xref: /onnv-gate/usr/src/cmd/fs.d/udfs/fstyp/ud_lib.c (revision 2212:4d4fd25d9b6e)

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

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

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <unistd.h>
#include <strings.h>
#include <errno.h>
#include <libintl.h>
#include <libgen.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/int_types.h>
#include <sys/dkio.h>
#include <sys/cdio.h>
#include <sys/vtoc.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/fs/udf_volume.h>
#include "ud_lib.h"

extern char *getfullrawname(char *);

static int32_t ud_get_ecma_ver(ud_handle_t, uint32_t);
static int32_t ud_get_fs_bsize(ud_handle_t, uint32_t, uint32_t *);
static int32_t ud_parse_fill_vds(ud_handle_t, struct vds *, uint32_t, uint32_t);
static int32_t	ud_read_and_translate_lvd(ud_handle_t, uint32_t, uint32_t);
static int32_t ud_get_latest_lvid(ud_handle_t, uint32_t, uint32_t);
static int32_t	ud_get_latest_fsd(ud_handle_t, uint16_t, uint32_t, uint32_t);

static uint16_t ud_crc(uint8_t *, int32_t);
static int32_t UdfTxName(uint16_t *, int32_t);
static int32_t UncompressUnicode(int32_t, uint8_t *, uint16_t *);
static int32_t ud_compressunicode(int32_t, int32_t, uint16_t *, uint8_t *);
static int32_t ud_convert2utf8(uint8_t *, uint8_t *, int32_t);
static int32_t ud_convert2utf16(uint8_t *, uint8_t *, int32_t);


int
ud_init(int fd, ud_handle_t *hp)
{
	struct ud_handle *h;

	if ((h = calloc(1, sizeof (struct ud_handle))) == NULL) {
		return (ENOMEM);
	}
	h->fd = fd;
	*hp = h;
	return (0);
}

void
ud_fini(ud_handle_t h)
{
	free(h);
}

/* ARGSUSED */
int32_t
ud_open_dev(ud_handle_t h, char *special, uint32_t flags)
{
	char *temp;
	struct stat i_stat, r_stat;

	(void) bzero(&i_stat, sizeof (struct stat));
	(void) bzero(&r_stat, sizeof (struct stat));

	/*
	 * Get the stat structure
	 */
	if (stat(special, &i_stat) < 0) {
		temp = special;
	} else {

		if ((i_stat.st_mode & S_IFMT) == S_IFCHR) {

			/*
			 * If Raw deivce is given use it as it is
			 */

			temp = special;
		} else if ((i_stat.st_mode & S_IFMT) == S_IFBLK) {

			/*
			 * Block device try to convert to raw device
			 */

			temp = getfullrawname(special);

			/*
			 * Stat the converted device name and verify
			 * both the raw and block device belong to
			 * the same device
			 */
			if (stat(temp, &r_stat) < 0) {
				temp = special;
			} else {
				if (((r_stat.st_mode & S_IFMT) == S_IFBLK) ||
					(r_stat.st_rdev != i_stat.st_rdev)) {
					temp = special;
				}
			}
		}
	}

	/*
	 * Now finally open the device
	 */
	h->fd = open(temp, flags);

	return (h->fd);
}

/* ARGSUSED */
void
ud_close_dev(ud_handle_t h)
{
	/*
	 * Too simple Just close it
	 */
	(void) close(h->fd);
}

int32_t
ud_read_dev(ud_handle_t h, uint64_t offset, uint8_t *buf, uint32_t count)
{
	/*
	 * Seek to the given offset
	 */
	if (lseek(h->fd, offset, SEEK_SET) == -1) {
		return (1);
	}

	/*
	 * Read the required number of bytes
	 */
	if (read(h->fd, buf, count) != count) {
		return (1);
	}
	return (0);
}

int32_t
ud_write_dev(ud_handle_t h, uint64_t offset, uint8_t *buf, uint32_t count)
{
	/*
	 * Seek to the given offset
	 */
	if (lseek(h->fd, offset, SEEK_SET) == -1) {
		return (1);
	}

	/*
	 * Read the appropriate number of bytes
	 */
	if (write(h->fd, buf, count) != count) {
		return (1);
	}
	return (0);
}

/* ----- BEGIN Read and translate the on disk VDS to IN CORE format -------- */

int32_t
ud_fill_udfs_info(ud_handle_t h)
{
	struct	anch_vol_desc_ptr	*avdp = NULL;
	uint32_t			offset = 0;

	if (ioctl(h->fd, CDROMREADOFFSET, &offset) == -1) {
		offset = 0;
	}

	h->udfs.flags = INVALID_UDFS;

	h->udfs.ecma_version = ud_get_ecma_ver(h, offset);
	if (h->udfs.ecma_version == UD_ECMA_UNKN) {
		return (1);
	}

	h->udfs.lbsize = ud_get_fs_bsize(h, offset, &h->udfs.avdp_loc);
	if (h->udfs.lbsize == 0) {
		return (2);
	}

	h->udfs.avdp_len = lb_roundup(512, h->udfs.lbsize);


	if ((avdp = (struct anch_vol_desc_ptr *)
			malloc(h->udfs.lbsize)) == NULL) {
		return (3);
	}
	if (ud_read_dev(h, h->udfs.avdp_loc * h->udfs.lbsize,
			(uint8_t *)avdp, h->udfs.lbsize) != 0) {
		free(avdp);
		return (4);
	}
	if (ud_verify_tag(h, &avdp->avd_tag, UD_ANCH_VOL_DESC,
			h->udfs.avdp_loc, 1, 0) != 0) {
		free(avdp);
		return (5);
	}

	h->udfs.mvds_loc = SWAP_32(avdp->avd_main_vdse.ext_loc);
	h->udfs.mvds_len = SWAP_32(avdp->avd_main_vdse.ext_len);

	h->udfs.rvds_loc = SWAP_32(avdp->avd_res_vdse.ext_loc);
	h->udfs.rvds_len = SWAP_32(avdp->avd_res_vdse.ext_len);

	free(avdp);

	/*
	 * get information from mvds and rvds
	 */
	if (ud_parse_fill_vds(h, &h->udfs.mvds,
			h->udfs.mvds_loc, h->udfs.mvds_len) == 0) {
		h->udfs.flags |= VALID_MVDS;
	}
	if (ud_parse_fill_vds(h, &h->udfs.rvds,
			h->udfs.rvds_loc, h->udfs.rvds_len) == 0) {
		h->udfs.flags |= VALID_RVDS;
	}

	if ((h->udfs.flags & (VALID_MVDS | VALID_RVDS)) == 0) {
		return (6);
	}

	/*
	 * If we are here we have
	 * a valid Volume Descriptor Seqence
	 * Read and understand lvd
	 */
	if (h->udfs.flags & VALID_MVDS) {
		if (ud_read_and_translate_lvd(h, h->udfs.mvds.lvd_loc,
				h->udfs.mvds.lvd_len) != 0) {
			return (7);
		}
	} else {
		if (ud_read_and_translate_lvd(h, h->udfs.rvds.lvd_loc,
				h->udfs.rvds.lvd_len) != 0) {
			return (8);
		}
	}

	h->udfs.flags |= VALID_UDFS;

	return (0);
}

static int32_t
ud_get_ecma_ver(ud_handle_t h, uint32_t offset)
{
	uint8_t *buf;
	uint64_t off;
	uint64_t end_off;
	struct nsr_desc *ndsc;
	uint32_t ecma_ver = UD_ECMA_UNKN;

	/*
	 * Allocate a buffer of size UD_VOL_REC_BSZ
	 */
	if ((buf = (uint8_t *)malloc(UD_VOL_REC_BSZ)) == NULL) {

		/*
		 * Uh could not even allocate this much
		 */
		goto end;
	}

	/*
	 * Start from 32k and keep reading 2k blocks we
	 * should be able to find NSR if we have one by 256 * 2k bytes
	 */
	off = offset * 2048 + UD_VOL_REC_START;
	end_off = offset * 2048 + UD_VOL_REC_END;
	for (; off < end_off; off += UD_VOL_REC_BSZ) {

		if (ud_read_dev(h, off, buf, UD_VOL_REC_BSZ) == 0) {

			ndsc = (struct nsr_desc *)buf;
			/*
			 * Is this either NSR02 or NSR03
			 */
			if ((ndsc->nsr_str_type == 0) &&
				(ndsc->nsr_ver == 1) &&
				(ndsc->nsr_id[0] == 'N') &&
				(ndsc->nsr_id[1] == 'S') &&
				(ndsc->nsr_id[2] == 'R') &&
				(ndsc->nsr_id[3] == '0') &&
					((ndsc->nsr_id[4] == '2') ||
					(ndsc->nsr_id[4] == '3'))) {

				(void) strncpy((char *)h->udfs.ecma_id,
					(char *)ndsc->nsr_id, 5);

				switch (ndsc->nsr_id[4]) {
				case '2' :

					/*
					 * ECMA 167/2
					 */
					ecma_ver = UD_ECMA_VER2;
					goto end;
				case '3' :

					/*
					 * ECMA 167/3
					 */
					ecma_ver = UD_ECMA_VER3;
					goto end;
				}
			}
		}
	}

end:
	/*
	 * Cleanup
	 */
	free(buf);
	return (ecma_ver);
}

static uint32_t last_block_index[] = {0, 0, 256, 2, 2 + 256,
		150, 150 + 256, 152, 152 + 256};

static int32_t
ud_get_fs_bsize(ud_handle_t h, uint32_t offset, uint32_t *avd_loc)
{
	uint64_t off;
	int32_t index, bsize, shift, end_index;
	uint32_t num_blocks, sub_blk;
	uint8_t *buf = NULL;
	struct anch_vol_desc_ptr *avdp;

	if ((buf = (uint8_t *)malloc(MAXBSIZE)) == NULL) {
		return (0);
	}

	/*
	 * If we could figure out the last block
	 * search at 256, N, N - 256 blocks
	 * otherwise just check at 256
	 */
	if (ud_get_num_blks(h, &num_blocks) != 0) {
		end_index = 1;
		num_blocks = 0;
	} else {
		end_index = sizeof (last_block_index) / 4;
	}

	for (index = 0; index < end_index; index++) {
		sub_blk = last_block_index[index];

		/*
		 * Start guessing from DEV_BSIZE to MAXBSIZE
		 */
		for (bsize = DEV_BSIZE, shift = 0;
			bsize <= MAXBSIZE; bsize <<= 1, shift++) {

			if (index == 0) {

				/*
				 * Check if we atleast have 256 of bsize
				 * blocks on the device
				 */
				if ((end_index == 0) ||
					(num_blocks > (256 << shift))) {
					*avd_loc = 256;
					if (bsize <= 2048) {
						*avd_loc +=
							offset * 2048 / bsize;
					} else {
						*avd_loc +=
							offset / (bsize / 2048);
					}
				} else {
					continue;
				}
			} else {
				/*
				 * Calculate the bsize avd block
				 */
				if ((num_blocks) &&
					(num_blocks > (sub_blk << shift))) {
					*avd_loc = (num_blocks >> shift) -
						sub_blk;
				} else {
					continue;
				}
			}

			off = (uint64_t)*avd_loc * bsize;

			/*
			 * Read bsize bytes at off
			 */
			if (ud_read_dev(h, off, buf, bsize) != 0) {
				continue;
			}

			/*
			 * Check if we have a Anchor Volume Descriptor here
			 */

			/* LINTED */
			avdp = (struct anch_vol_desc_ptr *)buf;
			if (ud_verify_tag(h, &avdp->avd_tag,
				UD_ANCH_VOL_DESC, *avd_loc, 1, 0) != 0) {
				continue;
			}
			goto end;
		}
	}

end:
	if (bsize > MAXBSIZE) {
		bsize = 0;
		*avd_loc = 0;
	}
	free(buf);
	return (bsize);
}

static int32_t
ud_parse_fill_vds(ud_handle_t h, struct vds *v,
	uint32_t vds_loc, uint32_t vds_len)
{
	uint8_t *addr, *taddr, *eaddr;
	uint16_t id;
	int32_t i;
	uint64_t off;
	struct tag *tag;
	struct pri_vol_desc *pvd;
	struct log_vol_desc *lvd;
	struct vol_desc_ptr *vds;
	struct unall_spc_desc *usd;

begin:
	if ((addr = (uint8_t *)malloc(vds_len)) == NULL) {
		return (1);
	}

	off = vds_loc * h->udfs.lbsize;
	if (ud_read_dev(h, off, addr, vds_len) != 0) {
		goto end;
	}

	for (taddr = addr, eaddr = addr + h->udfs.mvds_len; taddr < eaddr;
			taddr += h->udfs.lbsize, vds_loc ++) {

		/* LINTED */
		tag = (struct tag *)taddr;
		id = SWAP_16(tag->tag_id);
		/*
		 * If you cannot verify the tag just skip it
		 * This is not a fatal error
		 */
		if (ud_verify_tag(h, tag, id, vds_loc, 1, 0) != 0) {
			continue;
		}
		switch (id) {
		case UD_PRI_VOL_DESC :

			/*
			 * Primary Volume Descriptor
			 */
			/* LINTED */
			pvd = (struct pri_vol_desc *)taddr;
			if ((v->pvd_len == 0) ||
				(SWAP_32(pvd->pvd_vdsn) > v->pvd_vdsn)) {
				v->pvd_vdsn = SWAP_32(pvd->pvd_vdsn);
				v->pvd_loc = vds_loc;
				v->pvd_len = h->udfs.lbsize;
			}
			break;
		case UD_VOL_DESC_PTR :

			/*
			 * Curent sequence is continued from
			 * the location pointed by vdp
			 */
			/* LINTED */
			vds = (struct vol_desc_ptr *)taddr;

			if (SWAP_32(vds->vdp_nvdse.ext_len) != 0) {
				vds_loc = SWAP_32(vds->vdp_nvdse.ext_loc);
				vds_len = SWAP_32(vds->vdp_nvdse.ext_len);
				free(addr);
				goto begin;
			}
			break;
		case UD_IMPL_USE_DESC :

			/*
			 * Implementation Use Volume Descriptor
			 */
			v->iud_loc = vds_loc;
			v->iud_len = lb_roundup(512, h->udfs.lbsize);
			break;
		case UD_PART_DESC :
			{
				struct ud_part *p;
				struct phdr_desc *ph;
				struct part_desc *pd;

				/*
				 * Partition Descriptor
				 */
				/* LINTED */
				pd = (struct part_desc *)taddr;

				for (i = 0; i < h->n_parts; i++) {
					p = &h->part[i];

					if ((SWAP_16(pd->pd_pnum) ==
							p->udp_number) &&
						(SWAP_32(pd->pd_vdsn) >
							p->udp_seqno)) {
						break;
					}
				}

				v->part_loc[i] = vds_loc;
				v->part_len[i] =
					lb_roundup(512, h->udfs.lbsize);

				p = &h->part[i];
				p->udp_number = SWAP_16(pd->pd_pnum);
				p->udp_seqno = SWAP_32(pd->pd_vdsn);
				p->udp_access = SWAP_32(pd->pd_acc_type);
				p->udp_start = SWAP_32(pd->pd_part_start);
				p->udp_length = SWAP_32(pd->pd_part_length);

				/* LINTED */
				ph = (struct phdr_desc *)pd->pd_pc_use;
				if (ph->phdr_ust.sad_ext_len) {
			p->udp_flags = UDP_SPACETBLS;
			p->udp_unall_loc = SWAP_32(ph->phdr_ust.sad_ext_loc);
			p->udp_unall_len = SWAP_32(ph->phdr_ust.sad_ext_len);
			p->udp_freed_loc = SWAP_32(ph->phdr_fst.sad_ext_loc);
			p->udp_freed_len = SWAP_32(ph->phdr_fst.sad_ext_len);
				} else {
			p->udp_flags = UDP_BITMAPS;
			p->udp_unall_loc = SWAP_32(ph->phdr_usb.sad_ext_loc);
			p->udp_unall_len = SWAP_32(ph->phdr_usb.sad_ext_len);
			p->udp_freed_loc = SWAP_32(ph->phdr_fsb.sad_ext_loc);
			p->udp_freed_len = SWAP_32(ph->phdr_fsb.sad_ext_len);
				}

				if (i == h->n_parts) {
					h->n_parts ++;
				}
			}
			break;
		case UD_LOG_VOL_DESC :

			/*
			 * Logical Volume Descriptor
			 */
			/* LINTED */
			lvd = (struct log_vol_desc *)taddr;
			if ((v->lvd_len == 0) ||
				(SWAP_32(lvd->lvd_vdsn) > v->lvd_vdsn)) {
				v->lvd_vdsn = SWAP_32(lvd->lvd_vdsn);
				v->lvd_loc = vds_loc;
				v->lvd_len = ((uint32_t)
					&((struct log_vol_desc *)0)->lvd_pmaps);
				v->lvd_len =
					lb_roundup(v->lvd_len, h->udfs.lbsize);
			}
			break;
		case UD_UNALL_SPA_DESC :

			/*
			 * Unallocated Space Descriptor
			 */
			/* LINTED */
			usd = (struct unall_spc_desc *)taddr;
			v->usd_loc = vds_loc;
			v->usd_len = ((uint32_t)
			&((unall_spc_desc_t *)0)->ua_al_dsc) +
				SWAP_32(usd->ua_nad) *
				sizeof (struct extent_ad);
			v->usd_len = lb_roundup(v->usd_len, h->udfs.lbsize);
			break;
		case UD_TERM_DESC :
			/*
			 * Success fully completed
			 */
			goto end;
		default :
			/*
			 * If you donot undetstand any tag just skip
			 * it. This is not a fatal error
			 */
			break;
		}
	}

end:
	free(addr);
	if ((v->pvd_len == 0) ||
		(v->part_len[0] == 0) ||
		(v->lvd_len == 0)) {
		return (1);
	}

	return (0);
}

static int32_t
ud_read_and_translate_lvd(ud_handle_t h, uint32_t lvd_loc, uint32_t lvd_len)
{
	caddr_t addr;
	uint16_t fsd_prn;
	uint32_t fsd_loc, fsd_len;
	uint32_t lvds_loc, lvds_len;
	uint64_t off;
	struct log_vol_desc *lvd = NULL;

	int32_t max_maps, i, mp_sz, index;
	struct ud_map *m;
	struct pmap_hdr *ph;
	struct pmap_typ1 *typ1;
	struct pmap_typ2 *typ2;

	if (lvd_len == 0) {
		return (1);
	}

	if ((lvd = (struct log_vol_desc *)
			malloc(lvd_len)) == NULL) {
		return (1);
	}

	off = lvd_loc * h->udfs.lbsize;
	if (ud_read_dev(h, off, (uint8_t *)lvd, lvd_len) != 0) {
		free(lvd);
		return (1);
	}

	if (ud_verify_tag(h, &lvd->lvd_tag, UD_LOG_VOL_DESC,
			lvd_loc, 1, 0) != 0) {
		free(lvd);
		return (1);
	}

	/*
	 * Take care of maps
	 */
	max_maps = SWAP_32(lvd->lvd_num_pmaps);
	ph = (struct pmap_hdr *)lvd->lvd_pmaps;
	for (h->n_maps = index = 0; index < max_maps; index++) {
		m = &h->maps[h->n_maps];
		switch (ph->maph_type) {
		case MAP_TYPE1 :

			/* LINTED */
			typ1 = (struct pmap_typ1 *)ph;

			m->udm_flags = UDM_MAP_NORM;
			m->udm_vsn = SWAP_16(typ1->map1_vsn);
			m->udm_pn = SWAP_16(typ1->map1_pn);
			h->n_maps++;
			break;

		case MAP_TYPE2 :

			/* LINTED */
			typ2 = (struct pmap_typ2 *)ph;

			if (strncmp(typ2->map2_pti.reg_id,
					UDF_VIRT_PART, 23) == 0) {

				m->udm_flags = UDM_MAP_VPM;
				m->udm_vsn = SWAP_16(typ2->map2_vsn);
				m->udm_pn = SWAP_16(typ2->map2_pn);
			} else if (strncmp(typ2->map2_pti.reg_id,
					UDF_SPAR_PART, 23) == 0) {

				if ((SWAP_16(typ2->map2_pl) != 32) ||
						(typ2->map2_nst < 1) ||
						(typ2->map2_nst > 4)) {
					break;
				}
				m->udm_flags = UDM_MAP_SPM;
				m->udm_vsn = SWAP_16(typ2->map2_vsn);
				m->udm_pn = SWAP_16(typ2->map2_pn);

				m->udm_plen = SWAP_16(typ2->map2_pl);
				m->udm_nspm = typ2->map2_nst;
				m->udm_spsz = SWAP_32(typ2->map2_sest);

				mp_sz = lb_roundup(m->udm_spsz, h->udfs.lbsize);

				if ((addr = malloc(mp_sz * m->udm_nspm)) ==
						NULL) {
					break;
				}

				for (i = 0; i < m->udm_nspm; i++) {
					m->udm_loc[i] =
						SWAP_32(typ2->map2_st[index]);
					m->udm_spaddr[i] = addr + i * mp_sz;

					off = m->udm_loc[i] * h->udfs.lbsize;
					if (ud_read_dev(h, off,
						(uint8_t *)m->udm_spaddr[i],
							mp_sz) != 0) {
						m->udm_spaddr[i] = NULL;
						continue;
					}
				}
			}
			h->n_maps++;
		default :
			break;
		}
		ph = (struct pmap_hdr *)(((uint8_t *)h) + ph->maph_length);
	}

	lvds_loc = SWAP_32(lvd->lvd_int_seq_ext.ext_loc);
	lvds_len = SWAP_32(lvd->lvd_int_seq_ext.ext_len);

	fsd_prn = SWAP_16(lvd->lvd_lvcu.lad_ext_prn);
	fsd_loc = SWAP_32(lvd->lvd_lvcu.lad_ext_loc);
	fsd_len = SWAP_32(lvd->lvd_lvcu.lad_ext_len);

	free(lvd);

	/*
	 * Get the latest LVID
	 */
	if (ud_get_latest_lvid(h, lvds_loc, lvds_len) != 0) {
		return (1);
	}

	if (ud_get_latest_fsd(h, fsd_prn, fsd_loc, fsd_len) != 0) {
		return (1);
	}

	return (0);
}

static int32_t
ud_get_latest_lvid(ud_handle_t h, uint32_t lvds_loc, uint32_t lvds_len)
{
	uint8_t *addr, *taddr, *eaddr;
	uint16_t id;
	uint64_t off;
	struct tag *tag;
	struct log_vol_int_desc *lvid;

begin:
	if ((addr = (uint8_t *)malloc(lvds_len)) == NULL) {
		return (1);
	}

	off = lvds_loc * h->udfs.lbsize;
	if (ud_read_dev(h, off, addr, lvds_len) != 0) {
		goto end;
	}

	for (taddr = addr, eaddr = addr + h->udfs.mvds_len; taddr < eaddr;
			taddr += h->udfs.lbsize, lvds_loc ++) {

		/* LINTED */
		tag = (struct tag *)taddr;
		id = SWAP_16(tag->tag_id);
		/*
		 * If you cannot verify the tag just skip it
		 * This is not a fatal error
		 */
		if (ud_verify_tag(h, tag, id, lvds_loc, 1, 0) != 0) {
			continue;
		}
		switch (id) {
		case UD_LOG_VOL_INT :

			/*
			 * Logical Volume Integrity Descriptor
			 */
			/* LINTED */
			lvid = (struct log_vol_int_desc *)taddr;
			h->udfs.lvid_loc = lvds_loc;
			h->udfs.lvid_len = ((uint32_t)
			&((struct log_vol_int_desc *)0)->lvid_fst) +
				SWAP_32(lvid->lvid_npart) * 8 +
				SWAP_32(lvid->lvid_liu);
			h->udfs.lvid_len = lb_roundup(h->udfs.lvid_len,
				h->udfs.lbsize);

			/*
			 * It seems we have a next integrity
			 * sequence
			 */
			if (SWAP_32(lvid->lvid_nie.ext_len) != 0) {
				free(addr);
				lvds_loc = SWAP_32(lvid->lvid_nie.ext_loc);
				lvds_len = SWAP_32(lvid->lvid_nie.ext_len);
				goto begin;
			}
			goto end;
		case UD_TERM_DESC :

			/*
			 * Success fully completed
			 */
				goto end;
		default :
			/*
			 * If you donot undetstand any tag just skip
			 * it. This is not a fatal error
			 */
			break;
		}
	}
end:
	free(addr);
	if (h->udfs.lvid_len == 0) {
		return (1);
	}
	return (0);
}

static int32_t
ud_get_latest_fsd(ud_handle_t h, uint16_t fsd_prn,
	uint32_t fsd_loc, uint32_t fsd_len)
{
	uint8_t *addr, *taddr, *eaddr;
	uint16_t id;
	uint64_t off;
	uint32_t fsds_loc, fsds_len;
	struct tag *tag;
	struct file_set_desc *fsd;
	uint32_t old_fsn = 0;

begin:
	h->udfs.fsds_prn = fsd_prn;
	h->udfs.fsds_loc = fsd_loc;
	h->udfs.fsds_len = fsd_len;

	fsds_loc = ud_xlate_to_daddr(h, fsd_prn, fsd_loc);
	fsds_len = lb_roundup(fsd_len, h->udfs.lbsize);

	if ((addr = (uint8_t *)malloc(fsds_len)) == NULL) {
		return (1);
	}

	off = fsds_loc * h->udfs.lbsize;
	if (ud_read_dev(h, off, addr, fsds_len) != 0) {
		goto end;
	}

	for (taddr = addr, eaddr = addr + h->udfs.mvds_len; taddr < eaddr;
			taddr += h->udfs.lbsize, fsds_loc ++) {

		/* LINTED */
		tag = (struct tag *)taddr;
		id = SWAP_16(tag->tag_id);
		/*
		 * If you cannot verify the tag just skip it
		 * This is not a fatal error
		 */
		if (ud_verify_tag(h, tag, id, fsds_loc, 1, 0) != 0) {
			continue;
		}
		switch (id) {
		case UD_FILE_SET_DESC :
			/* LINTED */
			fsd = (struct file_set_desc *)taddr;
			if ((h->udfs.fsd_len == 0) ||
				(SWAP_32(fsd->fsd_fs_no) > old_fsn)) {
				old_fsn = SWAP_32(fsd->fsd_fs_no);
				h->udfs.fsd_loc = fsds_loc;
				h->udfs.fsd_len = lb_roundup(512,
					h->udfs.lbsize);
				h->udfs.ricb_prn =
					SWAP_16(fsd->fsd_root_icb.lad_ext_prn);
				h->udfs.ricb_loc =
					SWAP_32(fsd->fsd_root_icb.lad_ext_loc);
				h->udfs.ricb_len =
					SWAP_32(fsd->fsd_root_icb.lad_ext_len);
			}
			if (SWAP_32(fsd->fsd_next.lad_ext_len) != 0) {
				fsd_prn = SWAP_16(fsd->fsd_next.lad_ext_prn);
				fsd_loc = SWAP_32(fsd->fsd_next.lad_ext_loc);
				fsd_len = SWAP_32(fsd->fsd_next.lad_ext_len);
				goto begin;
			}
			break;
		case UD_TERM_DESC :

			/*
			 * Success fully completed
			 */
			goto end;
		default :
			/*
			 * If you donot undetstand any tag just skip
			 * it. This is not a fatal error
			 */
			break;
		}
	}

end:
	free(addr);
	if (h->udfs.fsd_len == 0) {
		return (1);
	}
	return (0);
}

int32_t
ud_get_num_blks(ud_handle_t h, uint32_t *blkno)
{
	struct vtoc vtoc;
	struct dk_cinfo dki_info;
	int32_t error;

	/*
	 * Get VTOC from driver
	 */
	if ((error = ioctl(h->fd, DKIOCGVTOC, (intptr_t)&vtoc)) != 0) {
		return (error);
	}

	/*
	 * Verify if is proper
	 */
	if (vtoc.v_sanity != VTOC_SANE) {
		return (EINVAL);
	}

	/*
	 * Get dk_cinfo from driver
	 */
	if ((error = ioctl(h->fd, DKIOCINFO, (intptr_t)&dki_info)) != 0) {
		return (error);
	}

	if (dki_info.dki_partition >= V_NUMPAR) {
		return (EINVAL);
	}

	/*
	 * Return the size of the partition
	 */
	*blkno = vtoc.v_part[dki_info.dki_partition].p_size;

	return (0);
}

uint32_t
ud_xlate_to_daddr(ud_handle_t h, uint16_t prn, uint32_t blkno)
{
	int32_t i;
	struct ud_map *m;
	struct ud_part *p;


	if (prn < h->n_maps) {
		m = &h->maps[prn];
		for (i = 0; i < h->n_parts; i++) {
			p = &h->part[i];
			if (m->udm_pn == p->udp_number) {
				return (p->udp_start + blkno);
			}
		}
	}
	return (0);
}

/* ------ END Read and translate the on disk VDS to IN CORE format -------- */

int32_t
ud_verify_tag(ud_handle_t h, struct tag *tag, uint16_t id,
	uint32_t blockno, int32_t do_crc, int32_t print_msg)
{
	int32_t i;
	uint8_t *addr, cksum = 0;
	uint16_t crc;


	/*
	 * Verify Tag Identifier
	 */
	if (tag->tag_id != SWAP_16(id)) {
		if (print_msg != 0) {
			(void) fprintf(stderr,
				gettext("tag does not verify tag %x req %x\n"),
				SWAP_16(tag->tag_id), id);
		}
		return (1);
	}

	/*
	 * Verify Tag Descriptor Version
	 */
	if (SWAP_16(tag->tag_desc_ver) != h->udfs.ecma_version) {
		if (print_msg != 0) {
			(void) fprintf(stderr,
				gettext("tag version does not match with "
				"NSR descriptor version TAG %x NSR %x\n"),
				SWAP_16(tag->tag_desc_ver),
				h->udfs.ecma_version);
		}
		return (1);
	}

	/*
	 * Caliculate Tag Checksum
	 */
	addr = (uint8_t *)tag;
	for (i = 0; i <= 15; i++) {
		if (i != 4) {
			cksum += addr[i];
		}
	}

	/*
	 * Verify Tag Checksum
	 */
	if (cksum != tag->tag_cksum) {
		if (print_msg != 0) {
			(void) fprintf(stderr,
				gettext("Checksum Does not Verify TAG"
				" %x CALC %x\n"), tag->tag_cksum, cksum);
		}
		return (1);
	}


	/*
	 * Do we want to do crc
	 */
	if (do_crc) {
		if (tag->tag_crc_len) {

			/*
			 * Caliculate CRC for the descriptor
			 */
			crc = ud_crc(addr + 0x10, SWAP_16(tag->tag_crc_len));

			/*
			 * Verify CRC
			 */
			if (crc != SWAP_16(tag->tag_crc)) {
				if (print_msg != 0) {
					(void) fprintf(stderr,
						gettext("CRC Does not verify"
						" TAG %x CALC %x %x\n"),
						SWAP_16(tag->tag_crc),
						crc, addr);
				}
			}
		}

		/*
		 * Verify Tag Location
		 */
		if (SWAP_32(blockno) != tag->tag_loc) {
			if (print_msg != 0) {
				(void) fprintf(stderr,
					gettext("Tag Location Does not verify"
					" blockno %x tag_blockno %x\n"),
					blockno, SWAP_32(tag->tag_loc));
			}
		}
	}

	return (0);
}


/* ARGSUSED1 */
void
ud_make_tag(ud_handle_t h, struct tag *tag, uint16_t tag_id,
	uint32_t blkno, uint16_t crc_len)
{
	int32_t i;
	uint16_t crc;
	uint8_t *addr, cksum = 0;

	tag->tag_id = SWAP_16(tag_id);
	tag->tag_desc_ver = SWAP_16(h->udfs.ecma_version);
	tag->tag_cksum = 0;
	tag->tag_res = 0;

	/*
	 * Calicualte and assign CRC, CRC_LEN
	 */
	addr = (uint8_t *)tag;
	crc = ud_crc(addr + 0x10, crc_len);
	tag->tag_crc = SWAP_16(crc);
	tag->tag_crc_len = SWAP_16(crc_len);
	tag->tag_loc = SWAP_32(blkno);

	/*
	 * Caliculate Checksum
	 */
	for (i = 0; i <= 15; i++) {
		cksum += addr[i];
	}

	/*
	 * Assign Checksum
	 */
	tag->tag_cksum = cksum;
}

/* **************** udf specific subroutines *********************** */

static uint16_t ud_crc_table[256] = {
	0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
	0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
	0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
	0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
	0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
	0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
	0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
	0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
	0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
	0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
	0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
	0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
	0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
	0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
	0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
	0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
	0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
	0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
	0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
	0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
	0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
	0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
	0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
	0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
	0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
	0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
	0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
	0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
	0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
	0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
	0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
	0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
};

static uint16_t
ud_crc(uint8_t *addr, int32_t len)
{
	uint16_t crc = 0;

	while (len-- > 0) {
		crc = ud_crc_table[(crc >> 8 ^ *addr++) & 0xff] ^ (crc<<8);
	}

	return (crc);
}

#define	MAXNAMLEN	0x200


#define	POUND		0x0023
#define	DOT		0x002E
#define	SLASH		0x002F
#define	UNDERBAR	0x005F


static uint16_t htoc[16] = {'0', '1', '2', '3',
	'4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
/*
 * unicode is the string of 16-bot characters
 * length is the number of 16-bit characters
 */
static int32_t
UdfTxName(uint16_t *unicode, int32_t count)
{
	int32_t i, j, k, lic, make_crc, dot_loc;
	uint16_t crc;

	if ((unicode[0] == DOT) &&
		((count == 1) || ((count == 2) && (unicode[1] == DOT)))) {
		crc = DOT;
		if (count == 2) {
			crc += DOT;
		}
		unicode[0] = UNDERBAR;
		unicode[1] = POUND;
		unicode[2] = htoc[(uint16_t)(crc & 0xf000) >> 12];
		unicode[3] = htoc[(uint16_t)(crc & 0xf00) >> 8];
		unicode[4] = htoc[(uint16_t)(crc & 0xf0) >> 4];
		unicode[5] = htoc[crc & 0xf];
		return (6);
	}
	crc = 0;
	j = make_crc = 0;
	lic = dot_loc = -1;
	for (i = 0; i < count; i++) {
		if (make_crc) {
			crc += unicode[i];
		}
		if (unicode[i] == DOT) {
			dot_loc = j;
		}
		if ((unicode[i] == SLASH) ||
			(unicode[i] == NULL)) {
			if (make_crc == 0) {
				for (k = 0; k <= i; k++) {
					crc += unicode[k];
				}
				make_crc = 1;
			}
			if (lic != (i - 1)) {
				unicode[j++] = UNDERBAR;
			}
			lic = i;
		} else {
			unicode[j++] = unicode[i];
		}
	}

	if (make_crc) {
		if (dot_loc != -1) {
			if ((j + 5) > MAXNAMLEN) {
				if ((j - dot_loc + 5) > MAXNAMLEN) {
					j = MAXNAMLEN - 5 + dot_loc;
					for (k = MAXNAMLEN;
						j >= dot_loc; k --, j--) {
						unicode[k] = unicode[j];
					}
					k = 0;
				} else {
					for (k = MAXNAMLEN;
						j >= dot_loc; k--, j--) {
						unicode[k] = unicode[j];
					}
					k -= 4;
				}
				j = MAXNAMLEN;
			} else {
				for (k = j; k >= dot_loc; k--) {
					unicode[k + 5] = unicode[k];
				}
				k = dot_loc;
				j += 5;
			}
		} else {
			if ((j + 5) > MAXNAMLEN) {
				j = MAXNAMLEN;
				k = MAXNAMLEN - 5;
			} else {
				k = j;
				j += 5;
			}
		}
		unicode[k++] = POUND;
		unicode[k++] = htoc[(uint16_t)(crc & 0xf000) >> 12];
		unicode[k++] = htoc[(uint16_t)(crc & 0xf00) >> 8];
		unicode[k++] = htoc[(uint16_t)(crc & 0xf0) >> 4];
		unicode[k++] = htoc[crc & 0xf];
	}
	return (j);
}

/*
 * Assumes the output buffer is large
 * enough to hold the uncompressed
 * code
 */
static int32_t
UncompressUnicode(
	int32_t numberOfBytes,	/* (Input) number of bytes read from media. */
	uint8_t *UDFCompressed,	/* (Input) bytes read from media. */
	uint16_t *unicode)	/* (Output) uncompressed unicode characters. */
{
	int32_t compID;
	int32_t returnValue, unicodeIndex, byteIndex;


	/*
	 * Use UDFCompressed to store current byte being read.
	 */
	compID = UDFCompressed[0];

	/* First check for valid compID. */
	if (compID != 8 && compID != 16) {
		returnValue = -1;
	} else {
		unicodeIndex = 0;
		byteIndex = 1;

		/* Loop through all the bytes. */
		while (byteIndex < numberOfBytes) {
			if (compID == 16) {
				/*
				 * Move the first byte to the
				 * high bits of the unicode char.
				 */
				unicode[unicodeIndex] =
					UDFCompressed[byteIndex++] << 8;
			} else {
				unicode[unicodeIndex] = 0;
			}
			if (byteIndex < numberOfBytes) {
				/*
				 * Then the next byte to the low bits.
				 */
				unicode[unicodeIndex] |=
					UDFCompressed[byteIndex++];
			}
			unicodeIndex++;
		}
		returnValue = unicodeIndex;
	}
	return (returnValue);
}





static int32_t
ud_compressunicode(
	int32_t numberOfChars,	/* (Input) number of unicode characters. */
	int32_t compID,		/* (Input) compression ID to be used. */
	uint16_t *unicode,	/* (Input) unicode characters to compress. */
	uint8_t *UDFCompressed) /* (Output) compressed string, as bytes. */
{
	int32_t byteIndex;

	if (compID != 8 && compID != 16) {
		/*
		 * Unsupported compression ID !
		 */
		byteIndex = -1;
	} else {
		/*
		 * Place compression code in first byte.
		 */
		UDFCompressed[0] = (uint8_t)compID;
		(void) strncpy((caddr_t)&UDFCompressed[1],
			(caddr_t)unicode, numberOfChars);
		byteIndex = numberOfChars + 1;
	}
	return (byteIndex);
}


static int32_t
ud_convert2utf8(uint8_t *ibuf, uint8_t *obuf, int32_t length)
{
	int i, size;
	uint16_t *buf;

	/* LINTED */
	buf = (uint16_t *)obuf;

	size = UncompressUnicode(length, ibuf, buf);

	size = UdfTxName(buf, size);

	for (i = 0; i < size; i++) {
		obuf[i] = (uint8_t)buf[i];
	}
	obuf[i] = '\0';

	return (size);
}

static int32_t
ud_convert2utf16(uint8_t *ibuf, uint8_t *obuf, int32_t length)
{
	int32_t comp_len;
	uint16_t *ptr;

	/* LINTED */
	ptr = (uint16_t *)ibuf;
	comp_len = ud_compressunicode(length, 8, ptr, obuf);

	return (comp_len);
}

/*
 * Assumption code set is zero in udfs
 */
void
ud_convert2local(int8_t *ibuf, int8_t *obuf, int32_t length)
{
	wchar_t buf4c[128];
	int32_t i, comp, index;

	/*
	 * Special uncompress code
	 * written to accomodate solaris wchar_t
	 */
	comp = ibuf[0];
	for (i = 0, index = 1; i < length; i++) {
		if (comp == 16) {
			buf4c[i] = ibuf[index++] << 8;
		} else {
			buf4c[i] = 0;
		}
		if (index < length) {
			buf4c[i] |= ibuf[index++];
		}
	}
	(void) wcstombs((char *)obuf, buf4c, 128);
}


/* ------------ Routines to print basic structures Part 1 ---------------- */



void
print_charspec(FILE *fout, char *name, struct charspec *cspec)
{
	int i = 0;

	(void) fprintf(fout,
		"%s : %x - \"", name, cspec->cs_type);
	for (i = 0; i < 63; i++) {
		(void) fprintf(fout,
			"%c", cspec->cs_info[i]);
	}
	(void) fprintf(fout, "\n");
}

/* ARGSUSED */
void
print_dstring(FILE *fout, char *name, uint16_t cset, char *bufc, uint8_t length)
{
	int8_t bufmb[1024];

	ud_convert2local(bufc, bufmb, length);

	(void) fprintf(fout,
		"%s %s\n", name, bufmb);
}

void
set_dstring(dstring_t *dp, char *cp, int32_t len)
{
	int32_t length;

	bzero(dp, len);
	length = strlen(cp);
	if (length > len - 1) {
		length = len - 1;
	}
	(void) strncpy(dp, cp, length);
	dp[len - 1] = length;
}

void
print_tstamp(FILE *fout, char *name, tstamp_t *ts)
{
	(void) fprintf(fout, "%s tz : %d yr : %d mo : %d da : %d "
		"Time : %d : %d : %d : %d : %d : %d\n", name,
		SWAP_16(ts->ts_tzone), SWAP_16(ts->ts_year), ts->ts_month,
		ts->ts_day, ts->ts_hour, ts->ts_min, ts->ts_sec, ts->ts_csec,
		ts->ts_husec, ts->ts_usec);
}



void
make_regid(ud_handle_t h, struct regid *reg, char *id, int32_t type)
{
	reg->reg_flags = 0;
	(void) strncpy(reg->reg_id, id, 23);

	if (type == REG_DOM_ID) {
		struct dom_id_suffix *dis;

		/* LINTED */
		dis = (struct dom_id_suffix *)reg->reg_ids;
		dis->dis_udf_revison = SWAP_16(h->udfs.ma_write);
		dis->dis_domain_flags = 0;

	} else if (type == REG_UDF_ID) {
		struct udf_id_suffix *uis;

		/* LINTED */
		uis = (struct udf_id_suffix *)reg->reg_ids;
		uis->uis_udf_revision = SWAP_16(h->udfs.ma_write);
		uis->uis_os_class = OS_CLASS_UNIX;
		uis->uis_os_identifier = OS_IDENTIFIER_SOLARIS;
	} else if (type == REG_UDF_II) {
		struct impl_id_suffix *iis;

		iis = (struct impl_id_suffix *)reg->reg_ids;
		iis->iis_os_class = OS_CLASS_UNIX;
		iis->iis_os_identifier = OS_IDENTIFIER_SOLARIS;
	}
}

void
print_regid(FILE *fout, char *name, struct regid *reg, int32_t type)
{
	(void) fprintf(fout, "%s : 0x%x : \"%s\" :",
		name, reg->reg_flags, reg->reg_id);

	if (type == REG_DOM_ID) {
		struct dom_id_suffix *dis;

		/* LINTED */
		dis = (struct dom_id_suffix *)reg->reg_ids;
		(void) fprintf(fout, " 0x%x : %s : %s\n",
			SWAP_16(dis->dis_udf_revison),
			(dis->dis_domain_flags & PROTECT_SOFT_WRITE) ?
				"HW Protect" : "No HW Write Protect",
			(dis->dis_domain_flags & PROTECT_HARD_WRITE) ?
				"SW Protect" : "No SW Protect");
	} else if (type == REG_UDF_ID) {
		struct udf_id_suffix *uis;

		/* LINTED */
		uis = (struct udf_id_suffix *)reg->reg_ids;
		(void) fprintf(fout,
			" 0x%x : OS Class 0x%x : OS Identifier 0x%x\n",
			SWAP_16(uis->uis_udf_revision),
			uis->uis_os_class, uis->uis_os_identifier);
	} else {
		struct impl_id_suffix *iis;

		iis = (struct impl_id_suffix *)reg->reg_ids;
		(void) fprintf(fout,
			" OS Class 0x%x : OS Identifier 0x%x\n",
			iis->iis_os_class, iis->iis_os_identifier);
	}
}

#ifdef	OLD
void
print_regid(FILE *fout, char *name, struct regid *reg)
{
	(void) fprintf(fout, "%s : 0x%x : \"%s\" :",
		name, reg->reg_flags, reg->reg_id);

	if (strncmp(reg->reg_id, "*OSTA UDF Compliant", 19) == 0) {
		(void) fprintf(fout, " 0x%x : %s : %s\n",
			reg->reg_ids[0] | (reg->reg_ids[1] << 8),
			(reg->reg_ids[2] & 1) ?
				"HW Protect" : "No HW Write Protect",
			(reg->reg_ids[2] & 2) ?
				"SW Protect" : "No SW Protect");
	} else if ((strncmp(reg->reg_id, "*UDF Virtual Partition", 22) == 0) ||
		(strncmp(reg->reg_id, "*UDF Sparable Partition", 23) == 0) ||
		(strncmp(reg->reg_id, "*UDF Virtual Alloc Tbl", 22) == 0) ||
		(strncmp(reg->reg_id, "*UDF Sparing Table", 18) == 0)) {
		(void) fprintf(fout,
			" 0x%x : OS Class 0x%x : OS Identifier 0x%x\n",
			reg->reg_ids[0] | (reg->reg_ids[1] << 8),
			reg->reg_ids[2], reg->reg_ids[3]);
	} else {
		(void) fprintf(fout,
			" OS Class 0x%x : OS Identifier 0x%x\n",
			reg->reg_ids[0], reg->reg_ids[1]);
	}
}
#endif


/* ------------ Routines to print basic structures Part 2 ---------------- */
/*
 * Part 2
 * This part is OS specific and is currently
 * not supported
 */

/* ------------ Routines to print basic structures Part 3 ---------------- */

void
print_ext_ad(FILE *fout, char *name, struct extent_ad *ead)
{
	(void) fprintf(fout,
		"%s EAD Len %x Loc %x\n",
		name, SWAP_32(ead->ext_len), SWAP_32(ead->ext_loc));
}

void
print_tag(FILE *fout, struct tag *tag)
{
	(void) fprintf(fout,
		"tag_id : %x ver : %x cksum : %x "
		"sno : %x crc : %x crc_len : %x loc : %x\n",
		SWAP_16(tag->tag_id), SWAP_16(tag->tag_desc_ver),
		tag->tag_cksum, SWAP_16(tag->tag_sno),
		SWAP_16(tag->tag_crc), SWAP_16(tag->tag_crc_len),
		SWAP_32(tag->tag_loc));
}


void
print_pvd(FILE *fout, struct pri_vol_desc *pvd)
{
	(void) fprintf(fout,
		"\n\t\t\tPrimary Volume Descriptor\n");
	print_tag(fout, &pvd->pvd_tag);
	(void) fprintf(fout, "vdsn : %x vdn : %x\n",
		SWAP_32(pvd->pvd_vdsn), SWAP_32(pvd->pvd_pvdn));
	print_dstring(fout, "volid : ", pvd->pvd_desc_cs.cs_type,
			pvd->pvd_vol_id, 32);
	(void) fprintf(fout,
		"vsn : %x mvsn : %x il : %x mil :"
		" %x csl : %x mcsl %x\n",
		SWAP_16(pvd->pvd_vsn), SWAP_16(pvd->pvd_mvsn),
		SWAP_16(pvd->pvd_il), SWAP_16(pvd->pvd_mil),
		SWAP_32(pvd->pvd_csl), SWAP_32(pvd->pvd_mcsl));
	print_dstring(fout, "vsid :", pvd->pvd_desc_cs.cs_type,
			pvd->pvd_vsi, 128);
	print_charspec(fout, "desc_cs", &pvd->pvd_desc_cs);
	print_charspec(fout, "exp_cs", &pvd->pvd_exp_cs);
	print_ext_ad(fout, "val ", &pvd->pvd_vol_abs);
	print_ext_ad(fout, "vcnl ", &pvd->pvd_vcn);
	print_regid(fout, "ai", &pvd->pvd_appl_id, REG_UDF_II);
	print_regid(fout, "ii", &pvd->pvd_ii, REG_UDF_II);
	(void) fprintf(fout, "pvdsl : %x flags : %x\n",
		SWAP_32(pvd->pvd_pvdsl),
		SWAP_16(pvd->pvd_flags));
}

void
print_avd(FILE *fout, struct anch_vol_desc_ptr *avdp)
{
	(void) fprintf(fout,
		"\n\t\t\tAnchor Volume Descriptor\n");
	print_tag(fout, &avdp->avd_tag);
	print_ext_ad(fout, "Main Volume Descriptor Sequence : ",
			&avdp->avd_main_vdse);
	print_ext_ad(fout, "Reserve Volume Descriptor Sequence : ",
			&avdp->avd_res_vdse);
}

void
print_vdp(FILE *fout, struct vol_desc_ptr *vdp)
{
	(void) fprintf(fout,
		"\n\t\t\tVolume Descriptor Pointer\n");
	print_tag(fout, &vdp->vdp_tag);
	(void) fprintf(fout, "vdsn : %x ",
		SWAP_32(vdp->vdp_vdsn));
	print_ext_ad(fout, "vdse ", &vdp->vdp_nvdse);
}

void
print_iuvd(FILE *fout, struct iuvd_desc *iuvd)
{
	(void) fprintf(fout,
		"\n\t\t\tImplementation Use Volume Descriptor\n");
	print_tag(fout, &iuvd->iuvd_tag);
	(void) fprintf(fout,
		"vdsn : %x ", SWAP_32(iuvd->iuvd_vdsn));
	print_regid(fout, "Impl Id : ", &iuvd->iuvd_ii, REG_UDF_ID);
	print_charspec(fout, "cset ", &iuvd->iuvd_cset);
	print_dstring(fout, "lvi : ", iuvd->iuvd_cset.cs_type,
			iuvd->iuvd_lvi, 128);
	print_dstring(fout, "ifo1 : ", iuvd->iuvd_cset.cs_type,
			iuvd->iuvd_ifo1, 36);
	print_dstring(fout, "ifo2 : ", iuvd->iuvd_cset.cs_type,
			iuvd->iuvd_ifo2, 36);
	print_dstring(fout, "ifo3 : ", iuvd->iuvd_cset.cs_type,
			iuvd->iuvd_ifo3, 36);

	print_regid(fout, "iid ", &iuvd->iuvd_iid, REG_UDF_II);
}

void
print_part(FILE *fout, struct part_desc *pd)
{
	(void) fprintf(fout,
		"\n\t\t\tPartition Descriptor\n");
	print_tag(fout, &pd->pd_tag);
	(void) fprintf(fout,
		"vdsn : %x flags : %x num : %x ",
		SWAP_32(pd->pd_vdsn),
		SWAP_16(pd->pd_pflags),
		SWAP_16(pd->pd_pnum));
	print_regid(fout, "contents ", &pd->pd_pcontents, REG_UDF_II);
	/* LINTED */
	print_phdr(fout, (struct phdr_desc *)(&pd->pd_pc_use));
	(void) fprintf(fout,
		"acc : %x start : %x length : %x ",
		SWAP_32(pd->pd_acc_type),
		SWAP_32(pd->pd_part_start),
		SWAP_32(pd->pd_part_length));
	print_regid(fout, "Impl Id : ", &pd->pd_ii, REG_UDF_II);
}

void
print_lvd(FILE *fout, struct log_vol_desc *lvd)
{
	(void) fprintf(fout,
		"\n\t\t\tLogical Volume Descriptor\n");
	print_tag(fout, &lvd->lvd_tag);
	(void) fprintf(fout,
		"vdsn : %x ", SWAP_32(lvd->lvd_vdsn));
	print_charspec(fout, "Desc Char Set ", &lvd->lvd_desc_cs);
	print_dstring(fout, "lvid : ", lvd->lvd_desc_cs.cs_type,
			lvd->lvd_lvid, 28);
	(void) fprintf(fout,
		"lbsize : %x ",
		SWAP_32(lvd->lvd_log_bsize));
	print_regid(fout, "Dom Id", &lvd->lvd_dom_id, REG_DOM_ID);
	print_long_ad(fout, "lvcu", &lvd->lvd_lvcu);
	(void) fprintf(fout,
		"mtlen : %x nmaps : %x ",
		SWAP_32(lvd->lvd_mtbl_len),
		SWAP_32(lvd->lvd_num_pmaps));
	print_regid(fout, "Impl Id : ", &lvd->lvd_ii, REG_UDF_II);
	print_ext_ad(fout, "Int Seq", &lvd->lvd_int_seq_ext);
	print_pmaps(fout, lvd->lvd_pmaps, SWAP_32(lvd->lvd_num_pmaps));
}

void
print_usd(FILE *fout, struct unall_spc_desc *ua)
{
	int32_t i, count;

	(void) fprintf(fout,
		"\n\t\t\tUnallocated Space Descriptor\n");
	print_tag(fout, &ua->ua_tag);
	count = SWAP_32(ua->ua_nad);
	(void) fprintf(fout,
		"vdsn : %x nad : %x\n",
		SWAP_32(ua->ua_vdsn), count);
	for (i = 0; i < count; i++) {
		(void) fprintf(fout,
			"loc : %x len : %x\n",
			SWAP_32(ua->ua_al_dsc[i * 2]),
			SWAP_32(ua->ua_al_dsc[i * 2 + 1]));
	}
}

void
print_lvid(FILE *fout, struct log_vol_int_desc *lvid)
{
	int32_t i, count;
	caddr_t addr;
	struct lvid_iu *liu;

	(void) fprintf(fout,
		"\n\t\t\tLogical Volume Integrity Descriptor\n");
	print_tag(fout, &lvid->lvid_tag);
	print_tstamp(fout, "Rec TM ", &lvid->lvid_tstamp);
	if (SWAP_32(lvid->lvid_int_type) == 0) {
		(void) fprintf(fout,
			"int_typ : Open\n");
	} else if (SWAP_32(lvid->lvid_int_type) == 1) {
		(void) fprintf(fout, "int_typ : Closed\n");
	} else {
		(void) fprintf(fout, "int_typ : Unknown\n");
	}
	print_ext_ad(fout, "Nie ", &lvid->lvid_nie);
	count = SWAP_32(lvid->lvid_npart);
	(void) fprintf(fout,
		"Uniq : %llx npart : %x liu : %x\n",
		SWAP_64(lvid->lvid_lvcu.lvhd_uniqid),
		count, SWAP_32(lvid->lvid_liu));
	for (i = 0; i < count; i++) {
		(void) fprintf(fout,
			"Part : %x Free : %x Size : %x\n",
			i, SWAP_32(lvid->lvid_fst[i]),
			SWAP_32(lvid->lvid_fst[count + i]));
	}

	addr = (caddr_t)lvid->lvid_fst;
	/* LINTED */
	liu = (struct lvid_iu *)(addr + 2 * count * 4);
	print_regid(fout, "Impl Id :", &liu->lvidiu_regid, REG_UDF_II);
	(void) fprintf(fout,
		"nfiles : %x ndirs : %x miread : %x"
		" miwrite : %x mawrite : %x\n",
		SWAP_32(liu->lvidiu_nfiles), SWAP_32(liu->lvidiu_ndirs),
		SWAP_16(liu->lvidiu_mread), SWAP_16(liu->lvidiu_mwrite),
		SWAP_16(liu->lvidiu_maxwr));
}


/* ------------ Routines to print basic structures Part 4 ---------------- */

void
print_fsd(FILE *fout, ud_handle_t h, struct file_set_desc *fsd)
{
	(void) fprintf(fout,
		"\n\t\t\tFile Set Descriptor\n");

	print_tag(fout, &fsd->fsd_tag);
	print_tstamp(fout, "Rec TM ", &fsd->fsd_time);
	(void) fprintf(fout,
		"ilvl : %x milvl : %x csl : %x"
		" mcsl : %x fsn : %x fsdn : %x\n",
		SWAP_16(fsd->fsd_ilevel), SWAP_16(fsd->fsd_mi_level),
		SWAP_32(fsd->fsd_cs_list), SWAP_32(fsd->fsd_mcs_list),
		SWAP_32(fsd->fsd_fs_no), SWAP_32(fsd->fsd_fsd_no));
	print_charspec(fout, "ID CS ", &fsd->fsd_lvidcs);
	print_dstring(fout, "lvi : ", fsd->fsd_lvidcs.cs_type,
			fsd->fsd_lvid, 128);
	print_charspec(fout, "ID CS ", &fsd->fsd_fscs);
	print_dstring(fout, "fsi : ", fsd->fsd_lvidcs.cs_type,
			fsd->fsd_fsi, 32);
	print_dstring(fout, "cfi : ", fsd->fsd_lvidcs.cs_type,
			fsd->fsd_cfi, 32);
	print_dstring(fout, "afi : ", fsd->fsd_lvidcs.cs_type,
			fsd->fsd_afi, 32);
	print_long_ad(fout, "Ricb ", &fsd->fsd_root_icb);
	print_regid(fout, "DI ", &fsd->fsd_did, REG_DOM_ID);
	print_long_ad(fout, "Next Fsd ", &fsd->fsd_next);
	if (h->udfs.ecma_version == UD_ECMA_VER3) {
		print_long_ad(fout, "System Stream Directory ICB ",
				&fsd->fsd_next);
	}
}

void
print_phdr(FILE *fout, struct phdr_desc *ph)
{
	print_short_ad(fout, "ust ", &ph->phdr_ust);
	print_short_ad(fout, "usb ", &ph->phdr_usb);
	print_short_ad(fout, "int ", &ph->phdr_it);
	print_short_ad(fout, "fst ", &ph->phdr_fst);
	print_short_ad(fout, "fsh ", &ph->phdr_fsb);
}

void
print_fid(FILE *fout, struct file_id *fid)
{
	int32_t i;
	uint8_t *addr;

	(void) fprintf(fout,
		"File Identifier Descriptor\n");
	print_tag(fout, &fid->fid_tag);
	(void) fprintf(fout, "fvn : %x fc : %x length : %x ",
		fid->fid_ver, fid->fid_flags, fid->fid_idlen);
	print_long_ad(fout, "ICB", &fid->fid_icb);
	addr = &fid->fid_spec[SWAP_16(fid->fid_iulen)];
	(void) fprintf(fout, "iulen : %x comp : %x name : ",
		SWAP_16(fid->fid_iulen), *addr);
	addr++;
	for (i = 0; i < fid->fid_idlen; i++) {
		(void) fprintf(fout, "%c", *addr++);
	}
	(void) fprintf(fout, "\n");
}

void
print_aed(FILE *fout, struct alloc_ext_desc *aed)
{
	(void) fprintf(fout,
		"Allocation Extent Descriptor\n");
	print_tag(fout, &aed->aed_tag);
	(void) fprintf(fout, "prev ael loc : %x laed : %x\n",
		SWAP_32(aed->aed_rev_ael), SWAP_32(aed->aed_len_aed));
}

static char *ftype[] = {
	"NON",  "USE",  "PIE",  "IE",
	"DIR",  "REG",  "BDEV", "CDEV",
	"EATT", "FIFO", "SOCK", "TERM",
	"SYML", "SDIR"
};

void
print_icb_tag(FILE *fout, struct icb_tag *itag)
{
	(void) fprintf(fout,
		"prnde : %x strat : %x param : %x max_ent %x\n",
		SWAP_32(itag->itag_prnde), SWAP_16(itag->itag_strategy),
		SWAP_16(itag->itag_param), SWAP_16(itag->itag_max_ent));
	(void) fprintf(fout,
		"ftype : %s prn : %x loc : %x flags : %x\n",
		(itag->itag_ftype >= 14) ? ftype[0] : ftype[itag->itag_ftype],
		SWAP_16(itag->itag_lb_prn),
		SWAP_32(itag->itag_lb_loc), SWAP_16(itag->itag_flags));
}


void
print_ie(FILE *fout, struct indirect_entry *ie)
{
	(void) fprintf(fout,
		"Indirect Entry\n");
	print_tag(fout, &ie->ie_tag);
	print_icb_tag(fout, &ie->ie_icb_tag);
	print_long_ad(fout, "ICB", &ie->ie_indirecticb);
}

void
print_td(FILE *fout, struct term_desc *td)
{
	(void) fprintf(fout,
		"Terminating Descriptor\n");
	print_tag(fout, &td->td_tag);
}

void
print_fe(FILE *fout, struct file_entry *fe)
{
	(void) fprintf(fout,
		"File Entry\n");
	print_tag(fout, &fe->fe_tag);
	print_icb_tag(fout, &fe->fe_icb_tag);
	(void) fprintf(fout,
		"uid : %x gid : %x perms : %x nlnk : %x\n",
		SWAP_32(fe->fe_uid), SWAP_32(fe->fe_gid),
		SWAP_32(fe->fe_perms), SWAP_16(fe->fe_lcount));
	(void) fprintf(fout,
		"rec_for : %x rec_dis : %x rec_len : %x "
		"sz : %llx blks : %llx\n",
		fe->fe_rec_for, fe->fe_rec_dis, SWAP_32(fe->fe_rec_len),
		SWAP_64(fe->fe_info_len), SWAP_64(fe->fe_lbr));
	print_tstamp(fout, "ctime ", &fe->fe_acc_time);
	print_tstamp(fout, "mtime ", &fe->fe_mod_time);
	print_tstamp(fout, "atime ", &fe->fe_attr_time);
	(void) fprintf(fout,
		"ckpoint : %x ", SWAP_32(fe->fe_ckpoint));
	print_long_ad(fout, "ICB", &fe->fe_ea_icb);
	print_regid(fout, "impl", &fe->fe_impl_id, REG_UDF_II);
	(void) fprintf(fout,
		"uniq_id : %llx len_ear : %x len_adesc %x\n",
		SWAP_64(fe->fe_uniq_id), SWAP_32(fe->fe_len_ear),
		SWAP_32(fe->fe_len_adesc));
}

void
print_pmaps(FILE *fout, uint8_t *addr, int32_t count)
{
	struct pmap_hdr *hdr;
	struct pmap_typ1 *map1;
	struct pmap_typ2 *map2;

	while (count--) {
		hdr = (struct pmap_hdr *)addr;
		switch (hdr->maph_type) {
		case 1 :
			/* LINTED */
			map1 = (struct pmap_typ1 *)hdr;
			(void) fprintf(fout, "Map type 1 ");
			(void) fprintf(fout, "VSN %x prn %x\n",
					SWAP_16(map1->map1_vsn),
					SWAP_16(map1->map1_pn));
			break;
		case 2 :
			/* LINTED */
			map2 = (struct pmap_typ2 *)hdr;
			(void) fprintf(fout, "Map type 2 ");
			(void) fprintf(fout, "VSN %x prn %x\n",
					SWAP_16(map2->map2_vsn),
					SWAP_16(map2->map2_pn));
			print_regid(fout, "Partition Type Identifier",
					&map2->map2_pti, REG_UDF_ID);
			break;
		default :
			(void) fprintf(fout, "unknown map type\n");
		}
		addr += hdr->maph_length;
	}
}



void
print_short_ad(FILE *fout, char *name, struct short_ad *sad)
{
	(void) fprintf(fout,
		"%s loc : %x len : %x\n", name,
		SWAP_32(sad->sad_ext_loc), SWAP_32(sad->sad_ext_len));
}

void
print_long_ad(FILE *fout, char *name, struct long_ad *lad)
{
	(void) fprintf(fout,
		"%s prn : %x loc : %x len : %x\n", name,
		SWAP_16(lad->lad_ext_prn), SWAP_32(lad->lad_ext_loc),
		SWAP_32(lad->lad_ext_len));
}