/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * rmf_misc.c :
 *      Miscelleneous routines for rmformat.
 */

#include <sys/types.h>
#include <stdio.h>
#include <sys/mnttab.h>
#include <volmgt.h>
#include <sys/dkio.h>
#include <sys/fdio.h>
#include <sys/vtoc.h>
#include <sys/termios.h>
#include <sys/mount.h>
#include <ctype.h>
#include <signal.h>
#include <sys/wait.h>
#include <dirent.h>
#include <priv_utils.h>
#include <stdarg.h>
#include "rmformat.h"

/*
 * Definitions.
 */
#define SENSE_KEY(rqbuf)        (rqbuf[2] & 0xf) /* scsi error category */
#define ASC(rqbuf)              (rqbuf[12])     /* additional sense code */
#define ASCQ(rqbuf)             (rqbuf[13])     /* ASC qualifier */

#define DEFAULT_SCSI_TIMEOUT    60
#define INQUIRY_CMD             0x12
#define RQBUFLEN                32
#define CD_RW                   1               /* CD_RW/CD-R   */
#define WRITE_10_CMD            0x2A
#define READ_INFO_CMD           0x51
#define SYNC_CACHE_CMD          0x35
#define CLOSE_TRACK_CMD         0x5B
#define MODE_SENSE_10_CMD       0x5A
#define DEVFS_PREFIX            "/devices"

int             uscsi_error;             /* used for debugging failed uscsi */
char            rqbuf[RQBUFLEN];
static uint_t   total_retries;
static struct   uscsi_cmd uscmd;
static char     ucdb[16];
uchar_t         uscsi_status, rqstatus, rqresid;
int             total_devices_found = 0;
int             removable_found = 0;

extern char     *global_intr_msg;
extern int      vol_running;
extern char     *dev_name;
extern int32_t  m_flag;

/*
 * ON-private functions from libvolmgt
 */
int     _dev_mounted(char *path);

/*
 * Function prototypes.
 */
static int              my_umount(char *mountp);
static int              my_volrmmount(char *real_name);
static int              vol_name_to_dev_node(char *vname, char *found);
static int              vol_lookup(char *supplied, char *found);
static device_t         *get_device(char *user_supplied, char *node);
static char             *get_physical_name(char *path);
static int              lookup_device(char *supplied, char *found);
static void             fini_device(device_t *dev);
static int              is_cd(char *node);
void                    *my_zalloc(size_t size);
void                    err_msg(char *fmt, ...);
int                     inquiry(int fd, uchar_t *inq);
struct uscsi_cmd        *get_uscsi_cmd(void);
int                     uscsi(int fd, struct uscsi_cmd *scmd);
int                     get_mode_page(int fd, int page_no, int pc, int buf_len,
                            uchar_t *buffer);
int                     mode_sense(int fd, uchar_t pc, int dbd, int page_len,
                            uchar_t *buffer);
uint16_t                read_scsi16(void *addr);
int                     check_device(device_t *dev, int cond);
static void             get_media_info(device_t *t_dev, char *sdev,
                            char *pname, char *sn);

extern void             process_p_flag(smedia_handle_t handle, int32_t fd);

void
my_perror(char *err_string)
{

        int error_no;
        if (errno == 0)
                return;

        error_no = errno;
        (void) fprintf(stderr, "%s", err_string);
        (void) fprintf(stderr, gettext(" : "));
        errno = error_no;
        perror("");
}

int32_t
get_confirmation()
{
        char c;

        (void) fprintf(stderr, gettext("Do you want to continue? (y/n)"));
        c = getchar();
        if (c == 'y' || c == 'Y')
                return (1);
        else if (c == 'n' || c == 'N')
                return (0);
        else {
                (void) fprintf(stderr, gettext("Invalid choice\n"));
                return (0);
        }
}


void
get_passwd(struct smwp_state *wp, int32_t confirm)
{
        char passwd[256], re_passwd[256];
        int32_t len;
        struct termios tio;
        int32_t echo_off = 0;
        FILE *in, *out;
        char *buf;


        in = fopen("/dev/tty", "r+");
        if (in == NULL) {
                in = stdin;
                out = stderr;
        } else {
                out = in;
        }

        /* Turn echoing off if it is on now.  */

        if (tcgetattr(fileno(in), &tio) < 0) {
                PERROR("Echo off ioctl failed");
                exit(1);
        }
        if (tio.c_lflag & ECHO) {
                tio.c_lflag &= ~ECHO;
                /* echo_off = tcsetattr(fileno(in), TCSAFLUSH, &tio) == 0; */
                echo_off = tcsetattr(fileno(in), TCSAFLUSH, &tio) == 0;
                tio.c_lflag |= ECHO;
        }

        /* CONSTCOND */
        while (1) {
                (void) fputs(
                    gettext("Please enter password (32 chars maximum):"),
                    out);
                (void) fflush(out);
                buf = fgets(passwd, (size_t)256, in);
                rewind(in);
                if (buf == NULL) {
                        PERROR("Error reading password");
                        continue;
                }
                len = strlen(passwd);
                (void) fputc('\n', out);
                len--;  /* To offset the \n */
                if ((len <= 0) || (len > 32)) {
                        (void) fprintf(stderr,
                            gettext("Invalid length of password \n"));
                        (void) fputs("Try again\n", out);
                        continue;
                }

                if (!confirm)
                        break;

                (void) fputs("Please reenter password:", out);
                (void) fflush(out);
                buf = fgets(re_passwd, (size_t)256, in);
                rewind(in);
                (void) fputc('\n', out);
                if ((buf == NULL) || strcmp(passwd, re_passwd)) {
                        (void) fputs("passwords did not match\n", out);
                        (void) fputs("Try again\n", out);
                } else {
                        break;
                }
        }
        wp->sm_passwd_len = len;
        (void) strncpy(wp->sm_passwd, passwd, wp->sm_passwd_len);
        wp->sm_version = SMWP_STATE_V_1;

        /* Restore echoing.  */
        if (echo_off)
                (void) tcsetattr(fileno(in), TCSAFLUSH, &tio);

}

int32_t
check_and_unmount_vold(char *device_name, int32_t flag)
{
        char *real_name;
        char *nm;
        char tmp_path_name[PATH_MAX];
        struct stat stat_buf;
        int32_t ret_val = 0;
        struct  mnttab  *mntp;
        FILE    *fp;
        int nl;

        DPRINTF1("Device name %s\n", device_name);

        if (volmgt_running() == 0) {
                DPRINTF("Vold not running\n");
                return (0);
        }
        if ((nm = volmgt_symname(device_name)) == NULL) {
                DPRINTF("path not managed\n");
                real_name = media_findname(device_name);
        } else {
                DPRINTF1("path managed as %s\n", nm);
                real_name = media_findname(nm);
                DPRINTF1("real name %s\n", real_name);
        }

        if (real_name == NULL)
                return (-1);

        /*
         * To find out whether the device has been mounted by
         * volume manager...
         *
         * Convert the real name to a block device address.
         * Do a partial match with the mnttab entries.
         * Make sure the match is in the beginning to avoid if
         * anybody puts a label similiar to volume manager path names.
         * Then use "volrmmount -e <dev_name>" if -U flag is set.
         */

        nl = strlen("/vol/dev/");

        if (strncmp(real_name, "/vol/dev/", nl) != 0)
                        return (0);
        if (real_name[nl] == 'r') {
                (void) snprintf(tmp_path_name, PATH_MAX, "%s%s", "/vol/dev/",
                    &real_name[nl + 1]);
        } else {
                (void) snprintf(tmp_path_name, PATH_MAX, "%s", real_name);
        }
        DPRINTF1("%s \n", tmp_path_name);
        ret_val = stat(tmp_path_name, &stat_buf);
        if (ret_val < 0) {
                PERROR("Could not stat");
                return (-1);
        }

        fp = fopen("/etc/mnttab", "r");

        if (fp == NULL) {
                PERROR("Could not open /etc/mnttab");
                return (-1);
        }

        mntp = (struct mnttab *)malloc(sizeof (struct mnttab));
        if (mntp == NULL) {
                PERROR("malloc failed");
                (void) fclose(fp);
                return (-1);
        }
        errno = 0;
        while (getmntent(fp, mntp) == 0) {
                if (errno != 0) {
                        PERROR("Error with mnttab");
                        (void) fclose(fp);
                        return (-1);
                }
                /* Is it a probable entry? */
                DPRINTF1(" %s \n", mntp->mnt_special);
                if (strstr(mntp->mnt_special, tmp_path_name) !=
                    mntp->mnt_special) {
                        /* Skip to next entry */
                        continue;
                } else {
                        DPRINTF1("Found!! %s\n", mntp->mnt_special);
                        ret_val = 1;
                        break;
                }
        }

        if (ret_val == 1) {
                if (flag) {
                        if (my_volrmmount(real_name) < 0) {
                                ret_val = -1;
                        }
                } else {
                        ret_val = -1;
                }
        }
        (void) fclose(fp);
        free(mntp);
        return (ret_val);
}

/*
 * This routine checks if a device has mounted partitions. The
 * device name is assumed to be /dev/rdsk/cNtNdNsN. So, this can
 * be used for SCSI and PCMCIA cards.
 * Returns
 *       0 : if not mounted
 *       1 : if successfully unmounted
 *      -1 : Any error or umount failed
 */

int32_t
check_and_unmount_scsi(char *device_name, int32_t flag)
{

        struct  mnttab  *mntrefp;
        struct  mnttab  *mntp;
        FILE    *fp;
        char block_dev_name[PATH_MAX];
        char tmp_name[PATH_MAX];
        int32_t  i, j;
        int32_t unmounted = 0;

        /*
         * If the device name is not a character special, anyway we
         * can not progress further
         */

        if (strncmp(device_name, "/dev/rdsk/c", strlen("/dev/rdsk/c")) != 0)
                return (0);

        (void) snprintf(block_dev_name, PATH_MAX, "/dev/%s",
            &device_name[strlen("/dev/r")]);
        fp = fopen("/etc/mnttab", "r");

        if (fp == NULL) {
                PERROR("Could not open /etc/mnttab");
                return (-1);
        }

        mntrefp = (struct mnttab *)malloc(sizeof (struct mnttab));
        if (mntrefp == NULL) {
                PERROR("malloc failed");
                (void) fclose(fp);
                return (-1);
        }

        mntp = (struct mnttab *)malloc(sizeof (struct mnttab));
        if (mntp == NULL) {
                PERROR("malloc failed");
                (void) fclose(fp);
                free(mntrefp);
                return (-1);
        }

        /* Try all the partitions */

        (void) snprintf(tmp_name, PATH_MAX, "/dev/%s",
            &device_name[strlen("/dev/r")]);

        tmp_name[strlen("/dev/dsk/c0t0d0s")] = '\0';

        errno = 0;
        while (getmntent(fp, mntp) == 0) {
                if (errno != 0) {
                        PERROR("Error with mnttab");
                        (void) fclose(fp);
                        return (-1);
                }
                /* Is it a probable entry? */
                if (strncmp(mntp->mnt_special, tmp_name, strlen(tmp_name))) {
                        /* Skip to next entry */
                        continue;
                }
                for (i = 0; i < NDKMAP; i++) {
                        /* Check for ufs style mount devices */
                        (void) snprintf(block_dev_name, PATH_MAX,
                            "%s%d", tmp_name, i);

                        if (strcmp(mntp->mnt_special, block_dev_name) == 0) {
                                if (flag) {
                                        if (my_umount(mntp->mnt_mountp) < 0) {
                                                (void) fclose(fp);
                                                return (-1);
                                        }
                                        unmounted = 1;
                                } else {
                                        (void) fclose(fp);
                                        return (-1);
                                }
                                /* Skip to next entry */
                                continue;
                        }

                        /* Try for :1 -> :24 for pcfs */

                        for (j = 1; j < 24; j++) {
                                (void) snprintf(block_dev_name, PATH_MAX,
                                    "%s%d:%d", tmp_name, i, j);

                                if (strcmp(mntp->mnt_special,
                                    block_dev_name) == 0) {
                                        if (flag) {
                                                if (my_umount(mntp->mnt_mountp)
                                                    < 0) {
                                                        (void) fclose(fp);
                                                        return (-1);
                                                }
                                                unmounted = 1;
                                        } else {
                                                (void) fclose(fp);
                                                return (-1);
                                        }
                                        /* Skip to next entry */
                                        continue;
                                }
                                (void) snprintf(block_dev_name, PATH_MAX,
                                    "%s%d:%c", tmp_name, i, 'b' + j);

                                if (strcmp(mntp->mnt_special,
                                    block_dev_name) == 0) {
                                        if (flag) {
                                                if (my_umount(mntp->mnt_mountp)
                                                    < 0) {
                                                        (void) fclose(fp);
                                                        return (-1);
                                                }
                                                unmounted = 1;
                                        } else {
                                                (void) fclose(fp);
                                                return (-1);
                                        }
                                        /* Skip to next entry */
                                        continue;
                                }
                        }
                }

        }

        if (unmounted)
                return (1);
        return (0);
}

/*
 * This routine checks if a device has mounted partitions. The
 * device name is assumed to be /dev/rdiskette. So, this can
 * be used for Floppy controllers
 * Returns
 *       0 : if not mounted
 *       1 : if successfully unmounted
 *      -1 : Any error or unmount failed
 */

int32_t
check_and_unmount_floppy(int32_t fd, int32_t flag)
{
        FILE    *fp = NULL;
        int32_t mfd;
        struct dk_cinfo dkinfo, dkinfo_tmp;
        struct mnttab   mnt_record;
        struct mnttab   *mp = &mnt_record;
        struct stat     stbuf;
        char    raw_device[PATH_MAX];
        int32_t found = 0;


        if (ioctl(fd, DKIOCINFO, &dkinfo) < 0) {
                return (-1);
        }

        if ((fp = fopen(MNTTAB, "r")) == NULL) {
                PERROR("Could not open /etc/mnttab");
                (void) close(fd);
                exit(3);
        }

        while (getmntent(fp, mp) == 0) {
                if (strstr(mp->mnt_special, "/dev/fd") == NULL &&
                    strstr(mp->mnt_special, "/dev/disket") == NULL &&
                    strstr(mp->mnt_special, "/dev/c") == NULL) {
                        continue;
                }

                (void) strcpy(raw_device, "/dev/r");
                (void) strcat(raw_device, mp->mnt_special + strlen("/dev/"));


                /*
                 * Attempt to open the device.  If it fails, skip it.
                 */

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);

                mfd = open(raw_device, O_RDWR | O_NDELAY);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (mfd < 0) {
                        continue;
                }

                /*
                 * Must be a character device
                 */
                if (fstat(mfd, &stbuf) < 0 || !S_ISCHR(stbuf.st_mode)) {
                        (void) close(mfd);
                        continue;
                }
                /*
                 * Attempt to read the configuration info on the disk.
                 */
                if (ioctl(mfd, DKIOCINFO, &dkinfo_tmp) < 0) {
                        (void) close(mfd);
                        continue;
                }
                /*
                 * Finished with the opened device
                 */
                (void) close(mfd);

                /*
                 * If it's not the disk we're interested in, it doesn't apply.
                 */
                if (dkinfo.dki_ctype != dkinfo_tmp.dki_ctype ||
                    dkinfo.dki_cnum != dkinfo_tmp.dki_cnum ||
                    dkinfo.dki_unit != dkinfo_tmp.dki_unit) {
                                continue;
                }
                /*
                 * It's a mount on the disk we're checking.  If we are
                 * checking whole disk, then we found trouble.  We can
                 * quit searching.
                 */

                if (flag) {
                        if (my_umount(mp->mnt_mountp) < 0) {
                                return (-1);
                        }
                        found = 1;
                } else {
                        return (-1);
                }
        }
        return (found);
}


int32_t
my_open(char *device_name, int32_t flags)
{
        char *real_name;
        char *nm;
        char tmp_path_name[PATH_MAX];
        struct stat stat_buf;
        int32_t ret_val;
        int32_t fd;
        int32_t have_read_priv = 0;
        DIR *dirp;
        struct dirent *dp;

        DPRINTF1("Device name %s\n", device_name);

        if ((nm = volmgt_symname(device_name)) == NULL) {
                DPRINTF("path not managed\n");
                real_name = media_findname(device_name);
        } else {
                DPRINTF1("path managed as %s\n", nm);
                real_name = media_findname(nm);
                DPRINTF1("real name %s\n", real_name);
        }

        if (real_name == NULL)
                return (-1);

        (void) strcpy(tmp_path_name, real_name);
        ret_val = stat(tmp_path_name, &stat_buf);
        if (ret_val < 0) {
                PERROR("Could not stat");
                return (-1);
        }
        if (S_ISDIR(stat_buf.st_mode)) {

                /*
                 * Open the directory and look for the
                 * first non '.' entry.
                 * Since raw_read and raw_writes are used, we don't
                 * need to access the backup slice.
                 * For PCMCIA Memory cards, raw_read and raw_writes are
                 * not supported, but that is not a problem as, only slice2
                 * is allowed on PCMCIA memory cards.
                 */

                /*
                 * First make sure we are operating with a /vol/....
                 * Otherwise it can dangerous,
                 * e.g. rmformat -s /dev/rdsk
                 * We should not look into the directory contents here.
                 */
                if (strncmp(tmp_path_name, "/vol/dev/", strlen("/vol/dev/"))
                    != 0) {
                        (void) fprintf(stderr, gettext("The specified device \
is not a raw device.\n"));
                        exit(1);
                }

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);

                dirp = opendir(tmp_path_name);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (dirp == NULL) {
                        return (-1);
                }

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);
                have_read_priv = 1;

                while ((dp = readdir(dirp)) != NULL) {

                        /* Turn off the privileges. */
                        (void) __priv_bracket(PRIV_OFF);
                        have_read_priv = 0;

                        DPRINTF1("Found %s\n", dp->d_name);
                        if ((strcmp(dp->d_name, ".") != 0) &&
                            (strcmp(dp->d_name, "..") != 0)) {
                                size_t len = strlen(tmp_path_name);

                                (void) snprintf(tmp_path_name + len,
                                    PATH_MAX - len, "/%s", dp->d_name);

                                DPRINTF1("tmp_pathname is %s\n", tmp_path_name);
                                break;
                        }

                        /* Turn on the privileges. */
                        (void) __priv_bracket(PRIV_ON);
                        have_read_priv = 1;
                }

                if (have_read_priv) {
                        /* drop the file_dac_read privilege */
                        (void) __priv_bracket(PRIV_OFF);
                        have_read_priv = 0;
                }

                (void) closedir(dirp);
        }


        if (volmgt_running() == 0) {
                /* Turn on privileges. */
                (void) __priv_bracket(PRIV_ON);
                have_read_priv = 1;
        }

        fd = open(tmp_path_name, flags);

        if (have_read_priv) {
                /* Turn off privileges. */
                (void) __priv_bracket(PRIV_OFF);
                have_read_priv = 0;
        }

        DPRINTF1("path opened %s\n", tmp_path_name);

        return (fd);
}

uint64_t
my_atoll(char *ptr)
{
        char *tmp_ptr = ptr;
        int32_t base = 10;
        uint64_t ret_val;

        while (*tmp_ptr) {
                if (isdigit(*tmp_ptr))
                        tmp_ptr++;
                else {
                        base = 16;
                        break;
                }
        }
        tmp_ptr = ptr;
        if (base == 16) {
                if (strlen(tmp_ptr) < 3) {
                        return (-1);
                }
                if (*tmp_ptr++ != '0' || (*tmp_ptr != 'x' && *tmp_ptr != 'X')) {
                        return (-1);
                }
                tmp_ptr++;
                while (*tmp_ptr) {
                        if (isxdigit(*tmp_ptr))
                                tmp_ptr++;
                        else {
                                return (-1);
                        }
                }
        }
        ret_val = (uint64_t)strtoull(ptr, (char **)NULL, 0);
        return (ret_val);
}

int32_t
write_sunos_label(int32_t fd, int32_t media_type)
{

        struct extvtoc v_toc;
        int32_t ret;

        (void) memset(&v_toc, 0, sizeof (struct extvtoc));

        /* Initialize the vtoc information */

        if (media_type == SM_FLOPPY) {
                struct fd_char fdchar;
                int32_t mult_factor;

                if (ioctl(fd, FDIOGCHAR, &fdchar) < 0) {
                        PERROR("FDIOGCHAR failed");
                        return (-1);
                }

                /* SPARC and x86 fd drivers use fdc_medium differently */
#if defined(__sparc)
                mult_factor = (fdchar.fdc_medium) ? 2 : 1;
#elif defined(__x86)
                mult_factor = (fdchar.fdc_medium == 5) ? 2 : 1;
#else
#error  No Platform defined
#endif /* defined(__sparc) */

                /* initialize the vtoc structure */
                v_toc.v_nparts = 3;

                v_toc.v_part[0].p_start = 0;
                v_toc.v_part[0].p_size = (fdchar.fdc_ncyl - 1) * 2 *
                    fdchar.fdc_secptrack * mult_factor;
                v_toc.v_part[1].p_start = (fdchar.fdc_ncyl - 1) * 2 *
                    fdchar.fdc_secptrack * mult_factor;
                v_toc.v_part[1].p_size = 2 * fdchar.fdc_secptrack * mult_factor;

                v_toc.v_part[2].p_start = 0;
                v_toc.v_part[2].p_size = fdchar.fdc_ncyl * 2 *
                    fdchar.fdc_secptrack * mult_factor;

        } else if (media_type == SM_SCSI_FLOPPY) {

                smedia_handle_t handle;
                smmedium_prop_t med_info;
                struct dk_geom dkgeom;


                /*
                 * call smedia_get_medium_property to get the
                 * correct media information, since DKIOCGMEDIAINFO
                 * may fail for unformatted media.
                 */

                handle = smedia_get_handle(fd);
                if (handle == NULL) {
                        (void) fprintf(stderr,
                        gettext("Failed to get libsmedia handle.\n"));

                        (void) close(fd);
                        return (-1);
                }


                if (smedia_get_medium_property(handle, &med_info) < 0) {
                        (void) fprintf(stderr,
                            gettext("Get medium property failed \n"));

                        (void) smedia_release_handle(handle);
                        (void) close(fd);
                        return (-1);
                }

                /* Fill in our own geometry information */

                dkgeom.dkg_pcyl = med_info.sm_pcyl;
                dkgeom.dkg_ncyl = med_info.sm_pcyl;
                dkgeom.dkg_nhead = med_info.sm_nhead;
                dkgeom.dkg_nsect = med_info.sm_nsect;
                dkgeom.dkg_acyl = 0;
                dkgeom.dkg_bcyl = 0;
                dkgeom.dkg_intrlv = 0;
                dkgeom.dkg_apc = 0;

                /*
                 * Try to set vtoc, if not successful we will
                 * continue to use the faked geometry information.
                 */

                (void) ioctl(fd, DKIOCSGEOM, &dkgeom);

                (void) smedia_release_handle(handle);

                /* we want the same partitioning as used for normal floppies */

                v_toc.v_part[0].p_start = 0;
                v_toc.v_part[0].p_size =  (diskaddr_t)(dkgeom.dkg_ncyl - 1) *
                    dkgeom.dkg_nhead * dkgeom.dkg_nsect;

                v_toc.v_part[1].p_start = (diskaddr_t)(dkgeom.dkg_ncyl - 1) *
                    dkgeom.dkg_nhead * dkgeom.dkg_nsect;
                v_toc.v_part[1].p_size =  dkgeom.dkg_nhead * dkgeom.dkg_nsect;

                v_toc.v_part[2].p_start = 0;
                v_toc.v_part[2].p_size = (diskaddr_t)dkgeom.dkg_ncyl *
                    dkgeom.dkg_nhead * dkgeom.dkg_nsect;

                /* both write_vtoc and DKIOCSVTOC require V_NUMPAR partitions */
                v_toc.v_nparts = V_NUMPAR;

        } else {

                return (0);
        }

        v_toc.v_sanity = VTOC_SANE;
        v_toc.v_version = V_VERSION;

        /*
         * The label structure is set up for DEV_BSIZE(512 byte) blocks,
         * even though a medium density diskette has 1024 byte blocks
         * See dklabel.h for more details.
         */
        v_toc.v_sectorsz = DEV_BSIZE;

        /* let the fd driver finish constructing the label and writing it. */


        /* Turn on the privileges. */
        (void) __priv_bracket(PRIV_ON);

        ret = write_extvtoc(fd, &v_toc);

        /* Turn off the privileges. */
        (void) __priv_bracket(PRIV_OFF);

        if (ret < 0) {
                PERROR("Write vtoc");
                DPRINTF1("Write vtoc failed errno:%d\n", errno);
                return (-1);
        }

        return (0);
}

static void
intr_sig_handler()
{
        char c;

        (void) fprintf(stderr, gettext(global_intr_msg));
        (void) fprintf(stderr,
            gettext("\nDo you want to stop formatting?(y/n)"));
        (void) fflush(stdout);
        rewind(stdin);
        while ((c = getchar()) == -1)
                ;
        if (c == 'y' || c == 'Y') {
                (void) fprintf(stderr, gettext("Format interrupted\n"));
                exit(1);
        } else if (c == 'n' || c == 'N')
                return;
        else {
                (void) fprintf(stderr, gettext("Did not interrupt\n"));
                return;
        }
}

static struct sigaction act, oact;
void
trap_SIGINT(void)
{

        act.sa_handler = intr_sig_handler;
        (void) memset(&act.sa_mask, 0, sizeof (sigset_t));
        act.sa_flags = SA_RESTART; /* | SA_NODEFER; */
        if (sigaction(SIGINT, &act, &oact) < 0) {
                DPRINTF("sigset failed\n");
                return;
        }
}

void
release_SIGINT(void)
{
        if (sigaction(SIGINT, &oact, (struct sigaction *)NULL) < 0) {
                DPRINTF("sigunset failed\n");
                return;
        }
}

int32_t
verify(smedia_handle_t handle, int32_t fd, diskaddr_t start_sector,
    uint32_t nblocks, char *buf,
    int32_t flag, int32_t blocksize, int32_t no_raw_rw)
{
        uint64_t ret;

        DPRINTF("ANALYSE MEDIA \n");


        if ((flag == VERIFY_READ) && (!no_raw_rw)) {

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);

                ret = smedia_raw_read(handle, start_sector, buf, nblocks *
                    blocksize);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (ret != (nblocks * blocksize))
                        return (-1);
                return (0);

        } else if ((flag == VERIFY_WRITE) && (!no_raw_rw)) {

                /* Turn on privileges. */
                (void) __priv_bracket(PRIV_ON);

                ret = smedia_raw_write(handle, start_sector, buf, nblocks *
                    blocksize);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (ret != (blocksize * nblocks))
                        return (-1);
                return (0);

        } else if ((flag == VERIFY_READ) && (no_raw_rw)) {
                ret = llseek(fd, start_sector * blocksize, SEEK_SET);
                if (ret != start_sector * blocksize) {
                        (void) fprintf(stderr, gettext("Seek failed\n"));
                        return (-2);
                }

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);

                ret = read(fd, buf, nblocks * blocksize);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (ret != nblocks * blocksize) {
                        return (-1);
                }
                return (0);
        } else if ((flag == VERIFY_WRITE) && (no_raw_rw)) {
                ret = llseek(fd, start_sector * blocksize, SEEK_SET);
                if (ret != start_sector * blocksize) {
                        (void) fprintf(stderr, gettext("Seek failed\n"));
                        return (-2);
                }

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);

                ret = write(fd, buf, nblocks * blocksize);

                /* Turn off the privileges. */
                (void) __priv_bracket(PRIV_OFF);

                if (ret != nblocks * blocksize) {
                        return (-1);
                }
                return (0);
        } else {
                DPRINTF("Illegal parameter to verify_analysis!\n");
                return (-1);
        }
}

static int
my_umount(char *mountp)
{
        pid_t   pid;    /* forked proc's pid */
        int     rval;   /* proc's return value */


        /* create a child to unmount the path */

        /* Turn on the privileges */
        (void) __priv_bracket(PRIV_ON);

        pid = fork();

        /* Turn off the privileges. */
        (void) __priv_bracket(PRIV_OFF);

        if (pid < 0) {
                PERROR("fork failed");
                exit(0);
        }

        if (pid == 0) {
                /* the child */
                /* get rid of those nasty err messages */
                DPRINTF1("call_unmount_prog: calling %s \n", mountp);

                /* Turn on the priviliges. */
                (void) __priv_bracket(PRIV_ON);

                if (execl("/usr/sbin/umount", "/usr/sbin/umount", mountp,
                    NULL) < 0) {
                        perror("exec failed");
                        /* Turn off the privileges */
                        (void) __priv_bracket(PRIV_OFF);
                        exit(-1);
                }
        }

        /* wait for the umount command to exit */
        rval = 0;
        if (waitpid(pid, &rval, 0) == pid) {
                if (WIFEXITED(rval)) {
                        if (WEXITSTATUS(rval) == 0) {
                                DPRINTF("umount : Success\n");
                                return (1);
                        }
                }
        }
        return (-1);
}

static int
my_volrmmount(char *real_name)
{
        int pid, rval;

        /* Turn on the privileges. */
        (void) __priv_bracket(PRIV_ON);

        pid = fork();

        /* Turn off the privileges. */
        (void) __priv_bracket(PRIV_OFF);

        /* create a child to unmount the path */
        if (pid < 0) {
                PERROR("fork failed");
                exit(0);
        }

        if (pid == 0) {
                /* the child */
                /* get rid of those nasty err messages */
                DPRINTF1("call_unmount_prog: calling %s \n",
                    "/usr/bin/volrmmount");

                /* Turn on the privileges. */
                (void) __priv_bracket(PRIV_ON);
                if (execl("/usr/bin/volrmmount", "/usr/bin/volrmmount", "-e",
                    real_name, NULL) < 0) {
                        PERROR("volrmmount exec failed");
                        /* Turn off the privileges */
                        (void) __priv_bracket(PRIV_OFF);
                        exit(-1);
                }
        } else if (waitpid(pid, &rval, 0) == pid) {
                if (WIFEXITED(rval)) {
                        if (WEXITSTATUS(rval) == 0) {
                                DPRINTF("volrmmount: Success\n");
                                return (1);
                        }
                }
        }
        return (-1);
}

int
find_device(int defer, char *tmpstr)
{
        DIR *dir;
        struct dirent *dirent;
        char sdev[PATH_MAX], dev[PATH_MAX], *pname;
        device_t *t_dev;
        int removable = 0;
        int device_type = 0;
        int hotpluggable = 0;
        struct dk_minfo mediainfo;
        static int found = 0;

        dir = opendir("/dev/rdsk");
        if (dir == NULL)
                return (-1);

        total_devices_found = 0;
        while ((dirent = readdir(dir)) != NULL) {
                if (dirent->d_name[0] == '.') {
                        continue;
                }
                (void) snprintf(sdev, PATH_MAX, "/dev/rdsk/%s",
                    dirent->d_name);
#ifdef sparc
                if (!strstr(sdev, "s2")) {
                        continue;
                }
#else /* x86 */
                if (vol_running) {
                        if (!(strstr(sdev, "s2") || strstr(sdev, "p0"))) {
                                continue;
                        }
                } else {
                        if (!strstr(sdev, "p0")) {
                                continue;
                        }
                }
#endif
                if (!lookup_device(sdev, dev)) {
                        continue;
                }
                if ((t_dev = get_device(NULL, dev)) == NULL) {
                        continue;
                }
                total_devices_found++;

                if ((!defer) && !found) {
                        char *sn, *tmpbuf;
                        /*
                         * dev_name is an optional command line input.
                         */
                        if (dev_name) {
                                if (strstr(dirent->d_name, tmpstr)) {
                                        found = 1;
                                } else if (!vol_running) {
                                        continue;
                                }
                        }
                        /*
                         * volmgt_symname() returns NULL if the device
                         * is not managed by volmgt.
                         */
                        sn = volmgt_symname(sdev);

                        if (vol_running && (sn != NULL)) {
                                if (strstr(sn, "dev") == NULL) {
                                        tmpbuf = (char *)my_zalloc(PATH_MAX);
                                        (void) strcpy(tmpbuf,
                                            "/vol/dev/aliases/");
                                        (void) strcat(tmpbuf, sn);
                                        free(sn);
                                        sn = tmpbuf;
                                }
                                if (dev_name && !found) {
                                        if (!strstr(tmpbuf, tmpstr)) {
                                                continue;
                                        } else {
                                                found = 1;
                                        }
                                }
                        }

                        /*
                         * Get device type information for CD/DVD devices.
                         */
                        if (is_cd(dev)) {
                                if (check_device(t_dev,
                                    CHECK_DEVICE_IS_DVD_WRITABLE)) {
                                        device_type = DK_DVDR;
                                } else if (check_device(t_dev,
                                    CHECK_DEVICE_IS_DVD_READABLE)) {
                                        device_type = DK_DVDROM;
                                } else if (check_device(t_dev,
                                    CHECK_DEVICE_IS_CD_WRITABLE)) {
                                        device_type = DK_CDR;
                                } else {
                                        device_type = DK_CDROM;
                                }
                        } else {
                                device_type = ioctl(t_dev->d_fd,
                                    DKIOCGMEDIAINFO, &mediainfo);
                                if (device_type < 0)
                                        device_type = 0;
                                else
                                        device_type = mediainfo.dki_media_type;
                        }

                        if (!ioctl(t_dev->d_fd, DKIOCREMOVABLE, &removable) &&
                            !ioctl(t_dev->d_fd, DKIOCHOTPLUGGABLE,
                            &hotpluggable)) {
                                if (removable || hotpluggable) {
                                        removable_found++;
                                        pname = get_physical_name(sdev);
                                        if (sn) {
                                                (void) printf("  %4d. "
                                                    "Volmgt Node: %s\n",
                                                    removable_found, sn);
                                                (void) printf("        "
                                                    "Logical Node: %s\n", sdev);
                                                (void) printf("        "
                                                    "Physical Node: %s\n",
                                                    pname);
                                        } else {
                                                (void) printf("  %4d. "
                                                    "Logical Node: %s\n",
                                                    removable_found, sdev);
                                                (void) printf("        "
                                                    "Physical Node: %s\n",
                                                    pname);
                                        }
                                        (void) printf("        Connected "
                                            "Device: %-8.8s %-16.16s "
                                            "%-4.4s\n",
                                            &t_dev->d_inq[8],
                                            &t_dev->d_inq[16],
                                            &t_dev->d_inq[32]);
                                        (void) printf("        Device "
                                            "Type: ");
                                } else
                                        continue;
                        } else
                                continue;

                        switch (device_type) {
                                case DK_CDROM:
                                        (void) printf("CD Reader\n");
                                        break;
                                case DK_CDR:
                                case DK_CDRW:
                                        (void) printf("CD Reader/Writer\n");
                                        break;
                                case DK_DVDROM:
                                        (void) printf("DVD Reader\n");
                                        break;
                                case DK_DVDR:
                                case DK_DVDRAM:
                                        (void) printf("DVD Reader/Writer\n");
                                        break;
                                case DK_FIXED_DISK:
                                        if (strstr((const char *)
                                            &t_dev->d_inq[16], "FD") ||
                                            strstr((const char *)
                                            &t_dev->d_inq[16], "LS-120"))
                                                (void) printf("Floppy "
                                                    "drive\n");
                                        else
                                                (void) printf("Removable\n");
                                        break;
                                case DK_FLOPPY:
                                        (void) printf("Floppy drive\n");
                                        break;
                                case DK_ZIP:
                                        (void) printf("Zip drive\n");
                                        break;
                                case DK_JAZ:
                                        (void) printf("Jaz drive\n");
                                        break;
                                default:
                                        (void) printf("<Unknown>\n");
                                        DPRINTF1("\t   %d\n", device_type);
                                        break;
                        }
                        get_media_info(t_dev, sdev, pname, sn);
                }
                fini_device(t_dev);
        }

        (void) closedir(dir);
        return (removable_found);
}

/*
 * Returns a device_t handle for a node returned by lookup_device()
 * and takes the user supplied name and stores it inside the node.
 */
static device_t *
get_device(char *user_supplied, char *node)
{
        device_t *dev;
        int fd;
        char devnode[PATH_MAX];
        int size;

        /*
         * we need to resolve any link paths to avoid fake files
         * such as /dev/rdsk/../../export/file.
         */
        size = resolvepath(node, devnode, PATH_MAX);
        if ((size <= 0) || (size >= (PATH_MAX - 1)))
                return (NULL);

        /* resolvepath may not return a null terminated string */
        devnode[size] = '\0';


        /* the device node must be in /devices/ or /vol/dev/rdsk */

        if ((strncmp(devnode, "/devices/", 9) != 0) &&
            (strncmp(devnode, "/vol/dev/rdsk", 13) != 0))
                return (NULL);

        /* Turn on the privileges. */
        (void) __priv_bracket(PRIV_ON);

        /*
         * Since we are currently running with the user euid it is
         * safe to try to open the file without checking access.
         */

        fd = open(devnode, O_RDONLY|O_NDELAY);

        /* Turn off the privileges. */
        (void) __priv_bracket(PRIV_OFF);

        if (fd < 0) {
                return (NULL);
        }

        dev = (device_t *)my_zalloc(sizeof (device_t));

        dev->d_node = (char *)my_zalloc(strlen(devnode) + 1);
        (void) strcpy(dev->d_node, devnode);

        dev->d_fd = fd;

        dev->d_inq = (uchar_t *)my_zalloc(INQUIRY_DATA_LENGTH);

        /* Turn on privileges. */
        (void) __priv_bracket(PRIV_ON);
        if (!inquiry(fd, dev->d_inq)) {
                DPRINTF1("USCSI ioctl failed %d\n",
                    uscsi_error);
                free(dev->d_inq);
                free(dev->d_node);
                (void) close(dev->d_fd);
                free(dev);
                /* Turn off privileges. */
                (void) __priv_bracket(PRIV_OFF);
                return (NULL);
        }
        /* Turn off privileges. */
        (void) __priv_bracket(PRIV_OFF);

        if (user_supplied) {
                dev->d_name = (char *)my_zalloc(strlen(user_supplied) + 1);
                (void) strcpy(dev->d_name, user_supplied);
        }
        return (dev);
}

/*
 * Check for device specific characteristics.
 */
int
check_device(device_t *dev, int cond)
{
        uchar_t page_code[4];

        /* Look at the capabilities page for this information */
        if (cond & CHECK_DEVICE_IS_CD_WRITABLE) {
                if (get_mode_page(dev->d_fd, 0x2a, 0, 4, page_code) &&
                    (page_code[3] & 1)) {
                        return (1);
                }
        }

        if (cond & CHECK_DEVICE_IS_DVD_WRITABLE) {
                if (get_mode_page(dev->d_fd, 0x2a, 0, 4, page_code) &&
                    (page_code[3] & 0x10)) {
                        return (1);
                }
        }

        if (cond & CHECK_DEVICE_IS_DVD_READABLE) {
                if (get_mode_page(dev->d_fd, 0x2a, 0, 4, page_code) &&
                    (page_code[2] & 0x8)) {
                        return (1);
                }
        }

        return (0);
}

/*
 * Builds an open()able device path from a user supplied node which can be
 * of the * form of /dev/[r]dsk/cxtxdx[sx] or cxtxdx[sx] or volmgt-name like
 * cdrom[n].
 * Returns the path found in 'found' and returns 1. Otherwise returns 0.
 */
int
lookup_device(char *supplied, char *found)
{
        struct stat statbuf;
        int fd;
        char tmpstr[PATH_MAX];

        /* Turn on privileges */
        (void) __priv_bracket(PRIV_ON);

        /* If everything is fine and proper, no need to analyze */
        if ((stat(supplied, &statbuf) == 0) && S_ISCHR(statbuf.st_mode) &&
            ((fd = open(supplied, O_RDONLY|O_NDELAY)) >= 0)) {
                (void) close(fd);
                (void) strlcpy(found, supplied, PATH_MAX);
                /* Turn off privilege */
                (void) __priv_bracket(PRIV_OFF);
                return (1);
        }

        /* Turn off privileges. */
        (void) __priv_bracket(PRIV_OFF);

        if (strncmp(supplied, "/dev/rdsk/", 10) == 0)
                return (vol_lookup(supplied, found));
        if (strncmp(supplied, "/dev/dsk/", 9) == 0) {
                (void) snprintf(tmpstr, PATH_MAX, "/dev/rdsk/%s",
                    (char *)strrchr(supplied, '/'));

                if ((fd = open(tmpstr, O_RDONLY|O_NDELAY)) >= 0) {
                        (void) close(fd);
                        (void) strlcpy(found, supplied, PATH_MAX);
                        return (1);
                }
                if ((access(tmpstr, F_OK) == 0) && vol_running)
                        return (vol_lookup(tmpstr, found));
                else
                        return (0);
        }
        if ((strncmp(supplied, "cdrom", 5) != 0) &&
            (strlen(supplied) < 32)) {
                (void) snprintf(tmpstr, sizeof (tmpstr), "/dev/rdsk/%s",
                    supplied);
                if (access(tmpstr, F_OK) < 0) {
                        (void) strcat(tmpstr, "s2");
                }
                if ((fd = open(tmpstr, O_RDONLY|O_NDELAY)) >= 0) {
                        (void) close(fd);
                        (void) strlcpy(found, tmpstr, PATH_MAX);
                        return (1);
                }
                if ((access(tmpstr, F_OK) == 0) && vol_running)
                        return (vol_lookup(tmpstr, found));
        }
        return (vol_name_to_dev_node(supplied, found));
}

int
is_cd(char *node)
{
        int fd;
        struct dk_cinfo cinfo;

        fd = open(node, O_RDONLY|O_NDELAY);
        if (fd < 0)
                return (0);
        if (ioctl(fd, DKIOCINFO, &cinfo) < 0) {
                (void) close(fd);
                return (0);
        }
        if (cinfo.dki_ctype != DKC_CDROM)
                return (0);
        return (1);
}

void
print_header(void)
{
        /* l10n_NOTE : Column spacing should be kept same */
        (void) printf(gettext("    Node                        "
            "Connected Device"));
        /* l10n_NOTE : Column spacing should be kept same */
        (void) printf(gettext("                 Device type\n"));
        (void) printf(
            "---------------------------+---------------------------");
        (void) printf("-----+----------------\n");
}

void
print_divider(void)
{
        (void) printf(
            "---------------------------+---------------------------");
        (void) printf("-----+----------------\n");
}

static void
fini_device(device_t *dev)
{
        free(dev->d_inq);
        free(dev->d_node);
        (void) close(dev->d_fd);
        if (dev->d_name)
                free(dev->d_name);
        free(dev);
}

void *
my_zalloc(size_t size)
{
        void *ret;

        ret = malloc(size);
        if (ret == NULL) {

                /* Lets wait a sec. and try again */
                if (errno == EAGAIN) {
                        (void) sleep(1);
                        ret = malloc(size);
                }

                if (ret == NULL) {
                        (void) err_msg("%s\n", gettext(strerror(errno)));
                        (void) err_msg(gettext(
                            "Memory allocation failure, Exiting...\n"));
                        exit(1);
                }
        }
        (void) memset(ret, 0, size);
        return (ret);
}

static int
vol_name_to_dev_node(char *vname, char *found)
{
        struct stat statbuf;
        char *p1;
        int i;

        if (vname == NULL)
                return (0);
        if (vol_running)
                (void) volmgt_check(vname);
        p1 = media_findname(vname);
        if (p1 == NULL)
                return (0);
        if (stat(p1, &statbuf) < 0) {
                free(p1);
                return (0);
        }
        if (S_ISDIR(statbuf.st_mode)) {
                for (i = 0; i < 16; i++) {
                        (void) snprintf(found, PATH_MAX, "%s/s%d", p1, i);
                        if (access(found, F_OK) >= 0)
                                break;
                }
                if (i == 16) {
                        free(p1);
                        return (0);
                }
        } else {
                (void) strlcpy(found, p1, PATH_MAX);
        }
        free(p1);
        return (1);
}

/*
 * Searches for volume manager's equivalent char device for the
 * supplied pathname which is of the form of /dev/rdsk/cxtxdxsx
 */
static int
vol_lookup(char *supplied, char *found)
{
        char tmpstr[PATH_MAX], tmpstr1[PATH_MAX], *p;
        int i, ret;

        (void) strlcpy(tmpstr, supplied, PATH_MAX);
        if ((p = volmgt_symname(tmpstr)) == NULL) {
                if (strstr(tmpstr, "s2") != NULL) {
                        *((char *)(strrchr(tmpstr, 's') + 1)) = 0;
                        for (i = 0; i < 16; i++) {
                                (void) snprintf(tmpstr1, PATH_MAX, "%s%d",
                                    tmpstr, i);
                                if ((p = volmgt_symname(tmpstr1)) != NULL)
                                        break;
                        }
                } else if (strstr(tmpstr, "p0") != NULL) {
                        *((char *)(strrchr(tmpstr, 'p') + 1)) = 0;
                        for (i = 0; i < 5; i++) {
                                (void) snprintf(tmpstr1, PATH_MAX, "%s%d",
                                    tmpstr, i);
                                if ((p = volmgt_symname(tmpstr1)) != NULL)
                                        break;
                        }
                } else
                        return (0);
                if (p == NULL)
                        return (0);
        }

        ret = vol_name_to_dev_node(p, found);
        free(p);
        return (ret);
}

/*PRINTFLIKE1*/
void
err_msg(char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        (void) vfprintf(stderr, fmt, ap);
        va_end(ap);
}

int
inquiry(int fd, uchar_t *inq)
{
        struct uscsi_cmd *scmd;

        scmd = get_uscsi_cmd();
        scmd->uscsi_flags = USCSI_READ|USCSI_SILENT;
        scmd->uscsi_timeout = DEFAULT_SCSI_TIMEOUT;
        scmd->uscsi_cdb[0] = INQUIRY_CMD;
        scmd->uscsi_cdb[4] = INQUIRY_DATA_LENGTH;
        scmd->uscsi_cdblen = 6;
        scmd->uscsi_bufaddr = (char *)inq;
        scmd->uscsi_buflen = INQUIRY_DATA_LENGTH;
        if ((uscsi_error = uscsi(fd, scmd)) < 0)
                return (0);
        return (1);
}

struct uscsi_cmd *
get_uscsi_cmd(void)
{
        (void) memset(&uscmd, 0, sizeof (uscmd));
        (void) memset(ucdb, 0, 16);
        uscmd.uscsi_cdb = ucdb;
        return (&uscmd);
}

int
uscsi(int fd, struct uscsi_cmd *scmd)
{
        int ret, global_rqsense;
        int retries, max_retries = 5;
        int i;

        /* set up for request sense extensions */
        if (!(scmd->uscsi_flags & USCSI_RQENABLE)) {
                scmd->uscsi_flags |= USCSI_RQENABLE;
                scmd->uscsi_rqlen = RQBUFLEN;
                scmd->uscsi_rqbuf = rqbuf;
                global_rqsense = 1;
        } else {
                global_rqsense = 0;
        }

        /*
         * The device may be busy or slow and fail with a not ready status.
         * we'll allow a limited number of retries to give the drive time
         * to recover.
         */
        for (retries = 0; retries < max_retries; retries++) {

                scmd->uscsi_status = 0;

                if (global_rqsense)
                        (void) memset(rqbuf, 0, RQBUFLEN);

                DPRINTF("cmd:[");
                for (i = 0; i < scmd->uscsi_cdblen; i++)
                        DPRINTF1("0x%02x ",
                            (uchar_t)scmd->uscsi_cdb[i]);
                DPRINTF("]\n");

                /*
                 * We need to have root privledges in order to use
                 * uscsi commands on the device.
                 */

                ret = ioctl(fd, USCSICMD, scmd);

                /* maintain consistency in case of sgen */
                if ((ret == 0) && (scmd->uscsi_status == 2)) {
                        ret = -1;
                        errno = EIO;
                }

                /* if error and extended request sense, retrieve errors */
                if (global_rqsense && (ret < 0) && (scmd->uscsi_status == 2)) {
                        /*
                         * The drive is not ready to recieve commands but
                         * may be in the process of becoming ready.
                         * sleep for a short time then retry command.
                         * SENSE/ASC = 2/4 : not ready
                         * ASCQ = 0  Not Reportable.
                         * ASCQ = 1  Becoming ready.
                         */
                        if ((SENSE_KEY(rqbuf) == 2) && (ASC(rqbuf) == 4) &&
                            ((ASCQ(rqbuf) == 0) || (ASCQ(rqbuf) == 1))) {
                                total_retries++;
                                (void) sleep(3);
                                continue;
                        }

                        /*
                         * Device is not ready to transmit or a device reset
                         * has occurred. wait for a short period of time then
                         * retry the command.
                         */
                        if ((SENSE_KEY(rqbuf) == 6) && ((ASC(rqbuf) == 0x28) ||
                            (ASC(rqbuf) == 0x29))) {
                                (void) sleep(3);
                                total_retries++;
                                continue;
                        }

                        DPRINTF3("cmd: 0x%02x ret:%i status:%02x ",
                            (uchar_t)scmd->uscsi_cdb[0], ret,
                            scmd->uscsi_status);
                        DPRINTF3(" sense: %02x ASC: %02x ASCQ:%02x\n",
                            (uchar_t)SENSE_KEY(rqbuf),
                            (uchar_t)ASC(rqbuf), (uchar_t)ASCQ(rqbuf));
                }

                /* no errors we'll return */
                break;
        }

        /* store the error status for later debug printing */
        if ((ret < 0) && (global_rqsense)) {
                uscsi_status = scmd->uscsi_status;
                rqstatus = scmd->uscsi_rqstatus;
                rqresid = scmd->uscsi_rqresid;

        }

        DPRINTF1("total retries: %d\n", total_retries);

        return (ret);
}

/*
 * will get the mode page only i.e. will strip off the header.
 */
int
get_mode_page(int fd, int page_no, int pc, int buf_len, uchar_t *buffer)
{
        int ret;
        uchar_t byte2, *buf;
        uint_t header_len, page_len, copy_cnt;

        byte2 = (uchar_t)(((pc << 6) & 0xC0) | (page_no & 0x3f));
        buf = (uchar_t *)my_zalloc(256);

        /* Ask 254 bytes only to make our IDE driver happy */
        ret = mode_sense(fd, byte2, 1, 254, buf);
        if (ret == 0) {
                free(buf);
                return (0);
        }

        header_len = 8 + read_scsi16(&buf[6]);
        page_len = buf[header_len + 1] + 2;

        copy_cnt = (page_len > buf_len) ? buf_len : page_len;
        (void) memcpy(buffer, &buf[header_len], copy_cnt);
        free(buf);

        return (1);
}

int
mode_sense(int fd, uchar_t pc, int dbd, int page_len, uchar_t *buffer)
{
        struct uscsi_cmd *scmd;

        scmd = get_uscsi_cmd();
        scmd->uscsi_flags = USCSI_READ|USCSI_SILENT;
        scmd->uscsi_buflen = page_len;
        scmd->uscsi_bufaddr = (char *)buffer;
        scmd->uscsi_timeout = DEFAULT_SCSI_TIMEOUT;
        scmd->uscsi_cdblen = 0xa;
        scmd->uscsi_cdb[0] = MODE_SENSE_10_CMD;
        if (dbd) {
                /* don't return any block descriptors */
                scmd->uscsi_cdb[1] = 0x8;
        }
        /* the page code we want */
        scmd->uscsi_cdb[2] = pc;
        /* allocation length */
        scmd->uscsi_cdb[7] = (page_len >> 8) & 0xff;
        scmd->uscsi_cdb[8] = page_len & 0xff;

        if ((uscsi_error = uscsi(fd, scmd)) < 0)
                return (0);
        return (1);
}

uint16_t
read_scsi16(void *addr)
{
        uchar_t *ad = (uchar_t *)addr;
        uint16_t ret;

        ret = ((((uint16_t)ad[0]) << 8) | ad[1]);
        return (ret);
}

/*
 * Allocate space for and return a pointer to a string
 * on the stack.  If the string is null, create
 * an empty string.
 * Use destroy_data() to free when no longer used.
 */
char *
alloc_string(char *s)
{
        char    *ns;

        if (s == (char *)NULL) {
                ns = (char *)my_zalloc(1);
        } else {
                ns = (char *)my_zalloc(strlen(s) + 1);
                (void) strcpy(ns, s);
        }
        return (ns);
}

/*
 * Follow symbolic links from the logical device name to
 * the /devfs physical device name.  To be complete, we
 * handle the case of multiple links.  This function
 * either returns NULL (no links, or some other error),
 * or the physical device name, alloc'ed on the heap.
 *
 * Note that the standard /devices prefix is stripped from
 * the final pathname, if present.  The trailing options
 * are also removed (":c, raw").
 */
static char *
get_physical_name(char *path)
{
        struct stat     stbuf;
        int             i;
        int             level;
        char            *p;
        char            s[MAXPATHLEN];
        char            buf[MAXPATHLEN];
        char            dir[MAXPATHLEN];
        char            savedir[MAXPATHLEN];
        char            *result = NULL;

        if (getcwd(savedir, sizeof (savedir)) == NULL) {
                DPRINTF1("getcwd() failed - %s\n", strerror(errno));
                return (NULL);
        }

        (void) strcpy(s, path);
        if ((p = strrchr(s, '/')) != NULL) {
                *p = 0;
        }
        if (s[0] == 0) {
                (void) strcpy(s, "/");
        }
        if (chdir(s) == -1) {
                DPRINTF2("cannot chdir() to %s - %s\n",
                    s, strerror(errno));
                goto exit;
        }

        level = 0;
        (void) strcpy(s, path);
        for (;;) {
                /*
                 * See if there's a real file out there.  If not,
                 * we have a dangling link and we ignore it.
                 */
                if (stat(s, &stbuf) == -1) {
                        goto exit;
                }
                if (lstat(s, &stbuf) == -1) {
                        DPRINTF2("%s: lstat() failed - %s\n",
                            s, strerror(errno));
                        goto exit;
                }
                /*
                 * If the file is not a link, we're done one
                 * way or the other.  If there were links,
                 * return the full pathname of the resulting
                 * file.
                 */
                if (!S_ISLNK(stbuf.st_mode)) {
                        if (level > 0) {
                                /*
                                 * Strip trailing options from the
                                 * physical device name
                                 */
                                if ((p = strrchr(s, ':')) != NULL) {
                                        *p = 0;
                                }
                                /*
                                 * Get the current directory, and
                                 * glue the pieces together.
                                 */
                                if (getcwd(dir, sizeof (dir)) == NULL) {
                                        DPRINTF1("getcwd() failed - %s\n",
                                            strerror(errno));
                                        goto exit;
                                }
                                (void) strcat(dir, "/");
                                (void) strcat(dir, s);
                                /*
                                 * If we have the standard fixed
                                 * /devices prefix, remove it.
                                 */
                                p = (strstr(dir, DEVFS_PREFIX) == dir) ?
                                    dir+strlen(DEVFS_PREFIX) : dir;
                                result = alloc_string(p);
                        }
                        goto exit;
                }
                i = readlink(s, buf, sizeof (buf));
                if (i == -1) {
                        DPRINTF2("%s: readlink() failed - %s\n",
                            s, strerror(errno));
                        goto exit;
                }
                level++;
                buf[i] = 0;

                /*
                 * Break up the pathname into the directory
                 * reference, if applicable and simple filename.
                 * chdir()'ing to the directory allows us to
                 * handle links with relative pathnames correctly.
                 */
                (void) strcpy(dir, buf);
                if ((p = strrchr(dir, '/')) != NULL) {
                        *p = 0;
                        if (chdir(dir) == -1) {
                                DPRINTF2("cannot chdir() to %s - %s\n",
                                    dir, strerror(errno));
                                goto exit;
                        }
                        (void) strcpy(s, p+1);
                } else {
                        (void) strcpy(s, buf);
                }
        }

exit:
        if (chdir(savedir) == -1) {
                (void) printf("cannot chdir() to %s - %s\n",
                    savedir, strerror(errno));
        }

        return (result);
}

static void
get_media_info(device_t *t_dev, char *sdev, char *pname, char *sn)
{
        struct dk_cinfo cinfo;
        struct extvtoc vtocinfo;
        float size;
        int32_t fd;
        smedia_handle_t handle;
        struct dk_minfo mediainfo;
        int device_type;

        device_type = ioctl(t_dev->d_fd, DKIOCGMEDIAINFO, &mediainfo);

        /*
         * Determine bus type.
         */
        if (!ioctl(t_dev->d_fd, DKIOCINFO, &cinfo)) {
                if (strstr(cinfo.dki_cname, "usb") || strstr(pname, "usb")) {
                        (void) printf("\tBus: USB\n");
                } else if (strstr(cinfo.dki_cname, "firewire") ||
                    strstr(pname, "firewire")) {
                        (void) printf("\tBus: Firewire\n");
                } else if (strstr(cinfo.dki_cname, "ide") ||
                    strstr(pname, "ide")) {
                        (void) printf("\tBus: IDE\n");
                } else if (strstr(cinfo.dki_cname, "scsi") ||
                    strstr(pname, "scsi")) {
                        (void) printf("\tBus: SCSI\n");
                } else {
                        (void) printf("\tBus: <Unknown>\n");
                }
        } else {
                (void) printf("\tBus: <Unknown>\n");
        }

        /*
         * Calculate size of media.
         */
        if (!device_type &&
            (!ioctl(t_dev->d_fd, DKIOCGMEDIAINFO, &mediainfo))) {
                size = (mediainfo.dki_lbsize*
                    mediainfo.dki_capacity)/(1024.0*1024.0);
                if (size < 1000) {
                        (void) printf("\tSize: %.1f MB\n", size);
                } else {
                        size = size/1000;
                        (void) printf("\tSize: %.1f GB\n", size);
                }
        } else {
                (void) printf("\tSize: <Unknown>\n");
        }

        /*
         * Print label.
         */
        if (!device_type && (read_extvtoc(t_dev->d_fd,  &vtocinfo) >= 0)) {
                if (*vtocinfo.v_volume) {
                        (void) printf("\tLabel: %s\n", vtocinfo.v_volume);
                } else {
                        (void) printf("\tLabel: <None>\n");
                }
        } else {
                (void) printf("\tLabel: <Unknown>\n");
        }

        /*
         * Acess permissions.
         */
        if (device_type) {
                (void) printf("\tAccess permissions: <Unknown>\n");
                return;
        }

        (void) fprintf(stdout, gettext("\tAccess permissions: "));
        if (sn) {
                /*
                 * Set dev_name for process_p_flag().
                 */
                dev_name = sn;
                fd = my_open(sn, O_RDONLY|O_NDELAY);
        } else {
                dev_name = sdev;
                fd = my_open(sdev, O_RDONLY|O_NDELAY);
        }
        if (fd < 0)  {
                (void) printf("<Unknown>\n");
                DPRINTF("Could not open device.\n");
                (void) close(fd);
        } else {
                /* register the fd with the libsmedia */
                handle = smedia_get_handle(fd);
                if (handle == NULL) {
                        (void) printf("<Unknown>\n");
                        DPRINTF("Failed to get libsmedia handle.\n");
                        (void) close(fd);
                } else {
                        process_p_flag(handle, fd);
                }
        }
        /* Clear dev_name */
        dev_name = NULL;
}