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

/*  Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
/*    All Rights Reserved   */

/*
 * Portions of this source code were derived from Berkeley 4.3 BSD
 * under license from the Regents of the University of California.
 */

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

/*
 * libfstyp module for pcfs
 */
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mntent.h>
#include <errno.h>
#include <sys/fs/pc_fs.h>
#include <sys/fs/pc_label.h>
#include <sys/fs/pc_dir.h>
#include <sys/stat.h>
#include <sys/vfs.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <sys/mnttab.h>
#include <locale.h>
#include <libfstyp_module.h>

#define PC_LABEL_SIZE 11

/* for the <sys/fs/pc_dir.h> PCDL_IS_LFN macro */
int enable_long_filenames = 1;

struct fstyp_fat16_bs {
    uint8_t     f_drvnum;
    uint8_t     f_reserved1;
    uint8_t     f_bootsig;
    uint8_t     f_volid[4];
    uint8_t     f_label[11];
    uint8_t     f_typestring[8];
};

struct fstyp_fat32_bs {
    uint32_t    f_fatlength;
    uint16_t    f_flags;
    uint8_t     f_major;
    uint8_t     f_minor;
    uint32_t    f_rootcluster;
    uint16_t    f_infosector;
    uint16_t    f_backupboot;
    uint8_t     f_reserved2[12];
    uint8_t     f_drvnum;
    uint8_t     f_reserved1;
    uint8_t     f_bootsig;
    uint8_t     f_volid[4];
    uint8_t     f_label[11];
    uint8_t     f_typestring[8];
};

typedef struct fstyp_pcfs {
    int     fd;
    off_t       offset;
    nvlist_t    *attr;
    struct bootsec  bs;
    struct fstyp_fat16_bs bs16;
    struct fstyp_fat32_bs bs32;
    ushort_t    bps;
    int     fattype;
    char        volume_label[PC_LABEL_SIZE + 1];

    /* parameters derived or calculated per FAT spec */
    ulong_t     FATSz;
    ulong_t     TotSec;
    ulong_t     RootDirSectors;
    ulong_t     FirstDataSector;
    ulong_t     DataSec;
    ulong_t     CountOfClusters;
} fstyp_pcfs_t;


/* We should eventually make the structs "packed" so these won't be needed */
#define PC_BPSEC(h) ltohs((h)->bs.bps[0])
#define PC_RESSEC(h)    ltohs((h)->bs.res_sec[0])
#define PC_NROOTENT(h)  ltohs((h)->bs.rdirents[0])
#define PC_NSEC(h)  ltohs((h)->bs.numsect[0])
#define PC_DRVNUM(h)    (FSTYP_IS_32(h) ? (h)->bs32.f_drvnum : \
                (h)->bs16.f_drvnum)
#define PC_VOLID(a) (FSTYP_IS_32(h) ? ltohi((h)->bs32.f_volid[0]) : \
                ltohi((h)->bs16.f_volid[0]))
#define PC_LABEL_ADDR(a) (FSTYP_IS_32(h) ? \
                &((h)->bs32.f_label[0]) : &((h)->bs16.f_label[0]))

#define FSTYP_IS_32(h)  ((h)->fattype == 32)

#define FSTYP_MAX_CLUSTER_SIZE  (64 * 1024) /* though officially 32K */
#define FSTYP_MAX_DIR_SIZE  (65536 * 32)

static int  read_bootsec(fstyp_pcfs_t *h);
static int  valid_media(fstyp_pcfs_t *h);
static int  well_formed(fstyp_pcfs_t *h);
static void calculate_parameters(fstyp_pcfs_t *h);
static void determine_fattype(fstyp_pcfs_t *h);
static void get_label(fstyp_pcfs_t *h);
static void get_label_16(fstyp_pcfs_t *h);
static void get_label_32(fstyp_pcfs_t *h);
static int  next_cluster_32(fstyp_pcfs_t *h, int n);
static boolean_t dir_find_label(fstyp_pcfs_t *h, struct pcdir *d, int nent);
static int  is_pcfs(fstyp_pcfs_t *h);
static int  dumpfs(fstyp_pcfs_t *h, FILE *fout, FILE *ferr);
static int  get_attr(fstyp_pcfs_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)
{
    struct fstyp_pcfs *h;

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

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

void
fstyp_mod_fini(fstyp_mod_handle_t handle)
{
    struct fstyp_pcfs *h = (struct fstyp_pcfs *)handle;

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

int
fstyp_mod_ident(fstyp_mod_handle_t handle)
{
    struct fstyp_pcfs *h = (struct fstyp_pcfs *)handle;

    return (is_pcfs(h));
}

int
fstyp_mod_get_attr(fstyp_mod_handle_t handle, nvlist_t **attrp)
{
    struct fstyp_pcfs *h = (struct fstyp_pcfs *)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);
}

int
fstyp_mod_dump(fstyp_mod_handle_t handle, FILE *fout, FILE *ferr)
{
    struct fstyp_pcfs *h = (struct fstyp_pcfs *)handle;

    return (dumpfs(h, fout, ferr));
}


/*
 * Read in boot sector. Convert into host endianness where possible.
 */
static int
read_bootsec(fstyp_pcfs_t *h)
{
    char    buf[PC_SECSIZE];

    (void) lseek(h->fd, h->offset, SEEK_SET);
    if (read(h->fd, buf, sizeof (buf)) != sizeof (buf)) {
        return (FSTYP_ERR_IO);
    }

    bcopy(buf, &h->bs, sizeof (h->bs));
    bcopy(buf + sizeof (struct bootsec), &h->bs16, sizeof (h->bs16));
    bcopy(buf + sizeof (struct bootsec), &h->bs32, sizeof (h->bs32));

    h->bs.fatsec = ltohs(h->bs.fatsec);
    h->bs.spt = ltohs(h->bs.spt);
    h->bs.nhead = ltohs(h->bs.nhead);
    h->bs.hiddensec = ltohi(h->bs.hiddensec);
    h->bs.totalsec = ltohi(h->bs.totalsec);

    h->bs32.f_fatlength = ltohi(h->bs32.f_fatlength);
    h->bs32.f_flags = ltohs(h->bs32.f_flags);
    h->bs32.f_rootcluster = ltohi(h->bs32.f_rootcluster);
    h->bs32.f_infosector = ltohs(h->bs32.f_infosector);
    h->bs32.f_backupboot = ltohs(h->bs32.f_backupboot);

    h->bps = PC_BPSEC(h);

    return (0);
}

static int
valid_media(fstyp_pcfs_t *h)
{
    switch (h->bs.mediadesriptor) {
    case MD_FIXED:
    case SS8SPT:
    case DS8SPT:
    case SS9SPT:
    case DS9SPT:
    case DS18SPT:
    case DS9_15SPT:
        return (1);
    default:
        return (0);
    }
}

static int
well_formed(fstyp_pcfs_t *h)
{
    int fatmatch;

    if (h->bs16.f_bootsig == 0x29) {
        fatmatch = ((h->bs16.f_typestring[0] == 'F' &&
            h->bs16.f_typestring[1] == 'A' &&
            h->bs16.f_typestring[2] == 'T') &&
            (h->bs.fatsec > 0) &&
            ((PC_NSEC(h) == 0 && h->bs.totalsec > 0) ||
            PC_NSEC(h) > 0));
    } else if (h->bs32.f_bootsig == 0x29) {
        fatmatch = ((h->bs32.f_typestring[0] == 'F' &&
            h->bs32.f_typestring[1] == 'A' &&
            h->bs32.f_typestring[2] == 'T') &&
            (h->bs.fatsec == 0 && h->bs32.f_fatlength > 0) &&
            ((PC_NSEC(h) == 0 && h->bs.totalsec > 0) ||
            PC_NSEC(h) > 0));
    } else {
        fatmatch = (PC_NSEC(h) > 0 && h->bs.fatsec > 0);
    }

    return (fatmatch && h->bps > 0 && h->bps % 512 == 0 &&
        h->bs.spcl > 0 && PC_RESSEC(h) >= 1 && h->bs.nfat > 0);
}

static void
calculate_parameters(fstyp_pcfs_t *h)
{
    if (PC_NSEC(h) != 0) {
        h->TotSec = PC_NSEC(h);
    } else {
        h->TotSec = h->bs.totalsec;
    }
    if (h->bs.fatsec != 0) {
        h->FATSz = h->bs.fatsec;
    } else {
        h->FATSz = h->bs32.f_fatlength;
    }
    if ((h->bps == 0) || (h->bs.spcl == 0)) {
        return;
    }
    h->RootDirSectors =
        ((PC_NROOTENT(h) * 32) + (h->bps - 1)) / h->bps;
    h->FirstDataSector =
        PC_RESSEC(h) + h->bs.nfat * h->FATSz + h->RootDirSectors;
    h->DataSec = h->TotSec - h->FirstDataSector;
    h->CountOfClusters = h->DataSec / h->bs.spcl;
}

static void
determine_fattype(fstyp_pcfs_t *h)
{
    if ((h->CountOfClusters >= 4085 && h->CountOfClusters <= 4095) ||
        (h->CountOfClusters >= 65525 && h->CountOfClusters <= 65535)) {
        h->fattype = 0;
    } else if (h->CountOfClusters < 4085) {
        h->fattype = 12;
    } else if (h->CountOfClusters < 65525) {
        h->fattype = 16;
    } else {
        h->fattype = 32;
    }
}

static void
get_label(fstyp_pcfs_t *h)
{
    /*
     * Use label from the boot sector by default.
     * Can overwrite later with the one from root directory.
     */
    (void) memcpy(h->volume_label, PC_LABEL_ADDR(h), PC_LABEL_SIZE);
    h->volume_label[PC_LABEL_SIZE] = '\0';

    if (h->fattype == 0) {
        return;
    } else if (FSTYP_IS_32(h)) {
        get_label_32(h);
    } else {
        get_label_16(h);
    }
}

/*
 * Get volume label from the root directory entry.
 * In FAT12/16 the root directory is of fixed size.
 * It immediately follows the FATs
 */
static void
get_label_16(fstyp_pcfs_t *h)
{
    ulong_t FirstRootDirSecNum;
    int secsize;
    off_t   offset;
    uint8_t buf[PC_SECSIZE * 4];
    int i;
    int nent, resid;

    if ((secsize = h->bps) > sizeof (buf)) {
        return;
    }

    FirstRootDirSecNum = PC_RESSEC(h) + h->bs.nfat * h->bs.fatsec;
    offset = h->offset + FirstRootDirSecNum * secsize;
    resid = PC_NROOTENT(h);

    for (i = 0; i < h->RootDirSectors; i++) {
        (void) lseek(h->fd, offset, SEEK_SET);
        if (read(h->fd, buf, secsize) != secsize) {
            return;
        }

        nent = secsize / sizeof (struct pcdir);
        if (nent > resid) {
            nent = resid;
        }
        if (dir_find_label(h, (struct pcdir *)buf, nent)) {
            return;
        }

        resid -= nent;
        offset += PC_SECSIZE;
    }
}

/*
 * Get volume label from the root directory entry.
 * In FAT32 root is a usual directory, a cluster chain.
 * It starts at BPB_RootClus.
 */
static void
get_label_32(fstyp_pcfs_t *h)
{
    off_t   offset;
    int clustersize;
    int n;
    ulong_t FirstSectorofCluster;
    uint8_t *buf;
    int nent;
    int cnt = 0;

    clustersize = h->bs.spcl * h->bps;
    if ((clustersize == 0) || (clustersize > FSTYP_MAX_CLUSTER_SIZE) ||
        ((buf = calloc(1, clustersize)) == NULL)) {
        return;
    }

    for (n = h->bs32.f_rootcluster; n != 0; n = next_cluster_32(h, n)) {
        FirstSectorofCluster =
            (n - 2) * h->bs.spcl + h->FirstDataSector;
        offset = h->offset + FirstSectorofCluster * h->bps;
        (void) lseek(h->fd, offset, SEEK_SET);
        if (read(h->fd, buf, clustersize) != clustersize) {
            break;
        }

        nent = clustersize / sizeof (struct pcdir);
        if (dir_find_label(h, (struct pcdir *)buf, nent)) {
            break;
        }

        if (++cnt > FSTYP_MAX_DIR_SIZE / clustersize) {
            break;
        }
    }

    free(buf);
}

/*
 * Get a FAT entry pointing to the next file cluster
 */
int
next_cluster_32(fstyp_pcfs_t *h, int n)
{
    uint8_t buf[PC_SECSIZE];
    ulong_t ThisFATSecNum;
    ulong_t ThisFATEntOffset;
    off_t   offset;
    uint32_t val;
    int next = 0;

    ThisFATSecNum = PC_RESSEC(h) + (n * 4) / h->bps;
    ThisFATEntOffset = (n * 4) % h->bps;
    offset = h->offset + ThisFATSecNum * h->bps;

    (void) lseek(h->fd, offset, SEEK_SET);
    if (read(h->fd, buf, sizeof (buf)) == sizeof (buf)) {
        val = buf[ThisFATEntOffset] & 0x0fffffff;
        next = ltohi(val);
    }

    return (next);
}

/*
 * Given an array of pcdir structs, find one containing volume label.
 */
static boolean_t
dir_find_label(fstyp_pcfs_t *h, struct pcdir *d, int nent)
{
    int i;

    for (i = 0; i < nent; i++, d++) {
        if (PCDL_IS_LFN(d))
            continue;
        if ((d->pcd_filename[0] != PCD_UNUSED) &&
            (d->pcd_filename[0] != PCD_ERASED) &&
            ((d->pcd_attr & (PCA_LABEL | PCA_DIR)) == PCA_LABEL) &&
            (d->un.pcd_scluster_hi == 0) &&
            (d->pcd_scluster_lo == 0)) {
            (void) memcpy(h->volume_label, d->pcd_filename,
                PC_LABEL_SIZE);
            h->volume_label[PC_LABEL_SIZE] = '\0';
            return (B_TRUE);
        }
    }
    return (B_FALSE);
}

static int
is_pcfs(fstyp_pcfs_t *h)
{
    int error;

    if ((error = read_bootsec(h)) != 0) {
        return (error);
    }
    if (!valid_media(h)) {
        return (FSTYP_ERR_NO_MATCH);
    }
    if (!well_formed(h)) {
        return (FSTYP_ERR_NO_MATCH);
    }

    calculate_parameters(h);
    determine_fattype(h);
    get_label(h);

    return (0);
}

/* ARGSUSED */
static int
dumpfs(fstyp_pcfs_t *h, FILE *fout, FILE *ferr)
{
    (void) fprintf(fout,
        "Bytes Per Sector  %d\t\tSectors Per Cluster    %d\n",
        h->bps, h->bs.spcl);
    (void) fprintf(fout,
        "Reserved Sectors  %d\t\tNumber of FATs         %d\n",
        (unsigned short)PC_RESSEC(h), h->bs.nfat);
    (void) fprintf(fout,
        "Root Dir Entries  %d\t\tNumber of Sectors      %d\n",
        (unsigned short)PC_NROOTENT(h), (unsigned short)PC_NSEC(h));
    (void) fprintf(fout,
        "Sectors Per FAT   %d\t\tSectors Per Track      %d\n",
        h->bs.fatsec, h->bs.spt);
    (void) fprintf(fout,
        "Number of Heads   %d\t\tNumber Hidden Sectors  %d\n",
        h->bs.nhead, h->bs.hiddensec);
    (void) fprintf(fout, "Volume ID: 0x%x\n", PC_VOLID(h));
    (void) fprintf(fout, "Volume Label: %s\n", h->volume_label);
    (void) fprintf(fout, "Drive Number: 0x%x\n", PC_DRVNUM(h));
    (void) fprintf(fout, "Media Type: 0x%x   ", h->bs.mediadesriptor);

    switch (h->bs.mediadesriptor) {
    case MD_FIXED:
        (void) fprintf(fout, "\"Fixed\" Disk\n");
        break;
    case SS8SPT:
        (void) fprintf(fout, "Single Sided, 8 Sectors Per Track\n");
        break;
    case DS8SPT:
        (void) fprintf(fout, "Double Sided, 8 Sectors Per Track\n");
        break;
    case SS9SPT:
        (void) fprintf(fout, "Single Sided, 9 Sectors Per Track\n");
        break;
    case DS9SPT:
        (void) fprintf(fout, "Double Sided, 9 Sectors Per Track\n");
        break;
    case DS18SPT:
        (void) fprintf(fout, "Double Sided, 18 Sectors Per Track\n");
        break;
    case DS9_15SPT:
        (void) fprintf(fout, "Double Sided, 9-15 Sectors Per Track\n");
        break;
    default:
        (void) fprintf(fout, "Unknown Media Type\n");
    }

    return (0);
}

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

#define ADD_UINT32(h, name, value) \
    if (nvlist_add_uint32(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_pcfs_t *h)
{
    char    s[64];

    ADD_UINT32(h, "bytes_per_sector", h->bps);
    ADD_UINT32(h, "sectors_per_cluster", h->bs.spcl);
    ADD_UINT32(h, "reserved_sectors", PC_RESSEC(h));
    ADD_UINT32(h, "fats", h->bs.nfat);
    ADD_UINT32(h, "root_entry_count", PC_NROOTENT(h));
    ADD_UINT32(h, "total_sectors_16", PC_NSEC(h));
    ADD_UINT32(h, "media", h->bs.mediadesriptor);
    ADD_UINT32(h, "fat_size_16", h->bs.fatsec);
    ADD_UINT32(h, "sectors_per_track", h->bs.spt);
    ADD_UINT32(h, "heads", h->bs.nhead);
    ADD_UINT32(h, "hidden_sectors", h->bs.hiddensec);
    ADD_UINT32(h, "total_sectors_32", h->bs.totalsec);
    ADD_UINT32(h, "drive_number", PC_DRVNUM(h));
    ADD_UINT32(h, "volume_id", PC_VOLID(h));
    ADD_STRING(h, "volume_label", h->volume_label);
    if (FSTYP_IS_32(h)) {
        ADD_UINT32(h, "fat_size_32", h->bs32.f_fatlength);
    }
    ADD_UINT32(h, "total_sectors", h->TotSec);
    ADD_UINT32(h, "fat_size", h->FATSz);
    ADD_UINT32(h, "count_of_clusters", h->CountOfClusters);
    ADD_UINT32(h, "fat_entry_size", h->fattype);

    ADD_BOOL(h, "gen_clean", B_TRUE);
    if (PC_VOLID(a) != 0) {
        (void) snprintf(s, sizeof (s), "%08x", PC_VOLID(a));
        ADD_STRING(h, "gen_guid", s);
    }
    (void) snprintf(s, sizeof (s), "%d", h->fattype);
    ADD_STRING(h, "gen_version", s);
    ADD_STRING(h, "gen_volume_label", h->volume_label);

    return (0);
}