xref: /illumos-gate/usr/src/cmd/fs.d/udfs/fstyp/fstyp.c (revision 2a8bcb4e)

/*
 * 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 udfs
 */
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <locale.h>
#include <stdlib.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 <libnvpair.h>
#include <libfstyp_module.h>
#include <sys/fs/udf_volume.h>
#include "ud_lib.h"


typedef struct fstyp_udfs {
	int		fd;
	ud_handle_t	udh;
	nvlist_t	*attr;
} fstyp_udfs_t;

static int	is_udfs(fstyp_udfs_t *h);
static int	print_vds(fstyp_udfs_t *h, struct vds *,
		FILE *fout, FILE *ferr);
static int	get_attr(fstyp_udfs_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_udfs_t *h = (fstyp_udfs_t *)handle;

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

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

	if (ud_init(h->fd, &h->udh) != 0) {
		free(h);
		return (FSTYP_ERR_NOMEM);
	}

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

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

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

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

	return (is_udfs(h));
}

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

int
fstyp_mod_dump(fstyp_mod_handle_t handle, FILE *fout, FILE *ferr)
{
	fstyp_udfs_t *h = (fstyp_udfs_t *)handle;
	struct udf *udfs = &h->udh->udfs;
	int ret;

	(void) fprintf(fout,
		"Standard Identifier %5s\n", udfs->ecma_id);

	if (udfs->flags & VALID_MVDS) {
		ret = print_vds(h, &udfs->mvds, fout, ferr);
	} else {
		ret = print_vds(h, &udfs->rvds, fout, ferr);
	}

	return (ret);
}


/*
 * Assumption is that we will confirm to level-1
 */
int
is_udfs(fstyp_udfs_t *h)
{
	struct udf *udfs = &h->udh->udfs;
	int32_t ret;

	if ((ret = ud_fill_udfs_info(h->udh)) != 0) {
		return (ret);
	}

	if ((udfs->flags & VALID_UDFS) == 0) {
		return (FSTYP_ERR_NO_MATCH);
	}

	return (0);
}

/*
 * For now, only return generic attributes.
 * Will open an RFE to add native attributes.
 */
static int
get_attr(fstyp_udfs_t *h)
{
	struct udf *udfs = &h->udh->udfs;
	struct vds *v;
	struct pri_vol_desc *pvd;
	uint32_t len;
	uint64_t off;
	uint8_t *buf;
	int8_t str[64];
	int ret = 0;

	v = (udfs->flags & VALID_MVDS) ? &udfs->mvds : &udfs->rvds;

	/* allocate buffer */
	len = udfs->lbsize;
	if (v->pvd_len > len) {
		len = v->pvd_len;
	}
	if ((buf = (uint8_t *)malloc(len)) == NULL) {
		return (FSTYP_ERR_NOMEM);
	}

	(void) nvlist_add_boolean_value(h->attr, "gen_clean", B_TRUE);

	/* Primary Volume Descriptor */
	if (v->pvd_len != 0) {
		off = v->pvd_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, v->pvd_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}
		/* LINTED */
		pvd = (struct pri_vol_desc *)(uint32_t *)buf;

		ud_convert2local(pvd->pvd_vol_id, str, 32);
		str[32] = '\0';
		(void) nvlist_add_string(h->attr, "gen_volume_label", str);
	}

	ret = 0;

out:
	free(buf);
	return (ret);
}

/* ARGSUSED */
int
print_vds(fstyp_udfs_t *h, struct vds *v, FILE *fout, FILE *ferr)
{
	struct udf *udfs = &h->udh->udfs;
	int32_t i;
	uint32_t len;
	uint64_t off;
	uint8_t *buf;
	int	ret = 0;

	/*
	 * All descriptors are 512 bytes
	 * except lvd, usd and lvid
	 * findout the largest and allocate space
	 */
	len = udfs->lbsize;
	if (v->lvd_len > len) {
		len = v->lvd_len;
	}
	if (v->usd_len > len) {
		len = v->usd_len;
	}
	if (udfs->lvid_len > len) {
		len = udfs->lvid_len;
	}

	if ((buf = (uint8_t *)malloc(len)) == NULL) {
		return (FSTYP_ERR_NOMEM);
	}

	/*
	 * Anchor Volume Descriptor
	 */
	if (udfs->avdp_len != 0) {
		off = udfs->avdp_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, udfs->avdp_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_avd(fout, (struct anch_vol_desc_ptr *)buf);
	}

	/*
	 * Primary Volume Descriptor
	 */
	if (v->pvd_len != 0) {
		off = v->pvd_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, v->pvd_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_pvd(fout, (struct pri_vol_desc *)buf);
	}

	/*
	 * Implementation Use descriptor
	 */
	if (v->iud_len != 0) {
		off = v->iud_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, v->iud_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_iuvd(fout, (struct iuvd_desc *)buf);
	}

	/*
	 * Paritions
	 */
	for (i = 0; i < h->udh->n_parts; i++) {
		if (v->part_len[i] != 0) {
			off = v->part_loc[i] * udfs->lbsize;
			if (ud_read_dev(h->udh, off, buf,
			    v->part_len[i]) != 0) {
				ret = FSTYP_ERR_IO;
				goto out;
			}

			/* LINTED */
			print_part(fout, (struct part_desc *)buf);
		}
	}

	/*
	 * Logical Volume Descriptor
	 */
	if (v->lvd_len != 0) {
		off = v->lvd_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, v->lvd_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_lvd(fout, (struct log_vol_desc *)buf);
	}

	/*
	 * Unallocated Space Descriptor
	 */
	if (v->usd_len != 0) {
		off = v->usd_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, v->usd_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_usd(fout, (struct unall_spc_desc *)buf);
	}

	/*
	 * Logical Volume Integrity Descriptor
	 */
	if (udfs->lvid_len != 0) {
		off = udfs->lvid_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, udfs->lvid_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_lvid(fout, (struct log_vol_int_desc *)buf);
	}

	/*
	 * File Set Descriptor
	 */
	if (udfs->fsd_len != 0) {
		off = udfs->fsd_loc * udfs->lbsize;
		if (ud_read_dev(h->udh, off, buf, udfs->fsd_len) != 0) {
			ret = FSTYP_ERR_IO;
			goto out;
		}

		/* LINTED */
		print_fsd(fout, h->udh, (struct file_set_desc *)buf);
	}
	ret = 0;

out:
	free(buf);
	return (ret);
}