/*
 * 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.
 */

/*
 * libfstyp module for hsfs
 */
#include <unistd.h>
#include <stropts.h>
#include <fcntl.h>
#include <stdio.h>
#include <strings.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/file.h>
#include <sys/cdio.h>
#include <sys/dkio.h>
#include <libnvpair.h>
#include <libfstyp_module.h>

#include <sys/fs/hsfs_spec.h>
#include <sys/fs/hsfs_isospec.h>

typedef struct fstyp_hsfs {
        int             fd;
        nvlist_t        *attr;
        char            hs_buf[ISO_SECTOR_SIZE];
        int             hs_pvd_sec_no;
        char            iso_buf[ISO_SECTOR_SIZE];
        int             iso_pvd_sec_no;
        char            unix_buf[ISO_SECTOR_SIZE];
        int             unix_pvd_sec_no;
        int             cdroff;
        int             cd_type;
} fstyp_hsfs_t;

#define GETCDSECTOR(h, buf, secno, nosec) (getdisk(h, buf, \
        ((secno)+(h)->cdroff)*ISO_SECTOR_SIZE, \
        (nosec)*ISO_SECTOR_SIZE))

#define NELEM(a)        sizeof (a) / sizeof (*(a))

static int      ckvoldesc(fstyp_hsfs_t *h, int *cd_type);
static int      findhsvol(fstyp_hsfs_t *h, char *volp);
static int      findisovol(fstyp_hsfs_t *h, char *volp);
static int      findunixvol(fstyp_hsfs_t *h, char *volp);
static char     *get_old_name(char *new);
static int      rdev_is_a_cd(int rdevfd);
static int      getdisk(fstyp_hsfs_t *h, char *buf, int daddr, int size);
static void     copy_string(char *d, char *s, int maxlen);
static int      is_hsfs(fstyp_hsfs_t *h);
static int      get_attr(fstyp_hsfs_t *h);

int     fstyp_mod_init(int fd, off_t offset, fstyp_mod_handle_t *handle);
void    fstyp_mod_fini(fstyp_mod_handle_t handle);
int     fstyp_mod_ident(fstyp_mod_handle_t handle);
int     fstyp_mod_get_attr(fstyp_mod_handle_t handle, nvlist_t **attrp);
int     fstyp_mod_dump(fstyp_mod_handle_t handle, FILE *fout, FILE *ferr);


int
fstyp_mod_init(int fd, off_t offset, fstyp_mod_handle_t *handle)
{
        fstyp_hsfs_t    *h = (fstyp_hsfs_t *)handle;

        if (offset != 0) {
                return (FSTYP_ERR_OFFSET);
        }

        if ((h = calloc(1, sizeof (fstyp_hsfs_t))) == NULL) {
                return (FSTYP_ERR_NOMEM);
        }
        h->fd = fd;

        *handle = (fstyp_mod_handle_t)h;
        return (0);
}

void
fstyp_mod_fini(fstyp_mod_handle_t handle)
{
        fstyp_hsfs_t    *h = (fstyp_hsfs_t *)handle;

        if (h->attr == NULL) {
                nvlist_free(h->attr);
                h->attr = NULL;
        }
        free(h);
}

int
fstyp_mod_ident(fstyp_mod_handle_t handle)
{
        fstyp_hsfs_t *h = (fstyp_hsfs_t *)handle;

        return (is_hsfs(h));
}

int
fstyp_mod_get_attr(fstyp_mod_handle_t handle, nvlist_t **attrp)
{
        fstyp_hsfs_t    *h = (fstyp_hsfs_t *)handle;
        int error;

        if (h->attr == NULL) {
                if (nvlist_alloc(&h->attr, NV_UNIQUE_NAME_TYPE, 0)) {
                        return (FSTYP_ERR_NOMEM);
                }
                if ((error = get_attr(h)) != 0) {
                        nvlist_free(h->attr);
                        h->attr = NULL;
                        return (error);
                }
        }

        *attrp = h->attr;
        return (0);
}

/* ARGSUSED */
int
fstyp_mod_dump(fstyp_mod_handle_t handle, FILE *fout, FILE *ferr)
{
        int             error;
        nvlist_t        *attr;
        nvpair_t        *elem = NULL;
        char            *str_value;
        uint64_t        uint64_value;
        char            *name;

        if ((error = fstyp_mod_get_attr(handle, &attr)) != 0) {
                return (error);
        }
        while ((elem = nvlist_next_nvpair(attr, elem)) != NULL) {
                /* format is special */
                if (strcmp(nvpair_name(elem), "format") == 0) {
                        (void) nvpair_value_string(elem, &str_value);
                        if (strcmp(str_value,
                            "ISO 9660 with UNIX extension") == 0) {
                                (void) fprintf(fout,
                                    "CD-ROM is in ISO 9660 format with"
                                    " UNIX extension\n");
                        } else {
                                (void) fprintf(fout, "CD-ROM is in %s"
                                    " format\n", str_value);
                        }
                        continue;
                }
                if ((name = get_old_name(nvpair_name(elem))) == NULL) {
                        continue;
                }
                if (nvpair_type(elem) == DATA_TYPE_STRING) {
                        (void) nvpair_value_string(elem, &str_value);
                        (void) fprintf(fout, "%s: %s\n", name, str_value);
                } else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
                        (void) nvpair_value_uint64(elem, &uint64_value);
                        (void) fprintf(fout, "%s %llu\n",
                            name, (u_longlong_t)uint64_value);
                }
        }

        return (0);
}

static char *
get_old_name(char *new)
{
        static char     *map[] = {
                "system_id",            "System id",
                "volume_id",            "Volume id",
                "volume_set_id",        "Volume set id",
                "publisher_id",         "Publisher id",
                "data_preparer_id",     "Data preparer id",
                "application_id",       "Application id",
                "copyright_file_id",    "Copyright File id",
                "abstract_file_id",     "Abstract File id",
                "bibliographic_file_id", "Bibliographic File id",
                "volume_set_size",      "Volume set size is",
                "volume_set_sequence_number", "Volume set sequence number is",
                "logical_block_size",   "Logical block size is",
                "volume_size",          "Volume size is"
        };
        int     i;
        char    *old = NULL;

        for (i = 0; i < NELEM(map) / 2; i++) {
                if (strcmp(new, map[i * 2]) == 0) {
                        old = map[i * 2 + 1];
                        break;
                }
        }
        return (old);
}

/*
 * findhsvol: check if the disk is in high sierra format
 *            return(1) if found, (0) otherwise
 *            if found, volp will point to the descriptor
 *
 */
static int
findhsvol(fstyp_hsfs_t *h, char *volp)
{
        int secno;
        int i;
        int err;

        secno = HS_VOLDESC_SEC;
        if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                return (err);
        }
        while (HSV_DESC_TYPE(volp) != VD_EOV) {
                for (i = 0; i < HSV_ID_STRLEN; i++)
                        if (HSV_STD_ID(volp)[i] != HSV_ID_STRING[i])
                                goto cantfind;
                if (HSV_STD_VER(volp) != HSV_ID_VER)
                        goto cantfind;
                switch (HSV_DESC_TYPE(volp)) {
                case VD_SFS:
                        h->hs_pvd_sec_no = secno-1;
                        return (0);
                case VD_EOV:
                        goto cantfind;
                }
                if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                        return (err);
                }
        }
cantfind:
        return (FSTYP_ERR_NO_MATCH);
}

/*
 * findisovol: check if the disk is in ISO 9660 format
 *            return(1) if found, (0) otherwise
 *            if found, volp will point to the descriptor
 *
 */
static int
findisovol(fstyp_hsfs_t *h, char *volp)
{
        int secno;
        int i;
        int err;

        secno = ISO_VOLDESC_SEC;
        if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                return (err);
        }
        while (ISO_DESC_TYPE(volp) != ISO_VD_EOV) {
                for (i = 0; i < ISO_ID_STRLEN; i++)
                        if (ISO_STD_ID(volp)[i] != ISO_ID_STRING[i])
                                goto cantfind;
                if (ISO_STD_VER(volp) != ISO_ID_VER)
                        goto cantfind;
                switch (ISO_DESC_TYPE(volp)) {
                case ISO_VD_PVD:
                        h->iso_pvd_sec_no = secno-1;
                        return (0);
                case ISO_VD_EOV:
                        goto cantfind;
                }
                if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                        return (err);
                }
        }
cantfind:
        return (FSTYP_ERR_NO_MATCH);
}

/*
 * findunixvol: check if the disk is in UNIX extension format
 *            return(1) if found, (0) otherwise
 *            if found, volp will point to the descriptor
 *
 */
static int
findunixvol(fstyp_hsfs_t *h, char *volp)
{
        int secno;
        int i;
        int err;

        secno = ISO_VOLDESC_SEC;
        if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                return (err);
        }
        while (ISO_DESC_TYPE(volp) != ISO_VD_EOV) {
                for (i = 0; i < ISO_ID_STRLEN; i++)
                        if (ISO_STD_ID(volp)[i] != ISO_ID_STRING[i])
                                goto cantfind;
                if (ISO_STD_VER(volp) != ISO_ID_VER)
                        goto cantfind;
                switch (ISO_DESC_TYPE(volp)) {
                case ISO_VD_UNIX:
                        h->unix_pvd_sec_no = secno-1;
                        return (0);
                case ISO_VD_EOV:
                        goto cantfind;
                }
                if ((err = GETCDSECTOR(h, volp, secno++, 1)) != 0) {
                        return (err);
                }
        }
cantfind:
        return (FSTYP_ERR_NO_MATCH);
}

static int
ckvoldesc(fstyp_hsfs_t *h, int *cd_type)
{
        int     err;

        if ((err = findhsvol(h, h->hs_buf)) == 0) {
                *cd_type = 0;
        } else if ((err = findisovol(h, h->iso_buf)) == 0) {
                if (findunixvol(h, h->unix_buf) == 0) {
                        *cd_type = 2;
                } else {
                        *cd_type = 1;
                }
        } else {
                *cd_type = -1;
        }

        return (err);
}

static int
is_hsfs(fstyp_hsfs_t *h)
{
#ifdef CDROMREADOFFSET
        int err;

        if (rdev_is_a_cd(h->fd)) {
                err = ioctl(h->fd, CDROMREADOFFSET, &h->cdroff);
                if (err == -1)
                        /*
                         *  This device doesn't support this ioctl.
                         *  That's OK.
                         */
                        h->cdroff = 0;
        }
#endif
        /* check volume descriptor */
        return (ckvoldesc(h, &h->cd_type));
}

#define ADD_STRING(h, name, value) \
        if (nvlist_add_string(h->attr, name, value) != 0) { \
                return (FSTYP_ERR_NOMEM); \
        }

#define ADD_UINT64(h, name, value) \
        if (nvlist_add_uint64(h->attr, name, value) != 0) { \
                return (FSTYP_ERR_NOMEM); \
        }

#define ADD_BOOL(h, name, value) \
        if (nvlist_add_boolean_value(h->attr, name, value) != 0) { \
                return (FSTYP_ERR_NOMEM); \
        }

static int
get_attr(fstyp_hsfs_t *h)
{
        char *sysid;
        char *volid;
        char *volsetid;
        char *pubid;
        char *prepid;
        char *applid;
        char *copyfile;
        char *absfile;
        char *bibfile;
        int volsetsize;
        int volsetseq;
        int blksize;
        int volsize;
        char s[256];

        switch (h->cd_type) {
        case 0:
                ADD_STRING(h, "format", "High Sierra");
                ADD_STRING(h, "gen_version", "High Sierra");
                sysid = (char *)HSV_sys_id(h->hs_buf);
                volid = (char *)HSV_vol_id(h->hs_buf);
                volsetid = (char *)HSV_vol_set_id(h->hs_buf);
                pubid = (char *)HSV_pub_id(h->hs_buf);
                prepid = (char *)HSV_prep_id(h->hs_buf);
                applid = (char *)HSV_appl_id(h->hs_buf);
                copyfile = (char *)HSV_copyr_id(h->hs_buf);
                absfile = (char *)HSV_abstr_id(h->hs_buf);
                bibfile = NULL;
                volsetsize = HSV_SET_SIZE(h->hs_buf);
                volsetseq = HSV_SET_SEQ(h->hs_buf);
                blksize = HSV_BLK_SIZE(h->hs_buf);
                volsize = HSV_VOL_SIZE(h->hs_buf);
                break;
        case 1:
                ADD_STRING(h, "format", "ISO 9660");
                ADD_STRING(h, "gen_version", "ISO 9660");
                sysid = (char *)ISO_sys_id(h->iso_buf);
                volid = (char *)ISO_vol_id(h->iso_buf);
                volsetid = (char *)ISO_vol_set_id(h->iso_buf);
                pubid = (char *)ISO_pub_id(h->iso_buf);
                prepid = (char *)ISO_prep_id(h->iso_buf);
                applid = (char *)ISO_appl_id(h->iso_buf);
                copyfile = (char *)ISO_copyr_id(h->iso_buf);
                absfile = (char *)ISO_abstr_id(h->iso_buf);
                bibfile = (char *)ISO_bibli_id(h->iso_buf);
                volsetsize = ISO_SET_SIZE(h->iso_buf);
                volsetseq = ISO_SET_SEQ(h->iso_buf);
                blksize = ISO_BLK_SIZE(h->iso_buf);
                volsize = ISO_VOL_SIZE(h->iso_buf);
                break;
        case 2:
                ADD_STRING(h, "format", "ISO 9660 with UNIX extension");
                ADD_STRING(h, "gen_version", "ISO 9660 with UNIX extension");
                sysid = (char *)ISO_sys_id(h->unix_buf);
                volid = (char *)ISO_vol_id(h->unix_buf);
                volsetid = (char *)ISO_vol_set_id(h->unix_buf);
                pubid = (char *)ISO_pub_id(h->unix_buf);
                prepid = (char *)ISO_prep_id(h->unix_buf);
                applid = (char *)ISO_appl_id(h->unix_buf);
                copyfile = (char *)ISO_copyr_id(h->unix_buf);
                absfile = (char *)ISO_abstr_id(h->unix_buf);
                bibfile = (char *)ISO_bibli_id(h->unix_buf);
                volsetsize = ISO_SET_SIZE(h->unix_buf);
                volsetseq = ISO_SET_SEQ(h->unix_buf);
                blksize = ISO_BLK_SIZE(h->unix_buf);
                volsize = ISO_VOL_SIZE(h->unix_buf);
                break;
        default:
                return (FSTYP_ERR_NO_MATCH);
        }

        copy_string(s, sysid, 32);
        ADD_STRING(h, "system_id", s);
        copy_string(s, volid, 32);
        ADD_STRING(h, "volume_id", s);
        ADD_STRING(h, "gen_volume_label", s);
        copy_string(s, volsetid, 128);
        ADD_STRING(h, "volume_set_id", s);
        copy_string(s, pubid, 128);
        ADD_STRING(h, "publisher_id", s);
        copy_string(s, prepid, 128);
        ADD_STRING(h, "data_preparer_id", s);
        copy_string(s, applid, 128);
        ADD_STRING(h, "application_id", s);
        copy_string(s, copyfile, 37);
        ADD_STRING(h, "copyright_file_id", s);
        copy_string(s, absfile, 37);
        ADD_STRING(h, "abstract_file_id", s);
        copy_string(s, bibfile, 37);
        ADD_STRING(h, "bibliographic_file_id", s);
        ADD_UINT64(h, "volume_set_size", volsetsize);
        ADD_UINT64(h, "volume_set_sequence_number", volsetseq);
        ADD_UINT64(h, "logical_block_size", blksize);
        ADD_UINT64(h, "volume_size", volsize);
        ADD_BOOL(h, "gen_clean", B_TRUE);

        return (0);
}

static void
copy_string(char *d, char *s, int maxlen)
{
        int i;

        /* strip off trailing zeros */
        for (i = maxlen-1; i >= 0; i--) {
                if (s[i] != ' ') {
                        break;
                }
        }

        maxlen = i+1;
        for (i = 0; i < maxlen; i++) {
                *d++ = s[i];
        }
        *d++ = '\0';
}

/* readdisk - read from cdrom image file */
static int
getdisk(fstyp_hsfs_t *h, char *buf, int daddr, int size)
{
        if (lseek(h->fd, daddr, L_SET) == -1) {
                return (FSTYP_ERR_IO);
        }
        if (read(h->fd, buf, size) != size) {
                return (FSTYP_ERR_IO);
        }
        return (0);
}

/*
 * rdev_is_a_cd  - return TRUE if the raw device identified by
 *                    a file descriptor is a CDROM device.
 *
 *                    return FALSE if the device can't be accessed
 *                    or is not a CDROM.
 */
static int
rdev_is_a_cd(int rdevfd)
{
        struct dk_cinfo dkc;

        if (ioctl(rdevfd, DKIOCINFO, &dkc) < 0)
                return (0);
        if (dkc.dki_ctype == DKC_CDROM)
                return (1);
        else
                return (0);
}