Adding upstream version 2.33.1.upstream/2.33.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 488 insertions, 0 deletions

diff --git a/libblkid/src/superblocks/udf.c b/libblkid/src/superblocks/udf.c
new file mode 100644
index 0000000..97e79da
--- /dev/null
+++ b/libblkid/src/superblocks/udf.c
@@ -0,0 +1,488 @@
+/*
+ * Copyright (C) 1999 by Andries Brouwer
+ * Copyright (C) 1999, 2000, 2003 by Theodore Ts'o
+ * Copyright (C) 2001 by Andreas Dilger
+ * Copyright (C) 2004 Kay Sievers <kay.sievers@vrfy.org>
+ * Copyright (C) 2008 Karel Zak <kzak@redhat.com>
+ * Copyright (C) 2014-2017 Pali Rohár <pali.rohar@gmail.com>
+ *
+ * This file may be redistributed under the terms of the
+ * GNU Lesser General Public License.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <stdint.h>
+
+#include "superblocks.h"
+
+#define udf_cid_to_enc(cid) ((cid) == 8 ? BLKID_ENC_LATIN1 : (cid) == 16 ? BLKID_ENC_UTF16BE : -1)
+
+struct dstring128 {
+	uint8_t	cid;
+	uint8_t	c[126];
+	uint8_t	clen;
+} __attribute__((packed));
+
+struct dstring32 {
+	uint8_t	cid;
+	uint8_t	c[30];
+	uint8_t	clen;
+} __attribute__((packed));
+
+struct volume_descriptor {
+	struct descriptor_tag {
+		uint16_t	id;
+		uint16_t	version;
+		uint8_t		checksum;
+		uint8_t		reserved;
+		uint16_t	serial;
+		uint16_t	crc;
+		uint16_t	crc_len;
+		uint32_t	location;
+	} __attribute__((packed)) tag;
+
+	union {
+		struct anchor_descriptor {
+			uint32_t	length;
+			uint32_t	location;
+		} __attribute__((packed)) anchor;
+
+		struct primary_descriptor {
+			uint32_t	seq_num;
+			uint32_t	desc_num;
+			struct dstring32 ident;
+			uint16_t	vds_num;
+			uint16_t	max_vol_seq;
+			uint16_t	ichg_lvl;
+			uint16_t	max_ichg_lvl;
+			uint32_t	charset_list;
+			uint32_t	max_charset_list;
+			struct dstring128 volset_id;
+		} __attribute__((packed)) primary;
+
+		struct logical_descriptor {
+			uint32_t	seq_num;
+			uint8_t		desc_charset[64];
+			struct dstring128 logvol_id;
+			uint32_t	logical_blocksize;
+			uint8_t		domain_id_flags;
+			char		domain_id[23];
+			uint16_t	udf_rev;
+			uint8_t		domain_suffix_flags;
+			uint8_t		reserved[5];
+			uint8_t		logical_contents_use[16];
+			uint32_t	map_table_length;
+			uint32_t	num_partition_maps;
+			uint8_t		imp_id[32];
+			uint8_t		imp_use[128];
+			uint32_t	lvid_length;
+			uint32_t	lvid_location;
+		} __attribute__((packed)) logical;
+
+		struct logical_vol_integ_descriptor {
+			uint8_t		recording_date[12];
+			uint32_t	type;
+			uint32_t	next_lvid_length;
+			uint32_t	next_lvid_location;
+			uint8_t		logical_contents_use[32];
+			uint32_t	num_partitions;
+			uint32_t	imp_use_length;
+		} __attribute__((packed)) logical_vol_integ;
+	} __attribute__((packed)) type;
+
+} __attribute__((packed));
+
+#define TAG_ID_PVD  1
+#define TAG_ID_AVDP 2
+#define TAG_ID_LVD  6
+#define TAG_ID_TD   8
+#define TAG_ID_LVID 9
+
+struct volume_structure_descriptor {
+	uint8_t		type;
+	uint8_t		id[5];
+	uint8_t		version;
+} __attribute__((packed));
+
+#define UDF_VSD_OFFSET			0x8000LL
+
+struct logical_vol_integ_descriptor_imp_use
+{
+	uint8_t		imp_id[32];
+	uint32_t	num_files;
+	uint32_t	num_dirs;
+	uint16_t	min_udf_read_rev;
+	uint16_t	min_udf_write_rev;
+	uint16_t	max_udf_write_rev;
+} __attribute__ ((packed));
+
+#define UDF_LVIDIU_OFFSET(vd) (sizeof((vd).tag) + sizeof((vd).type.logical_vol_integ) + 2 * 4 * le32_to_cpu((vd).type.logical_vol_integ.num_partitions))
+#define UDF_LVIDIU_LENGTH(vd) (le32_to_cpu((vd).type.logical_vol_integ.imp_use_length))
+
+static inline int gen_uuid_from_volset_id(unsigned char uuid[17], struct dstring128 *volset_id)
+{
+	int enc;
+	size_t i;
+	size_t len;
+	size_t clen;
+	size_t nonhexpos;
+	unsigned char buf[17];
+
+	memset(buf, 0, sizeof(buf));
+
+	clen = volset_id->clen;
+	if (clen > 0)
+		--clen;
+	if (clen > sizeof(volset_id->c))
+		clen = sizeof(volset_id->c);
+
+	enc = udf_cid_to_enc(volset_id->cid);
+	if (enc == -1)
+		return -1;
+
+	len = blkid_encode_to_utf8(enc, buf, sizeof(buf), volset_id->c, clen);
+	if (len < 8)
+		return -1;
+
+	nonhexpos = 16;
+	for (i = 0; i < 16; ++i) {
+		if (!isxdigit(buf[i])) {
+			nonhexpos = i;
+			break;
+		}
+	}
+
+	if (nonhexpos < 8) {
+		snprintf((char *) uuid, 17, "%02x%02x%02x%02x%02x%02x%02x%02x",
+			buf[0], buf[1], buf[2], buf[3],
+			buf[4], buf[5], buf[6], buf[7]);
+	} else if (nonhexpos < 16) {
+		for (i = 0; i < 8; ++i)
+			uuid[i] = tolower(buf[i]);
+		snprintf((char *) uuid + 8, 9, "%02x%02x%02x%02x",
+			buf[8], buf[9], buf[10], buf[11]);
+	} else {
+		for (i = 0; i < 16; ++i)
+			uuid[i] = tolower(buf[i]);
+		uuid[16] = 0;
+	}
+
+	return 0;
+}
+
+static int probe_udf(blkid_probe pr,
+		const struct blkid_idmag *mag __attribute__((__unused__)))
+{
+	struct volume_descriptor *vd;
+	struct volume_structure_descriptor *vsd;
+	struct logical_vol_integ_descriptor_imp_use *lvidiu;
+	uint32_t lvid_len = 0;
+	uint32_t lvid_loc = 0;
+	uint32_t bs;
+	uint32_t b;
+	uint16_t type;
+	uint32_t count;
+	uint32_t loc;
+	size_t i;
+	uint32_t vsd_len;
+	uint16_t udf_rev = 0;
+	int vsd_2048_valid = -1;
+	int have_label = 0;
+	int have_uuid = 0;
+	int have_logvolid = 0;
+	int have_volid = 0;
+	int have_volsetid = 0;
+
+	/* The block size of a UDF filesystem is that of the underlying
+	 * storage; we check later on for the special case of image files,
+	 * which may have any block size valid for UDF filesystem */
+	uint32_t pbs[] = { 0, 512, 1024, 2048, 4096 };
+	pbs[0] = blkid_probe_get_sectorsize(pr);
+
+	for (i = 0; i < ARRAY_SIZE(pbs); i++) {
+		/* Do not try with block size same as sector size two times */
+		if (i != 0 && pbs[0] == pbs[i])
+			continue;
+
+		/* ECMA-167 2/8.4, 2/9.1: Each VSD is either 2048 bytes long or
+		 * its size is same as blocksize (for blocksize > 2048 bytes)
+		 * plus padded with zeros */
+		vsd_len = pbs[i] > 2048 ? pbs[i] : 2048;
+
+		/* Process 2048 bytes long VSD only once */
+		if (vsd_len == 2048) {
+			if (vsd_2048_valid == 0)
+				continue;
+			else if (vsd_2048_valid == 1)
+				goto anchor;
+		}
+
+		/* Check for a Volume Structure Descriptor (VSD) */
+		for (b = 0; b < 64; b++) {
+			vsd = (struct volume_structure_descriptor *)
+				blkid_probe_get_buffer(pr,
+						UDF_VSD_OFFSET + b * vsd_len,
+						sizeof(*vsd));
+			if (!vsd)
+				return errno ? -errno : 1;
+			if (vsd->id[0] == '\0')
+				break;
+			if (memcmp(vsd->id, "NSR02", 5) == 0 ||
+			    memcmp(vsd->id, "NSR03", 5) == 0)
+				goto anchor;
+			else if (memcmp(vsd->id, "BEA01", 5) != 0 &&
+			         memcmp(vsd->id, "BOOT2", 5) != 0 &&
+			         memcmp(vsd->id, "CD001", 5) != 0 &&
+			         memcmp(vsd->id, "CDW02", 5) != 0 &&
+			         memcmp(vsd->id, "TEA01", 5) != 0)
+				/* ECMA-167 2/8.3.1: The volume recognition sequence is
+				 * terminated by the first sector which is not a valid
+				 * descriptor.
+				 * UDF-2.60 2.1.7: UDF 2.00 and lower revisions do not
+				 * have requirement that NSR descritor is in Extended Area
+				 * (between BEA01 and TEA01) and that there is only one
+				 * Extended Area. So do not stop scanning after TEA01. */
+				break;
+		}
+
+		if (vsd_len == 2048)
+			vsd_2048_valid = 0;
+
+		/* NSR was not found, try with next block size */
+		continue;
+
+anchor:
+		if (vsd_len == 2048)
+			vsd_2048_valid = 1;
+
+		/* Read Anchor Volume Descriptor (AVDP), detect block size */
+		vd = (struct volume_descriptor *)
+			blkid_probe_get_buffer(pr, 256 * pbs[i], sizeof(*vd));
+		if (!vd)
+			return errno ? -errno : 1;
+
+		/* Check that we read correct sector and detected correct block size */
+		if (le32_to_cpu(vd->tag.location) != 256)
+			continue;
+
+		type = le16_to_cpu(vd->tag.id);
+		if (type == TAG_ID_AVDP)
+			goto real_blksz;
+
+	}
+	return 1;
+
+real_blksz:
+	/* Use the actual block size from here on out */
+	bs = pbs[i];
+
+	/* get descriptor list address and block count */
+	count = le32_to_cpu(vd->type.anchor.length) / bs;
+	loc = le32_to_cpu(vd->type.anchor.location);
+
+	/* pick the primary descriptor from the list and read UDF identifiers */
+	for (b = 0; b < count; b++) {
+		vd = (struct volume_descriptor *)
+			blkid_probe_get_buffer(pr,
+					(uint64_t) (loc + b) * bs,
+					sizeof(*vd));
+		if (!vd)
+			return errno ? -errno : 1;
+		type = le16_to_cpu(vd->tag.id);
+		if (type == 0)
+			break;
+		if (le32_to_cpu(vd->tag.location) != loc + b)
+			break;
+		if (type == TAG_ID_TD)
+			break;
+		if (type == TAG_ID_PVD) {
+			if (!have_volid) {
+				int enc = udf_cid_to_enc(vd->type.primary.ident.cid);
+				uint8_t clen = vd->type.primary.ident.clen;
+				if (clen > 0)
+					--clen;
+				if (clen > sizeof(vd->type.primary.ident.c))
+					clen = sizeof(vd->type.primary.ident.c);
+				if (enc != -1)
+					have_volid = !blkid_probe_set_utf8_id_label(pr, "VOLUME_ID",
+							vd->type.primary.ident.c, clen, enc);
+			}
+			if (!have_uuid) {
+				/* VolumeSetIdentifier in UDF 2.01 specification:
+				 * =================================================================================
+				 * 2.2.2.5 dstring VolumeSetIdentifier
+				 *
+				 * Interpreted as specifying the identifier for the volume set.
+				 *
+				 * The first 16 characters of this field should be set to a unique value. The
+				 * remainder of the field may be set to any allowed value. Specifically, software
+				 * generating volumes conforming to this specification shall not set this field to a
+				 * fixed or trivial value. Duplicate disks which are intended to be identical may
+				 * contain the same value in this field.
+				 *
+				 * NOTE: The intended purpose of this is to guarantee Volume Sets with unique
+				 * identifiers. The first 8 characters of the unique part should come from a CS0
+				 * hexadecimal representation of a 32-bit time value. The remaining 8 characters
+				 * are free for implementation use.
+				 * =================================================================================
+				 *
+				 * Implementation in libblkid:
+				 * The first 16 (Unicode) characters of VolumeSetIdentifier are encoded to UTF-8
+				 * and then first 16 UTF-8 bytes are used to generate UUID. If all 16 bytes are
+				 * hexadecimal digits then their lowercase variants are used as UUID. If one of
+				 * the first 8 bytes (time value) is not hexadecimal digit then first 8 bytes are
+				 * encoded to their hexadecimal representations, resulting in 16 characters and
+				 * set as UUID. If all first 8 bytes (time value) are hexadecimal digits but some
+				 * remaining not then lowercase variant of the first 8 bytes are used as first
+				 * part of UUID and next 4 bytes encoded in hexadecimal representations (resulting
+				 * in 8 characters) are used as second part of UUID string.
+				 */
+				unsigned char uuid[17];
+				if (gen_uuid_from_volset_id(uuid, &vd->type.primary.volset_id) == 0)
+					have_uuid = !blkid_probe_strncpy_uuid(pr, uuid, sizeof(uuid));
+			}
+			if (!have_volsetid) {
+				int enc = udf_cid_to_enc(vd->type.primary.volset_id.cid);
+				uint8_t clen = vd->type.primary.volset_id.clen;
+				if (clen > 0)
+					--clen;
+				if (clen > sizeof(vd->type.primary.volset_id.c))
+					clen = sizeof(vd->type.primary.volset_id.c);
+				if (enc != -1)
+					have_volsetid = !blkid_probe_set_utf8_id_label(pr, "VOLUME_SET_ID",
+							vd->type.primary.volset_id.c, clen, enc);
+			}
+		} else if (type == TAG_ID_LVD) {
+			if (!lvid_len || !lvid_loc) {
+				uint32_t num_partition_maps = le32_to_cpu(vd->type.logical.num_partition_maps);
+				/* ECMA-167 3/10.6.12: If num_partition_maps is 0, then no LVID is specified */
+				if (num_partition_maps) {
+					lvid_len = le32_to_cpu(vd->type.logical.lvid_length);
+					lvid_loc = le32_to_cpu(vd->type.logical.lvid_location);
+				}
+			}
+			if (!udf_rev) {
+				/* UDF-2.60: 2.1.5.3: UDF revision field shall indicate revision of UDF document
+				 * We use this field as fallback value for ID_FS_VERSION when LVIDIU is missing */
+				if (strncmp(vd->type.logical.domain_id, "*OSTA UDF Compliant", sizeof(vd->type.logical.domain_id)) == 0)
+					udf_rev = le16_to_cpu(vd->type.logical.udf_rev);
+			}
+			if (!have_logvolid || !have_label) {
+				/* LogicalVolumeIdentifier in UDF 2.01 specification:
+				 * ===============================================================
+				 * 2. Basic Restrictions & Requirements
+				 *
+				 * Logical Volume Descriptor
+				 *
+				 * There shall be exactly one prevailing Logical Volume
+				 * Descriptor recorded per Volume Set.
+				 *
+				 * The LogicalVolumeIdentifier field shall not be null and
+				 * should contain an identifier that aids in the identification of
+				 * the logical volume. Specifically, software generating
+				 * volumes conforming to this specification shall not set this
+				 * field to a fixed or trivial value. Duplicate disks, which are
+				 * intended to be identical, may contain the same value in this
+				 * field. This field is extremely important in logical volume
+				 * identification when multiple media are present within a
+				 * jukebox. This name is typically what is displayed to the user.
+				 * ===============================================================
+				 *
+				 * Implementation in libblkid:
+				 * The LogicalVolumeIdentifier field is used for LABEL. MS Windows
+				 * read Volume Label also from LogicalVolumeIdentifier. Grub2 read
+				 * LABEL also from this field. Program newfs_udf (from UDFclient)
+				 * when formatting disk set this field from user option Disc Name.
+				 */
+				int enc = udf_cid_to_enc(vd->type.logical.logvol_id.cid);
+				uint8_t clen = vd->type.logical.logvol_id.clen;
+				if (clen > 0)
+					--clen;
+				if (clen > sizeof(vd->type.logical.logvol_id.c))
+					clen = sizeof(vd->type.logical.logvol_id.c);
+				if (enc != -1) {
+					if (!have_label)
+						have_label = !blkid_probe_set_utf8label(pr,
+								vd->type.logical.logvol_id.c, clen, enc);
+					if (!have_logvolid)
+						have_logvolid = !blkid_probe_set_utf8_id_label(pr, "LOGICAL_VOLUME_ID",
+								vd->type.logical.logvol_id.c, clen, enc);
+				}
+			}
+		}
+		if (have_volid && have_uuid && have_volsetid && have_logvolid && have_label && lvid_len && lvid_loc)
+			break;
+	}
+
+	/* Pick the first logical volume integrity descriptor and read UDF revision */
+	if (lvid_loc && lvid_len >= sizeof(*vd)) {
+		vd = (struct volume_descriptor *)
+			blkid_probe_get_buffer(pr,
+					(uint64_t) lvid_loc * bs,
+					sizeof(*vd));
+		if (!vd)
+			return errno ? -errno : 1;
+		type = le16_to_cpu(vd->tag.id);
+		if (type == TAG_ID_LVID &&
+		    le32_to_cpu(vd->tag.location) == lvid_loc &&
+		    UDF_LVIDIU_LENGTH(*vd) >= sizeof(*lvidiu)) {
+			/* ECMA-167 3/8.8.2: There is stored sequence of LVIDs and valid is just last
+			 * one. So correctly we should jump to next_lvid_location and read next LVID
+			 * until we find last one. This could be time consuming process and could
+			 * lead to scanning lot of disk blocks. Because we use LVID only for UDF
+			 * version, in the worst case we would report only wrong ID_FS_VERSION. */
+			uint16_t lvidiu_udf_rev;
+			lvidiu = (struct logical_vol_integ_descriptor_imp_use *)
+				blkid_probe_get_buffer(pr,
+						(uint64_t) lvid_loc * bs + UDF_LVIDIU_OFFSET(*vd),
+						sizeof(*lvidiu));
+			if (!lvidiu)
+				return errno ? -errno : 1;
+			/* Use Minimum UDF Read Revision as ID_FS_VERSION */
+			lvidiu_udf_rev = le16_to_cpu(lvidiu->min_udf_read_rev);
+			if (lvidiu_udf_rev)
+				udf_rev = lvidiu_udf_rev;
+			/* UDF-2.60: 2. Basic Restrictions & Requirements:
+			 * The Minimum UDF Read Revision value shall be at most #0250
+			 * for all media with a UDF 2.60 file system.
+			 * So in this case use Minimum UDF Write Revision as ID_FS_VERSION
+			 * to distinguish between UDF 2.50 and UDF 2.60 discs. */
+			if (lvidiu_udf_rev == 0x250) {
+				lvidiu_udf_rev = le16_to_cpu(lvidiu->min_udf_write_rev);
+				if (lvidiu_udf_rev > 0x250)
+					udf_rev = lvidiu_udf_rev;
+			}
+		}
+	}
+
+	if (udf_rev)
+		/* UDF revision is stored as decimal number in hexadecimal format.
+		 * E.g. number 0x0150 is revision 1.50, number 0x0201 is revision 2.01. */
+		blkid_probe_sprintf_version(pr, "%x.%02x", (unsigned int)(udf_rev >> 8), (unsigned int)(udf_rev & 0xFF));
+
+	return 0;
+}
+
+
+const struct blkid_idinfo udf_idinfo =
+{
+	.name		= "udf",
+	.usage		= BLKID_USAGE_FILESYSTEM,
+	.probefunc	= probe_udf,
+	.flags		= BLKID_IDINFO_TOLERANT,
+	.magics		=
+	{
+		{ .magic = "BEA01", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "BOOT2", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "CD001", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "CDW02", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "NSR02", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "NSR03", .len = 5, .kboff = 32, .sboff = 1 },
+		{ .magic = "TEA01", .len = 5, .kboff = 32, .sboff = 1 },
+		{ NULL }
+	}
+};