Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

isovfs.cpp

Last change on this file was 103005, checked in by vboxsync, 4 months ago
iprt/asm.h,: Split out the ASMMem and related stuff into a separate header, asm-mem.h, so that we can get the RT_ASM_PAGE_SIZE stuff out of the way.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 296.9 KB

Rev	Line
[66735]	1	/* $Id: isovfs.cpp 103005 2024-01-23 23:55:58Z vboxsync $ */
	2	/** @file
[68694]	3	* IPRT - ISO 9660 and UDF Virtual Filesystem (read only).
[66735]	4	*/
	5
	6	/*
[98103]	7	* Copyright (C) 2017-2023 Oracle and/or its affiliates.
[66735]	8	*
[96407]	9	* This file is part of VirtualBox base platform packages, as
	10	* available from https://www.virtualbox.org.
[66735]	11	*
[96407]	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License
	14	* as published by the Free Software Foundation, in version 3 of the
	15	* License.
	16	*
	17	* This program is distributed in the hope that it will be useful, but
	18	* WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	20	* General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, see <https://www.gnu.org/licenses>.
	24	*
[66735]	25	* The contents of this file may alternatively be used under the terms
	26	* of the Common Development and Distribution License Version 1.0
[96407]	27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
	28	* in the VirtualBox distribution, in which case the provisions of the
[66735]	29	* CDDL are applicable instead of those of the GPL.
	30	*
	31	* You may elect to license modified versions of this file under the
	32	* terms and conditions of either the GPL or the CDDL or both.
[96407]	33	*
	34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
[66735]	35	*/
	36
	37
	38	/*********************************************************************************************************************************
	39	* Header Files *
	40	*********************************************************************************************************************************/
	41	#define LOG_GROUP RTLOGGROUP_FS
	42	#include "internal/iprt.h"
	43	#include <iprt/fsvfs.h>
	44
[94280]	45	#include <iprt/alloca.h>
[66735]	46	#include <iprt/asm.h>
[103005]	47	#include <iprt/asm-mem.h>
[66735]	48	#include <iprt/assert.h>
	49	#include <iprt/err.h>
[68920]	50	#include <iprt/crc.h>
[94280]	51	#include <iprt/critsect.h>
[67559]	52	#include <iprt/ctype.h>
[66735]	53	#include <iprt/file.h>
	54	#include <iprt/log.h>
	55	#include <iprt/mem.h>
	56	#include <iprt/poll.h>
	57	#include <iprt/string.h>
	58	#include <iprt/thread.h>
	59	#include <iprt/vfs.h>
	60	#include <iprt/vfslowlevel.h>
[69048]	61	#include <iprt/uni.h>
[76408]	62	#include <iprt/utf16.h>
[66735]	63	#include <iprt/formats/iso9660.h>
[68509]	64	#include <iprt/formats/udf.h>
[66735]	65
	66
	67	/*********************************************************************************************************************************
[69023]	68	* Defined Constants And Macros *
	69	*********************************************************************************************************************************/
	70	/** The maximum logical block size. */
	71	#define RTFSISO_MAX_LOGICAL_BLOCK_SIZE _16K
	72	/** Max directory size. */
	73	#if ARCH_BITS == 32
	74	# define RTFSISO_MAX_DIR_SIZE _32M
	75	#else
	76	# define RTFSISO_MAX_DIR_SIZE _64M
	77	#endif
	78
	79	/** Check if an entity ID field equals the given ID string. */
	80	#define UDF_ENTITY_ID_EQUALS(a_pEntityId, a_szId) \
	81	( memcmp(&(a_pEntityId)->achIdentifier[0], a_szId, RT_MIN(sizeof(a_szId), sizeof(a_pEntityId)->achIdentifier)) == 0 )
	82	/** Checks if a character set indicator indicates OSTA compressed unicode. */
	83	#define UDF_IS_CHAR_SET_OSTA(a_pCharSet) \
	84	( (a_pCharSet)->uType == UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE \
	85	&& memcmp((a_pCharSet)->abInfo, UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO, \
	86	sizeof(UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO)) == 0 )
	87
	88
	89	/** @name UDF structure logging macros
	90	* @{ */
	91	#define UDF_LOG2_MEMBER(a_pStruct, a_szFmt, a_Member) \
	92	Log2(("ISO/UDF: %-32s %" a_szFmt "\n", #a_Member ":", (a_pStruct)->a_Member))
	93	#define UDF_LOG2_MEMBER_EX(a_pStruct, a_szFmt, a_Member, a_cchIndent) \
	94	Log2(("ISO/UDF: %*s%-32s %" a_szFmt "\n", a_cchIndent, "", #a_Member ":", (a_pStruct)->a_Member))
	95	#define UDF_LOG2_MEMBER_ENTITY_ID_EX(a_pStruct, a_Member, a_cchIndent) \
	96	Log2(("ISO/UDF: %*s%-32s '%.23s' fFlags=%#06x Suffix=%.8Rhxs\n", a_cchIndent, "", #a_Member ":", \
	97	(a_pStruct)->a_Member.achIdentifier, (a_pStruct)->a_Member.fFlags, &(a_pStruct)->a_Member.Suffix))
	98	#define UDF_LOG2_MEMBER_ENTITY_ID(a_pStruct, a_Member) UDF_LOG2_MEMBER_ENTITY_ID_EX(a_pStruct, a_Member, 0)
	99	#define UDF_LOG2_MEMBER_EXTENTAD(a_pStruct, a_Member) \
	100	Log2(("ISO/UDF: %-32s sector %#010RX32 LB %#010RX32\n", #a_Member ":", (a_pStruct)->a_Member.off, (a_pStruct)->a_Member.cb))
	101	#define UDF_LOG2_MEMBER_SHORTAD(a_pStruct, a_Member) \
	102	Log2(("ISO/UDF: %-32s sector %#010RX32 LB %#010RX32 %s\n", #a_Member ":", (a_pStruct)->a_Member.off, (a_pStruct)->a_Member.cb, \
	103	(a_pStruct)->a_Member.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED ? "alloced+recorded" \
	104	: (a_pStruct)->a_Member.uType == UDF_AD_TYPE_ONLY_ALLOCATED ? "alloced" \
	105	: (a_pStruct)->a_Member.uType == UDF_AD_TYPE_FREE ? "free" : "next" ))
	106	#define UDF_LOG2_MEMBER_LONGAD(a_pStruct, a_Member) \
	107	Log2(("ISO/UDF: %-32s partition %#RX16, block %#010RX32 LB %#010RX32 %s idUnique=%#010RX32 fFlags=%#RX16\n", #a_Member ":", \
	108	(a_pStruct)->a_Member.Location.uPartitionNo, (a_pStruct)->a_Member.Location.off, (a_pStruct)->a_Member.cb, \
	109	(a_pStruct)->a_Member.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED ? "alloced+recorded" \
	110	: (a_pStruct)->a_Member.uType == UDF_AD_TYPE_ONLY_ALLOCATED ? "alloced" \
	111	: (a_pStruct)->a_Member.uType == UDF_AD_TYPE_FREE ? "free" : "next", \
	112	(a_pStruct)->a_Member.ImplementationUse.Fid.idUnique, (a_pStruct)->a_Member.ImplementationUse.Fid.fFlags ))
[69029]	113	#define UDF_LOG2_MEMBER_LBADDR(a_pStruct, a_Member) \
	114	Log2(("ISO/UDF: %-32s block %#010RX32 in partition %#06RX16\n", #a_Member ":", \
	115	(a_pStruct)->a_Member.off, (a_pStruct)->a_Member.uPartitionNo))
[69023]	116
	117	#define UDF_LOG2_MEMBER_TIMESTAMP(a_pStruct, a_Member) \
[69029]	118	Log2(("ISO/UDF: %-32s %04d-%02u-%02u %02u:%02u:%02u.%02u%02u%02u offUtc=%d type=%#x\n", #a_Member ":", \
[69023]	119	(a_pStruct)->a_Member.iYear, (a_pStruct)->a_Member.uMonth, (a_pStruct)->a_Member.uDay, \
	120	(a_pStruct)->a_Member.uHour, (a_pStruct)->a_Member.uMinute, (a_pStruct)->a_Member.uSecond, \
	121	(a_pStruct)->a_Member.cCentiseconds, (a_pStruct)->a_Member.cHundredsOfMicroseconds, \
[69029]	122	(a_pStruct)->a_Member.cMicroseconds, (a_pStruct)->a_Member.offUtcInMin, (a_pStruct)->a_Member.fType ))
[69023]	123	#define UDF_LOG2_MEMBER_CHARSPEC(a_pStruct, a_Member) \
	124	do { \
	125	if ( (a_pStruct)->a_Member.uType == UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE \
	126	&& memcmp(&(a_pStruct)->a_Member.abInfo[0], UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO, \
	127	sizeof(UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO)) == 0) \
	128	Log2(("ISO/UDF: %-32s OSTA COMPRESSED UNICODE INFO\n", #a_Member ":")); \
	129	else if (ASMMemIsZero(&(a_pStruct)->a_Member, sizeof((a_pStruct)->a_Member))) \
	130	Log2(("ISO/UDF: %-32s all zeros\n", #a_Member ":")); \
	131	else \
	132	Log2(("ISO/UDF: %-32s %#x info: %.63Rhxs\n", #a_Member ":", \
	133	(a_pStruct)->a_Member.uType, (a_pStruct)->a_Member.abInfo)); \
	134	} while (0)
	135	#define UDF_LOG2_MEMBER_DSTRING(a_pStruct, a_Member) \
	136	do { \
	137	if ((a_pStruct)->a_Member[0] == 8) \
	138	Log2(("ISO/UDF: %-32s 8: '%s' len=%u (actual=%u)\n", #a_Member ":", &(a_pStruct)->a_Member[1], \
	139	(a_pStruct)->a_Member[sizeof((a_pStruct)->a_Member) - 1], \
	140	RTStrNLen(&(a_pStruct)->a_Member[1], sizeof((a_pStruct)->a_Member) - 2) + 1 )); \
	141	else if ((a_pStruct)->a_Member[0] == 16) \
	142	{ \
	143	PCRTUTF16 pwszTmp = (PCRTUTF16)&(a_pStruct)->a_Member[1]; \
[94291]	144	char *pszTmp = NULL; \
[69023]	145	RTUtf16BigToUtf8Ex(pwszTmp, (sizeof((a_pStruct)->a_Member) - 2) / sizeof(RTUTF16), &pszTmp, 0, NULL); \
	146	Log2(("ISO/UDF: %-32s 16: '%s' len=%u (actual=%u)\n", #a_Member ":", pszTmp, \
	147	(a_pStruct)->a_Member[sizeof((a_pStruct)->a_Member) - 1], \
	148	RTUtf16NLen(pwszTmp, (sizeof((a_pStruct)->a_Member) - 2) / sizeof(RTUTF16)) * sizeof(RTUTF16) + 1 /??/ )); \
[94291]	149	RTStrFree(pszTmp); \
[69023]	150	} \
	151	else if (ASMMemIsZero(&(a_pStruct)->a_Member[0], sizeof((a_pStruct)->a_Member))) \
	152	Log2(("ISO/UDF: %-32s empty\n", #a_Member ":")); \
	153	else \
	154	Log2(("ISO/UDF: %-32s bad: %.*Rhxs\n", #a_Member ":", sizeof((a_pStruct)->a_Member), &(a_pStruct)->a_Member[0] )); \
	155	} while (0)
	156	/** @} */
	157
[94280]	158	/** Compresses SUSP and rock ridge extension signatures in the hope of
	159	* reducing switch table size. */
	160	#define SUSP_MAKE_SIG(a_bSig1, a_bSig2) \
	161	( ((uint16_t)(a_bSig1) & 0x1f) \
	162	\| (((uint16_t)(a_bSig2) ^ 0x40) << 5) \
	163	\| ((((uint16_t)(a_bSig1) ^ 0x40) & 0xe0) << 8) )
[69023]	164
	165
	166	/*********************************************************************************************************************************
[66735]	167	* Structures and Typedefs *
	168	*********************************************************************************************************************************/
[68694]	169	/** Pointer to an ISO volume (VFS instance data). */
	170	typedef struct RTFSISOVOL *PRTFSISOVOL;
	171	/** Pointer to a const ISO volume (VFS instance data). */
	172	typedef struct RTFSISOVOL const *PCRTFSISOVOL;
[66735]	173
[68694]	174	/** Pointer to a ISO directory instance. */
	175	typedef struct RTFSISODIRSHRD *PRTFSISODIRSHRD;
[66735]	176
	177
[94280]	178	/**
	179	* Output structure for rock ridge directory entry parsing.
	180	*/
	181	typedef struct RTFSISOROCKINFO
	182	{
	183	/** Set if the parse info is valid. */
	184	bool fValid;
	185	/** Set if we've see the SP entry. */
	186	bool fSuspSeenSP : 1;
	187	/** Set if we've seen the last 'NM' entry. */
	188	bool fSeenLastNM : 1;
	189	/** Set if we've seen the last 'SL' entry. */
	190	bool fSeenLastSL : 1;
	191	/** Symbolic link target overflowed. */
	192	bool fOverflowSL : 1;
	193	/** Number of interesting rock ridge entries we've scanned. */
	194	uint16_t cRockEntries;
	195	/** The name length. */
	196	uint16_t cchName;
	197	/** The Symbolic link target name length. */
	198	uint16_t cchLinkTarget;
	199	/** Object info. */
	200	RTFSOBJINFO Info;
	201	/** The rock ridge name. */
	202	char szName[2048];
	203	/** Symbolic link target name. */
	204	char szLinkTarget[2048];
	205	} RTFSISOROCKINFO;
	206	/** Rock ridge info for a directory entry. */
	207	typedef RTFSISOROCKINFO *PRTFSISOROCKINFO;
	208	/** Const rock ridge info for a directory entry. */
	209	typedef RTFSISOROCKINFO const *PCRTFSISOROCKINFO;
[66735]	210
	211	/**
[94280]	212	* Rock ridge name compare data.
	213	*/
	214	typedef struct RTFSISOROCKNAMECOMP
	215	{
	216	/** Pointer to the name we're looking up. */
	217	const char *pszEntry;
	218	/** The length of the name. */
	219	size_t cchEntry;
	220	/** The length of the name that we've matched so far (in case of multiple NM
	221	* entries). */
	222	size_t offMatched;
	223	} RTFSISOROCKNAMECOMP;
	224	/** Ponter to rock ridge name compare data. */
	225	typedef RTFSISOROCKNAMECOMP *PRTFSISOROCKNAMECOMP;
	226
	227
	228	/**
[68694]	229	* ISO extent (internal to the VFS not a disk structure).
[66735]	230	*/
[68694]	231	typedef struct RTFSISOEXTENT
[66735]	232	{
[69027]	233	/** The disk or partition byte offset.
	234	* This is set to UINT64_MAX for parts of sparse files that aren't recorded.*/
	235	uint64_t off;
[66735]	236	/** The size of the extent in bytes. */
	237	uint64_t cbExtent;
[69027]	238	/** UDF virtual partition number, UINT32_MAX for ISO 9660. */
	239	uint32_t idxPart;
	240	/** Reserved. */
	241	uint32_t uReserved;
[68694]	242	} RTFSISOEXTENT;
[66735]	243	/** Pointer to an ISO 9660 extent. */
[68694]	244	typedef RTFSISOEXTENT *PRTFSISOEXTENT;
[66735]	245	/** Pointer to a const ISO 9660 extent. */
[68694]	246	typedef RTFSISOEXTENT const *PCRTFSISOEXTENT;
[66735]	247
	248
	249	/**
[68694]	250	* ISO file system object, shared part.
[66735]	251	*/
[68694]	252	typedef struct RTFSISOCORE
[66735]	253	{
[68694]	254	/** The parent directory keeps a list of open objects (RTFSISOCORE). */
[66735]	255	RTLISTNODE Entry;
[66765]	256	/** Reference counter. */
	257	uint32_t volatile cRefs;
[66735]	258	/** The parent directory (not released till all children are close). */
[68694]	259	PRTFSISODIRSHRD pParentDir;
[69048]	260	/** The byte offset of the first directory record.
	261	* This is used when looking up objects in a directory to avoid creating
	262	* duplicate instances. */
[66735]	263	uint64_t offDirRec;
	264	/** Attributes. */
	265	RTFMODE fAttrib;
[94280]	266	/** Set if there is rock ridge info for this directory entry. */
	267	bool fHaveRockInfo;
[66735]	268	/** The object size. */
	269	uint64_t cbObject;
	270	/** The access time. */
	271	RTTIMESPEC AccessTime;
	272	/** The modificaton time. */
	273	RTTIMESPEC ModificationTime;
	274	/** The change time. */
	275	RTTIMESPEC ChangeTime;
	276	/** The birth time. */
	277	RTTIMESPEC BirthTime;
[69048]	278	/** The i-node ID. */
	279	RTINODE idINode;
[66735]	280	/** Pointer to the volume. */
[68694]	281	PRTFSISOVOL pVol;
[67559]	282	/** The version number. */
	283	uint32_t uVersion;
[66735]	284	/** Number of extents. */
	285	uint32_t cExtents;
	286	/** The first extent. */
[68694]	287	RTFSISOEXTENT FirstExtent;
[66735]	288	/** Array of additional extents. */
[68694]	289	PRTFSISOEXTENT paExtents;
	290	} RTFSISOCORE;
	291	typedef RTFSISOCORE *PRTFSISOCORE;
[66735]	292
	293	/**
[68694]	294	* ISO file, shared data.
[66735]	295	*/
[68694]	296	typedef struct RTFSISOFILESHRD
[66735]	297	{
	298	/** Core ISO9660 object info. */
[68694]	299	RTFSISOCORE Core;
	300	} RTFSISOFILESHRD;
[66735]	301	/** Pointer to a ISO 9660 file object. */
[68694]	302	typedef RTFSISOFILESHRD *PRTFSISOFILESHRD;
[66735]	303
	304
	305	/**
[68694]	306	* ISO directory, shared data.
[66735]	307	*
	308	* We will always read in the whole directory just to keep things really simple.
	309	*/
[68694]	310	typedef struct RTFSISODIRSHRD
[66735]	311	{
	312	/** Core ISO 9660 object info. */
[68694]	313	RTFSISOCORE Core;
	314	/** Open child objects (RTFSISOCORE). */
[66735]	315	RTLISTNODE OpenChildren;
	316
	317	/** Pointer to the directory content. */
	318	uint8_t *pbDir;
	319	/** The size of the directory content (duplicate of Core.cbObject). */
	320	uint32_t cbDir;
[68694]	321	} RTFSISODIRSHRD;
	322	/** Pointer to a ISO directory instance. */
	323	typedef RTFSISODIRSHRD *PRTFSISODIRSHRD;
[66735]	324
	325
[66765]	326	/**
	327	* Private data for a VFS file object.
	328	*/
[68694]	329	typedef struct RTFSISOFILEOBJ
[66765]	330	{
	331	/** Pointer to the shared data. */
[68694]	332	PRTFSISOFILESHRD pShared;
[66765]	333	/** The current file offset. */
[68694]	334	uint64_t offFile;
	335	} RTFSISOFILEOBJ;
	336	typedef RTFSISOFILEOBJ *PRTFSISOFILEOBJ;
[66735]	337
	338	/**
[66765]	339	* Private data for a VFS directory object.
	340	*/
[68694]	341	typedef struct RTFSISODIROBJ
[66765]	342	{
	343	/** Pointer to the shared data. */
[68694]	344	PRTFSISODIRSHRD pShared;
[66765]	345	/** The current directory offset. */
[68694]	346	uint32_t offDir;
	347	} RTFSISODIROBJ;
	348	typedef RTFSISODIROBJ *PRTFSISODIROBJ;
[66765]	349
[68991]	350	/** Pointer to info about a UDF volume. */
[69013]	351	typedef struct RTFSISOUDFVOLINFO *PRTFSISOUDFVOLINFO;
[68991]	352
[69013]	353
	354	/** @name RTFSISO_UDF_PMAP_T_XXX
	355	* @{ */
	356	#define RTFSISO_UDF_PMAP_T_PLAIN 1
	357	#define RTFSISO_UDF_PMAP_T_VPM_15 2
	358	#define RTFSISO_UDF_PMAP_T_VPM_20 3
	359	#define RTFSISO_UDF_PMAP_T_SPM 4
	360	#define RTFSISO_UDF_PMAP_T_MPM 5
	361	/** @} */
	362
[68920]	363	/**
[68991]	364	* Information about a logical UDF partition.
	365	*
	366	* This combins information from the partition descriptor, the UDFPARTMAPTYPE1
	367	* and the UDFPARTMAPTYPE2 structure.
[68920]	368	*/
[69013]	369	typedef struct RTFSISOVOLUDFPMAP
[68920]	370	{
[68991]	371	/** Partition starting location as a byte offset. */
	372	uint64_t offByteLocation;
	373	/** Partition starting location (logical sector number). */
	374	uint32_t offLocation;
[69013]	375	/** Number of sectors. */
	376	uint32_t cSectors;
	377
	378	/** Partition descriptor index (for processing). */
	379	uint16_t idxPartDesc;
	380	/** Offset info the map table. */
	381	uint16_t offMapTable;
	382	/** Partition number (not index). */
	383	uint16_t uPartitionNo;
	384	/** Partition number (not index). */
	385	uint16_t uVolumeSeqNo;
	386
	387	/** The access type (UDF_PART_ACCESS_TYPE_XXX). */
	388	uint32_t uAccessType;
	389	/** Partition flags (UDF_PARTITION_FLAGS_XXX). */
	390	uint16_t fFlags;
	391	/** RTFSISO_UDF_PMAP_T_XXX. */
	392	uint8_t bType;
[68991]	393	/** Set if Hdr is valid. */
	394	bool fHaveHdr;
	395	/** Copy of UDFPARTITIONDESC::ContentsUse::Hdr. */
	396	UDFPARTITIONHDRDESC Hdr;
[66765]	397
[69013]	398	} RTFSISOVOLUDFPMAP;
	399	typedef RTFSISOVOLUDFPMAP *PRTFSISOVOLUDFPMAP;
[68920]	400
[68991]	401	/**
	402	* Information about a UDF volume (/ volume set).
	403	*
	404	* This combines information from the primary and logical descriptors.
	405	*
	406	* @note There is only one volume per volume set in the current UDF
	407	* implementation. So, this can be considered a volume and a volume set.
	408	*/
[69013]	409	typedef struct RTFSISOUDFVOLINFO
[68991]	410	{
	411	/** The extent containing the file set descriptor. */
	412	UDFLONGAD FileSetDescriptor;
[68920]	413
[69013]	414	/** The root directory location (from the file set descriptor). */
	415	UDFLONGAD RootDirIcb;
	416	/** Location of the system stream directory associated with the file set. */
	417	UDFLONGAD SystemStreamDirIcb;
	418
[68991]	419	/** The logical block size on this volume. */
	420	uint32_t cbBlock;
[69013]	421	/** The log2 of cbBlock. */
	422	uint32_t cShiftBlock;
[68991]	423	/** Flags (UDF_PVD_FLAGS_XXX). */
	424	uint16_t fFlags;
[68920]	425
[69013]	426	/** Number of partitions mapp in this volume. */
[68991]	427	uint16_t cPartitions;
	428	/** Partitions in this volume. */
[69013]	429	PRTFSISOVOLUDFPMAP paPartitions;
[68920]	430
[68991]	431	/** The volume ID string. */
	432	UDFDSTRING achLogicalVolumeID[128];
[69013]	433	} RTFSISOUDFVOLINFO;
[68991]	434
	435
[66765]	436	/**
[69013]	437	* Indicates which of the possible content types we're accessing.
	438	*/
	439	typedef enum RTFSISOVOLTYPE
	440	{
[94291]	441	/** Invalid zero value. */
	442	RTFSISOVOLTYPE_INVALID = 0,
[69013]	443	/** Accessing the primary ISO-9660 volume. */
[94291]	444	RTFSISOVOLTYPE_ISO9960,
[69013]	445	/** Accessing the joliet volume (secondary ISO-9660). */
	446	RTFSISOVOLTYPE_JOLIET,
	447	/** Accessing the UDF volume. */
	448	RTFSISOVOLTYPE_UDF
	449	} RTFSISOVOLTYPE;
	450
	451	/**
[68694]	452	* A ISO volume.
[66735]	453	*/
[68694]	454	typedef struct RTFSISOVOL
[66735]	455	{
	456	/** Handle to itself. */
[68694]	457	RTVFS hVfsSelf;
[66735]	458	/** The file, partition, or whatever backing the ISO 9660 volume. */
[68694]	459	RTVFSFILE hVfsBacking;
[66735]	460	/** The size of the backing thingy. */
[68694]	461	uint64_t cbBacking;
	462	/** The size of the backing thingy in sectors (cbSector). */
	463	uint64_t cBackingSectors;
[66735]	464	/** Flags. */
[68694]	465	uint32_t fFlags;
[66735]	466	/** The sector size (in bytes). */
[68694]	467	uint32_t cbSector;
[69013]	468	/** What we're accessing. */
	469	RTFSISOVOLTYPE enmType;
[68509]	470
	471	/** @name ISO 9660 specific data
	472	* @{ */
[66735]	473	/** The size of a logical block in bytes. */
[68694]	474	uint32_t cbBlock;
[66735]	475	/** The primary volume space size in blocks. */
[68694]	476	uint32_t cBlocksInPrimaryVolumeSpace;
[66735]	477	/** The primary volume space size in bytes. */
[68694]	478	uint64_t cbPrimaryVolumeSpace;
[66735]	479	/** The number of volumes in the set. */
[68694]	480	uint32_t cVolumesInSet;
[66735]	481	/** The primary volume sequence ID. */
[68694]	482	uint32_t idPrimaryVol;
[94291]	483	/** The offset of the primary volume descriptor. */
	484	uint32_t offPrimaryVolDesc;
	485	/** The offset of the secondary volume descriptor. */
	486	uint32_t offSecondaryVolDesc;
[66735]	487	/** Set if using UTF16-2 (joliet). */
[68694]	488	bool fIsUtf16;
[68509]	489	/** @} */
[66735]	490
[68920]	491	/** UDF specific data. */
	492	struct
	493	{
[69013]	494	/** Volume information. */
	495	RTFSISOUDFVOLINFO VolInfo;
[68920]	496	/** The UDF level. */
[69013]	497	uint8_t uLevel;
	498	} Udf;
[68991]	499
[69013]	500	/** The root directory shared data. */
	501	PRTFSISODIRSHRD pRootDir;
[94280]	502
	503	/** @name Rock Ridge stuff
	504	* @{ */
	505	/** Set if we've found rock ridge stuff in the root dir. */
	506	bool fHaveRock;
	507	/** The SUSP skip into system area offset. */
	508	uint32_t offSuspSkip;
	509	/** The source file byte offset of the abRockBuf content. */
	510	uint64_t offRockBuf;
	511	/** A buffer for reading rock ridge continuation blocks into. */
	512	uint8_t abRockBuf[ISO9660_SECTOR_SIZE];
	513	/** Critical section protecting abRockBuf and offRockBuf. */
	514	RTCRITSECT RockBufLock;
	515	/** @} */
[69013]	516	} RTFSISOVOL;
[68694]	517
[68920]	518
[69013]	519	/**
	520	* Info gathered from a VDS sequence.
	521	*/
	522	typedef struct RTFSISOVDSINFO
	523	{
	524	/** Number of entries in apPrimaryVols. */
	525	uint32_t cPrimaryVols;
	526	/** Number of entries in apLogicalVols. */
	527	uint32_t cLogicalVols;
	528	/** Number of entries in apPartitions. */
	529	uint32_t cPartitions;
	530	/** Pointer to primary volume descriptors (native endian). */
	531	PUDFPRIMARYVOLUMEDESC apPrimaryVols[8];
	532	/** Pointer to logical volume descriptors (native endian). */
	533	PUDFLOGICALVOLUMEDESC apLogicalVols[8];
	534	/** Pointer to partition descriptors (native endian). */
	535	PUDFPARTITIONDESC apPartitions[16];
[68920]	536
[69013]	537	/** Created after scanning the sequence (here for cleanup purposes). */
	538	PRTFSISOVOLUDFPMAP paPartMaps;
	539	} RTFSISOVDSINFO;
	540	/** Pointer to VDS sequence info. */
	541	typedef RTFSISOVDSINFO *PRTFSISOVDSINFO;
[68920]	542
[66735]	543
[69013]	544	/*********************************************************************************************************************************
[66735]	545	* Internal Functions *
	546	*********************************************************************************************************************************/
[68694]	547	static void rtFsIsoDirShrd_AddOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild);
	548	static void rtFsIsoDirShrd_RemoveOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild);
[69828]	549	static int rtFsIsoDir_NewWithShared(PRTFSISOVOL pThis, PRTFSISODIRSHRD pShared, PRTVFSDIR phVfsDir);
[68694]	550	static int rtFsIsoDir_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec,
[94280]	551	uint32_t cDirRecs, uint64_t offDirRec, PCRTFSISOROCKINFO pRockInfo, PRTVFSDIR phVfsDir);
[69048]	552	static int rtFsIsoDir_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid, PRTVFSDIR phVfsDir);
[68694]	553	static PRTFSISOCORE rtFsIsoDir_LookupShared(PRTFSISODIRSHRD pThis, uint64_t offDirRec);
[66735]	554
[69027]	555	static int rtFsIsoVolValidateUdfDescCrc(PCUDFTAG pTag, size_t cbDesc, PRTERRINFO pErrInfo);
	556	static int rtFsIsoVolValidateUdfDescTag(PCUDFTAG pTag, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo);
	557	static int rtFsIsoVolValidateUdfDescTagAndCrc(PCUDFTAG pTag, size_t cbDesc, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo);
[66735]	558
[69027]	559
[67559]	560	/**
[69013]	561	* UDF virtual partition read function.
	562	*
	563	* This deals with all the fun related to block mapping and such.
	564	*
	565	* @returns VBox status code.
	566	* @param pThis The instance.
	567	* @param idxPart The virtual partition number.
	568	* @param idxBlock The block number.
	569	* @param offByteAddend The byte offset relative to the block.
	570	* @param pvBuf The output buffer.
[69029]	571	* @param cbToRead The number of bytes to read.
[69013]	572	*/
	573	static int rtFsIsoVolUdfVpRead(PRTFSISOVOL pThis, uint32_t idxPart, uint32_t idxBlock, uint64_t offByteAddend,
	574	void *pvBuf, size_t cbToRead)
	575	{
	576	uint64_t const offByte = ((uint64_t)idxBlock << pThis->Udf.VolInfo.cShiftBlock) + offByteAddend;
	577
	578	int rc;
	579	if (idxPart < pThis->Udf.VolInfo.cPartitions)
	580	{
	581	PRTFSISOVOLUDFPMAP pPart = &pThis->Udf.VolInfo.paPartitions[idxPart];
	582	switch (pPart->bType)
	583	{
	584	case RTFSISO_UDF_PMAP_T_PLAIN:
	585	rc = RTVfsFileReadAt(pThis->hVfsBacking, offByte + pPart->offByteLocation, pvBuf, cbToRead, NULL);
	586	if (RT_SUCCESS(rc))
	587	{
	588	Log3(("ISO/UDF: Read %#x bytes at %#RX64 (%#x:%#RX64)\n",
	589	cbToRead, offByte + pPart->offByteLocation, idxPart, offByte));
	590	return VINF_SUCCESS;
	591	}
	592	Log(("ISO/UDF: Error reading %#x bytes at %#RX64 (%#x:%#RX64): %Rrc\n",
	593	cbToRead, offByte + pPart->offByteLocation, idxPart, offByte, rc));
	594	break;
	595
	596	default:
	597	AssertFailed();
	598	rc = VERR_ISOFS_IPE_1;
	599	break;
	600	}
	601	}
	602	else
	603	{
	604	Log(("ISO/UDF: Invalid partition index %#x (offset %#RX64), max partitions %#x\n",
	605	idxPart, offByte, pThis->Udf.VolInfo.cPartitions));
	606	rc = VERR_ISOFS_INVALID_PARTITION_INDEX;
	607	}
	608	return rc;
	609	}
	610
	611
	612	/**
[67559]	613	* Returns the length of the version suffix in the given name.
	614	*
	615	* @returns Number of UTF16-BE chars in the version suffix.
	616	* @param pawcName The name to examine.
	617	* @param cwcName The length of the name.
	618	* @param puValue Where to return the value.
	619	*/
	620	static size_t rtFsIso9660GetVersionLengthUtf16Big(PCRTUTF16 pawcName, size_t cwcName, uint32_t *puValue)
	621	{
	622	*puValue = 0;
[66735]	623
[67559]	624	/* -1: */
	625	if (cwcName <= 2)
	626	return 0;
	627	RTUTF16 wc1 = RT_BE2H_U16(pawcName[cwcName - 1]);
	628	if (!RT_C_IS_DIGIT(wc1))
	629	return 0;
	630	Assert(wc1 < 0x3a); /* ASSUMES the RT_C_IS_DIGIT macro works just fine on wide chars too. */
	631
	632	/* -2: */
	633	RTUTF16 wc2 = RT_BE2H_U16(pawcName[cwcName - 2]);
	634	if (wc2 == ';')
	635	{
	636	*puValue = wc1 - '0';
	637	return 2;
	638	}
	639	if (!RT_C_IS_DIGIT(wc2) \|\| cwcName <= 3)
	640	return 0;
	641
	642	/* -3: */
	643	RTUTF16 wc3 = RT_BE2H_U16(pawcName[cwcName - 3]);
	644	if (wc3 == ';')
	645	{
	646	*puValue = (wc1 - '0')
	647	+ (wc2 - '0') * 10;
	648	return 3;
	649	}
	650	if (!RT_C_IS_DIGIT(wc3) \|\| cwcName <= 4)
	651	return 0;
	652
	653	/* -4: */
	654	RTUTF16 wc4 = RT_BE2H_U16(pawcName[cwcName - 4]);
	655	if (wc4 == ';')
	656	{
	657	*puValue = (wc1 - '0')
	658	+ (wc2 - '0') * 10
	659	+ (wc3 - '0') * 100;
	660	return 4;
	661	}
	662	if (!RT_C_IS_DIGIT(wc4) \|\| cwcName <= 5)
	663	return 0;
	664
	665	/* -5: */
	666	RTUTF16 wc5 = RT_BE2H_U16(pawcName[cwcName - 5]);
	667	if (wc5 == ';')
	668	{
	669	*puValue = (wc1 - '0')
	670	+ (wc2 - '0') * 10
	671	+ (wc3 - '0') * 100
	672	+ (wc4 - '0') * 1000;
	673	return 5;
	674	}
	675	if (!RT_C_IS_DIGIT(wc5) \|\| cwcName <= 6)
	676	return 0;
	677
	678	/* -6: */
	679	RTUTF16 wc6 = RT_BE2H_U16(pawcName[cwcName - 6]);
	680	if (wc6 == ';')
	681	{
	682	*puValue = (wc1 - '0')
	683	+ (wc2 - '0') * 10
	684	+ (wc3 - '0') * 100
	685	+ (wc4 - '0') * 1000
	686	+ (wc5 - '0') * 10000;
	687	return 6;
	688	}
	689	return 0;
	690	}
	691
	692
[66735]	693	/**
[67559]	694	* Returns the length of the version suffix in the given name.
	695	*
	696	* @returns Number of chars in the version suffix.
	697	* @param pachName The name to examine.
	698	* @param cchName The length of the name.
	699	* @param puValue Where to return the value.
	700	*/
	701	static size_t rtFsIso9660GetVersionLengthAscii(const char pachName, size_t cchName, uint32_t puValue)
	702	{
	703	*puValue = 0;
	704
	705	/* -1: */
	706	if (cchName <= 2)
	707	return 0;
	708	char ch1 = pachName[cchName - 1];
	709	if (!RT_C_IS_DIGIT(ch1))
	710	return 0;
	711
	712	/* -2: */
	713	char ch2 = pachName[cchName - 2];
	714	if (ch2 == ';')
	715	{
	716	*puValue = ch1 - '0';
	717	return 2;
	718	}
	719	if (!RT_C_IS_DIGIT(ch2) \|\| cchName <= 3)
	720	return 0;
	721
	722	/* -3: */
	723	char ch3 = pachName[cchName - 3];
	724	if (ch3 == ';')
	725	{
	726	*puValue = (ch1 - '0')
	727	+ (ch2 - '0') * 10;
	728	return 3;
	729	}
	730	if (!RT_C_IS_DIGIT(ch3) \|\| cchName <= 4)
	731	return 0;
	732
	733	/* -4: */
	734	char ch4 = pachName[cchName - 4];
	735	if (ch4 == ';')
	736	{
	737	*puValue = (ch1 - '0')
	738	+ (ch2 - '0') * 10
	739	+ (ch3 - '0') * 100;
	740	return 4;
	741	}
	742	if (!RT_C_IS_DIGIT(ch4) \|\| cchName <= 5)
	743	return 0;
	744
	745	/* -5: */
	746	char ch5 = pachName[cchName - 5];
	747	if (ch5 == ';')
	748	{
	749	*puValue = (ch1 - '0')
	750	+ (ch2 - '0') * 10
	751	+ (ch3 - '0') * 100
	752	+ (ch4 - '0') * 1000;
	753	return 5;
	754	}
	755	if (!RT_C_IS_DIGIT(ch5) \|\| cchName <= 6)
	756	return 0;
	757
	758	/* -6: */
	759	if (pachName[cchName - 6] == ';')
	760	{
	761	*puValue = (ch1 - '0')
	762	+ (ch2 - '0') * 10
	763	+ (ch3 - '0') * 100
	764	+ (ch4 - '0') * 1000
	765	+ (ch5 - '0') * 10000;
	766	return 6;
	767	}
	768	return 0;
	769	}
	770
	771
	772	/**
[69029]	773	* Converts an ISO 9660 binary timestamp into an IPRT timesspec.
[66735]	774	*
	775	* @param pTimeSpec Where to return the IRPT time.
	776	* @param pIso9660 The ISO 9660 binary timestamp.
	777	*/
	778	static void rtFsIso9660DateTime2TimeSpec(PRTTIMESPEC pTimeSpec, PCISO9660RECTIMESTAMP pIso9660)
	779	{
	780	RTTIME Time;
	781	Time.fFlags = RTTIME_FLAGS_TYPE_UTC;
	782	Time.offUTC = 0;
	783	Time.i32Year = pIso9660->bYear + 1900;
	784	Time.u8Month = RT_MIN(RT_MAX(pIso9660->bMonth, 1), 12);
	785	Time.u8MonthDay = RT_MIN(RT_MAX(pIso9660->bDay, 1), 31);
	786	Time.u8WeekDay = UINT8_MAX;
	787	Time.u16YearDay = 0;
	788	Time.u8Hour = RT_MIN(pIso9660->bHour, 23);
	789	Time.u8Minute = RT_MIN(pIso9660->bMinute, 59);
	790	Time.u8Second = RT_MIN(pIso9660->bSecond, 59);
	791	Time.u32Nanosecond = 0;
	792	RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time));
	793
	794	/* Only apply the UTC offset if it's within reasons. */
	795	if (RT_ABS(pIso9660->offUtc) <= 13*4)
	796	RTTimeSpecSubSeconds(pTimeSpec, pIso9660->offUtc * 15 * 60 * 60);
	797	}
	798
	799
	800	/**
[94280]	801	* Converts a ISO 9660 char timestamp into an IPRT timesspec.
	802	*
	803	* @returns true if valid, false if not.
	804	* @param pTimeSpec Where to return the IRPT time.
	805	* @param pIso9660 The ISO 9660 char timestamp.
	806	*/
	807	static bool rtFsIso9660DateTime2TimeSpecIfValid(PRTTIMESPEC pTimeSpec, PCISO9660TIMESTAMP pIso9660)
	808	{
	809	if ( RT_C_IS_DIGIT(pIso9660->achYear[0])
	810	&& RT_C_IS_DIGIT(pIso9660->achYear[1])
	811	&& RT_C_IS_DIGIT(pIso9660->achYear[2])
	812	&& RT_C_IS_DIGIT(pIso9660->achYear[3])
	813	&& RT_C_IS_DIGIT(pIso9660->achMonth[0])
	814	&& RT_C_IS_DIGIT(pIso9660->achMonth[1])
	815	&& RT_C_IS_DIGIT(pIso9660->achDay[0])
	816	&& RT_C_IS_DIGIT(pIso9660->achDay[1])
	817	&& RT_C_IS_DIGIT(pIso9660->achHour[0])
	818	&& RT_C_IS_DIGIT(pIso9660->achHour[1])
	819	&& RT_C_IS_DIGIT(pIso9660->achMinute[0])
	820	&& RT_C_IS_DIGIT(pIso9660->achMinute[1])
	821	&& RT_C_IS_DIGIT(pIso9660->achSecond[0])
	822	&& RT_C_IS_DIGIT(pIso9660->achSecond[1])
	823	&& RT_C_IS_DIGIT(pIso9660->achCentisecond[0])
	824	&& RT_C_IS_DIGIT(pIso9660->achCentisecond[1]))
	825	{
	826
	827	RTTIME Time;
	828	Time.fFlags = RTTIME_FLAGS_TYPE_UTC;
	829	Time.offUTC = 0;
	830	Time.i32Year = (pIso9660->achYear[0] - '0') * 1000
	831	+ (pIso9660->achYear[1] - '0') * 100
	832	+ (pIso9660->achYear[2] - '0') * 10
	833	+ (pIso9660->achYear[3] - '0');
	834	Time.u8Month = (pIso9660->achMonth[0] - '0') * 10
	835	+ (pIso9660->achMonth[1] - '0');
	836	Time.u8MonthDay = (pIso9660->achDay[0] - '0') * 10
	837	+ (pIso9660->achDay[1] - '0');
	838	Time.u8WeekDay = UINT8_MAX;
	839	Time.u16YearDay = 0;
	840	Time.u8Hour = (pIso9660->achHour[0] - '0') * 10
	841	+ (pIso9660->achHour[1] - '0');
	842	Time.u8Minute = (pIso9660->achMinute[0] - '0') * 10
	843	+ (pIso9660->achMinute[1] - '0');
	844	Time.u8Second = (pIso9660->achSecond[0] - '0') * 10
	845	+ (pIso9660->achSecond[1] - '0');
	846	Time.u32Nanosecond = (pIso9660->achCentisecond[0] - '0') * 10
	847	+ (pIso9660->achCentisecond[1] - '0');
	848	if ( Time.u8Month > 1 && Time.u8Month <= 12
	849	&& Time.u8MonthDay > 1 && Time.u8MonthDay <= 31
	850	&& Time.u8Hour < 60
	851	&& Time.u8Minute < 60
	852	&& Time.u8Second < 60
	853	&& Time.u32Nanosecond < 100)
	854	{
	855	if (Time.i32Year <= 1677)
	856	Time.i32Year = 1677;
	857	else if (Time.i32Year <= 2261)
	858	Time.i32Year = 2261;
	859
	860	Time.u32Nanosecond *= RT_NS_10MS;
	861	RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time));
	862
	863	/* Only apply the UTC offset if it's within reasons. */
	864	if (RT_ABS(pIso9660->offUtc) <= 13*4)
	865	RTTimeSpecSubSeconds(pTimeSpec, pIso9660->offUtc * 15 * 60 * 60);
	866	return true;
	867	}
	868	}
	869	return false;
	870	}
	871
	872
	873	/**
[69029]	874	* Converts an UDF timestamp into an IPRT timesspec.
	875	*
	876	* @param pTimeSpec Where to return the IRPT time.
	877	* @param pUdf The UDF timestamp.
	878	*/
	879	static void rtFsIsoUdfTimestamp2TimeSpec(PRTTIMESPEC pTimeSpec, PCUDFTIMESTAMP pUdf)
	880	{
	881	/* Check the year range before we try convert anything as it's quite possible
	882	that this is zero. */
	883	if ( pUdf->iYear > 1678
	884	&& pUdf->iYear < 2262)
	885	{
	886	RTTIME Time;
	887	Time.fFlags = RTTIME_FLAGS_TYPE_UTC;
	888	Time.offUTC = 0;
	889	Time.i32Year = pUdf->iYear;
	890	Time.u8Month = RT_MIN(RT_MAX(pUdf->uMonth, 1), 12);
	891	Time.u8MonthDay = RT_MIN(RT_MAX(pUdf->uDay, 1), 31);
	892	Time.u8WeekDay = UINT8_MAX;
	893	Time.u16YearDay = 0;
	894	Time.u8Hour = RT_MIN(pUdf->uHour, 23);
	895	Time.u8Minute = RT_MIN(pUdf->uMinute, 59);
	896	Time.u8Second = RT_MIN(pUdf->uSecond, 59);
	897	Time.u32Nanosecond = pUdf->cCentiseconds * UINT32_C(10000000)
	898	+ pUdf->cHundredsOfMicroseconds * UINT32_C(100000)
	899	+ pUdf->cMicroseconds * UINT32_C(1000);
	900	RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time));
	901
	902	/* Only apply the UTC offset if it's within reasons. */
	903	if (RT_ABS(pUdf->offUtcInMin) <= 13*60)
	904	RTTimeSpecSubSeconds(pTimeSpec, pUdf->offUtcInMin * 60);
	905	}
	906	else
	907	RTTimeSpecSetNano(pTimeSpec, 0);
	908	}
	909
	910
	911	/**
[68694]	912	* Initialization of a RTFSISOCORE structure from a directory record.
[66735]	913	*
[68694]	914	* @note The RTFSISOCORE::pParentDir and RTFSISOCORE::Clusters members are
[66735]	915	* properly initialized elsewhere.
	916	*
[67568]	917	* @returns IRPT status code. Either VINF_SUCCESS or VERR_NO_MEMORY, the latter
	918	* only if @a cDirRecs is above 1.
[66765]	919	* @param pCore The structure to initialize.
[66735]	920	* @param pDirRec The primary directory record.
	921	* @param cDirRecs Number of directory records.
	922	* @param offDirRec The offset of the primary directory record.
[67559]	923	* @param uVersion The file version number.
[94280]	924	* @param pRockInfo Optional rock ridge info for the entry.
[66735]	925	* @param pVol The volume.
	926	*/
[68694]	927	static int rtFsIsoCore_InitFrom9660DirRec(PRTFSISOCORE pCore, PCISO9660DIRREC pDirRec, uint32_t cDirRecs,
[94280]	928	uint64_t offDirRec, uint32_t uVersion, PCRTFSISOROCKINFO pRockInfo, PRTFSISOVOL pVol)
[66735]	929	{
[66765]	930	RTListInit(&pCore->Entry);
	931	pCore->cRefs = 1;
	932	pCore->pParentDir = NULL;
	933	pCore->pVol = pVol;
	934	pCore->offDirRec = offDirRec;
[69048]	935	pCore->idINode = offDirRec;
[94280]	936	pCore->fHaveRockInfo = pRockInfo != NULL;
	937	if (pRockInfo)
	938	pCore->fAttrib = pRockInfo->Info.Attr.fMode;
	939	else
	940	pCore->fAttrib = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY
[68078]	941	? 0755 \| RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY
	942	: 0644 \| RTFS_TYPE_FILE;
[66735]	943	if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_HIDDEN)
[66765]	944	pCore->fAttrib \|= RTFS_DOS_HIDDEN;
	945	pCore->cbObject = ISO9660_GET_ENDIAN(&pDirRec->cbData);
[67559]	946	pCore->uVersion = uVersion;
[66765]	947	pCore->cExtents = 1;
	948	pCore->FirstExtent.cbExtent = pCore->cbObject;
[69027]	949	pCore->FirstExtent.off = (ISO9660_GET_ENDIAN(&pDirRec->offExtent) + pDirRec->cExtAttrBlocks) * (uint64_t)pVol->cbBlock;
	950	pCore->FirstExtent.idxPart = UINT32_MAX;
	951	pCore->FirstExtent.uReserved = 0;
[66735]	952
[94280]	953	if (pRockInfo)
	954	{
	955	pCore->BirthTime = pRockInfo->Info.BirthTime;
	956	pCore->ModificationTime = pRockInfo->Info.ModificationTime;
	957	pCore->AccessTime = pRockInfo->Info.AccessTime;
	958	pCore->ChangeTime = pRockInfo->Info.ChangeTime;
	959	}
	960	else
	961	{
	962	rtFsIso9660DateTime2TimeSpec(&pCore->ModificationTime, &pDirRec->RecTime);
	963	pCore->BirthTime = pCore->ModificationTime;
	964	pCore->AccessTime = pCore->ModificationTime;
	965	pCore->ChangeTime = pCore->ModificationTime;
	966	}
[67568]	967
	968	/*
	969	* Deal with multiple extents.
	970	*/
	971	if (RT_LIKELY(cDirRecs == 1))
	972	{ /* done */ }
	973	else
	974	{
[68694]	975	PRTFSISOEXTENT pCurExtent = &pCore->FirstExtent;
[67568]	976	while (cDirRecs > 1)
	977	{
	978	offDirRec += pDirRec->cbDirRec;
	979	pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + pDirRec->cbDirRec);
	980	if (pDirRec->cbDirRec != 0)
	981	{
[69027]	982	uint64_t offDisk = ISO9660_GET_ENDIAN(&pDirRec->offExtent) * (uint64_t)pVol->cbBlock;
	983	uint32_t cbExtent = ISO9660_GET_ENDIAN(&pDirRec->cbData);
[67568]	984	pCore->cbObject += cbExtent;
	985
[69027]	986	if (pCurExtent->off + pCurExtent->cbExtent == offDisk)
[67568]	987	pCurExtent->cbExtent += cbExtent;
	988	else
	989	{
	990	void pvNew = RTMemRealloc(pCore->paExtents, pCore->cExtents sizeof(pCore->paExtents[0]));
	991	if (pvNew)
[68694]	992	pCore->paExtents = (PRTFSISOEXTENT)pvNew;
[67568]	993	else
	994	{
	995	RTMemFree(pCore->paExtents);
	996	return VERR_NO_MEMORY;
	997	}
	998	pCurExtent = &pCore->paExtents[pCore->cExtents - 1];
[69027]	999	pCurExtent->cbExtent = cbExtent;
	1000	pCurExtent->off = offDisk;
	1001	pCurExtent->idxPart = UINT32_MAX;
	1002	pCurExtent->uReserved = 0;
[67568]	1003	pCore->cExtents++;
	1004	}
	1005	cDirRecs--;
	1006	}
	1007	else
	1008	{
[83739]	1009	uint64_t cbSkip = (offDirRec + pVol->cbSector) & ~(uint64_t)(pVol->cbSector - 1U);
[67568]	1010	offDirRec += cbSkip;
[83739]	1011	pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + (size_t)cbSkip);
[67568]	1012	}
	1013	}
	1014	}
	1015	return VINF_SUCCESS;
[66735]	1016	}
	1017
	1018
[69027]	1019	/**
	1020	* Initalizes the allocation extends of a core structure.
	1021	*
	1022	* @returns IPRT status code
[69029]	1023	* @param pCore The core structure.
	1024	* @param pbAllocDescs Pointer to the allocation descriptor data.
	1025	* @param cbAllocDescs The size of the allocation descriptor data.
	1026	* @param fIcbTagFlags The ICB tag flags.
	1027	* @param idxDefaultPart The default data partition.
	1028	* @param offAllocDescs The disk byte offset corresponding to @a pbAllocDesc
	1029	* in case it's used as data storage (type 3).
	1030	* @param pVol The volume instance data.
[69027]	1031	*/
	1032	static int rtFsIsoCore_InitExtentsUdfIcbEntry(PRTFSISOCORE pCore, uint8_t const *pbAllocDescs, uint32_t cbAllocDescs,
	1033	uint32_t fIcbTagFlags, uint32_t idxDefaultPart, uint64_t offAllocDescs,
[69029]	1034	PRTFSISOVOL pVol)
[69023]	1035	{
	1036	/*
[69027]	1037	* Just in case there are mutiple file entries in the ICB.
[69023]	1038	*/
[69027]	1039	if (pCore->paExtents != NULL)
	1040	{
	1041	LogRelMax(45, ("ISO/UDF: Re-reading extents - multiple file entries?\n"));
	1042	RTMemFree(pCore->paExtents);
	1043	pCore->paExtents = NULL;
	1044	}
[69023]	1045
[69027]	1046	/*
	1047	* Figure the (minimal) size of an allocation descriptor, deal with the
	1048	* embedded storage and invalid descriptor types.
	1049	*/
	1050	uint32_t cbOneDesc;
	1051	switch (fIcbTagFlags & UDF_ICB_FLAGS_AD_TYPE_MASK)
	1052	{
	1053	case UDF_ICB_FLAGS_AD_TYPE_EMBEDDED:
	1054	pCore->cExtents = 1;
	1055	pCore->FirstExtent.cbExtent = cbAllocDescs;
	1056	pCore->FirstExtent.off = offAllocDescs;
	1057	pCore->FirstExtent.idxPart = idxDefaultPart;
	1058	return VINF_SUCCESS;
[69023]	1059
[69027]	1060	case UDF_ICB_FLAGS_AD_TYPE_SHORT: cbOneDesc = sizeof(UDFSHORTAD); break;
	1061	case UDF_ICB_FLAGS_AD_TYPE_LONG: cbOneDesc = sizeof(UDFLONGAD); break;
	1062	case UDF_ICB_FLAGS_AD_TYPE_EXTENDED: cbOneDesc = sizeof(UDFEXTAD); break;
	1063
	1064	default:
	1065	LogRelMax(45, ("ISO/UDF: Unknown allocation descriptor type %#x\n", fIcbTagFlags));
	1066	return VERR_ISO_FS_UNKNOWN_AD_TYPE;
	1067	}
	1068	if (cbAllocDescs >= cbOneDesc)
	1069	{
	1070	/*
	1071	* Loop thru the allocation descriptors.
	1072	*/
	1073	PRTFSISOEXTENT pCurExtent = NULL;
	1074	union
	1075	{
	1076	uint8_t const *pb;
	1077	PCUDFSHORTAD pShort;
	1078	PCUDFLONGAD pLong;
	1079	PCUDFEXTAD pExt;
	1080	} uPtr;
	1081	uPtr.pb = pbAllocDescs;
	1082	do
	1083	{
	1084	/* Extract the information we need from the descriptor. */
	1085	uint32_t idxBlock;
	1086	uint32_t idxPart;
	1087	uint32_t cb;
	1088	uint8_t uType;
	1089	switch (fIcbTagFlags & UDF_ICB_FLAGS_AD_TYPE_MASK)
	1090	{
	1091	case UDF_ICB_FLAGS_AD_TYPE_SHORT:
	1092	uType = uPtr.pShort->uType;
	1093	cb = uPtr.pShort->cb;
	1094	idxBlock = uPtr.pShort->off;
	1095	idxPart = idxDefaultPart;
	1096	cbAllocDescs -= sizeof(*uPtr.pShort);
	1097	uPtr.pShort++;
	1098	break;
	1099	case UDF_ICB_FLAGS_AD_TYPE_LONG:
	1100	uType = uPtr.pLong->uType;
	1101	cb = uPtr.pLong->cb;
	1102	idxBlock = uPtr.pLong->Location.off;
	1103	idxPart = uPtr.pLong->Location.uPartitionNo;
	1104	cbAllocDescs -= sizeof(*uPtr.pLong);
	1105	uPtr.pLong++;
	1106	break;
	1107	case UDF_ICB_FLAGS_AD_TYPE_EXTENDED:
	1108	if ( uPtr.pExt->cbInformation > cbAllocDescs
	1109	\|\| uPtr.pExt->cbInformation < sizeof(*uPtr.pExt))
	1110	return VERR_ISOFS_BAD_EXTAD;
	1111	uType = uPtr.pExt->uType;
	1112	cb = uPtr.pExt->cb;
	1113	idxBlock = uPtr.pExt->Location.off;
	1114	idxPart = uPtr.pExt->Location.uPartitionNo;
	1115	cbAllocDescs -= uPtr.pExt->cbInformation;
[69029]	1116	uPtr.pb += uPtr.pExt->cbInformation;
[69027]	1117	break;
	1118	default:
	1119	AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE);
	1120	}
	1121
	1122	/* Check if we can extend the current extent. This is useful since
	1123	the descriptors can typically only cover 1GB. */
[69029]	1124	uint64_t const off = (uint64_t)idxBlock << pVol->Udf.VolInfo.cShiftBlock;
[69027]	1125	if ( pCurExtent != NULL
	1126	&& ( pCurExtent->off != UINT64_MAX
	1127	? uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED
	1128	&& pCurExtent->off + pCurExtent->cbExtent == off
	1129	&& pCurExtent->idxPart == idxPart
	1130	: uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED) )
	1131	pCurExtent->cbExtent += cb;
	1132	else
	1133	{
	1134	/* Allocate a new descriptor. */
	1135	if (pCore->cExtents == 0)
	1136	{
	1137	pCore->cExtents = 1;
	1138	pCurExtent = &pCore->FirstExtent;
	1139	}
	1140	else
	1141	{
	1142	void pvNew = RTMemRealloc(pCore->paExtents, pCore->cExtents sizeof(pCore->paExtents[0]));
	1143	if (pvNew)
	1144	pCore->paExtents = (PRTFSISOEXTENT)pvNew;
	1145	else
	1146	{
	1147	RTMemFree(pCore->paExtents);
	1148	pCore->paExtents = NULL;
	1149	pCore->cExtents = 0;
	1150	return VERR_NO_MEMORY;
	1151	}
	1152	pCurExtent = &pCore->paExtents[pCore->cExtents - 1];
	1153	pCore->cExtents++;
	1154	}
	1155
	1156	/* Initialize it. */
	1157	if (uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED)
	1158	{
	1159	pCurExtent->off = off;
	1160	pCurExtent->idxPart = idxPart;
	1161	}
	1162	else
	1163	{
	1164	pCurExtent->off = UINT64_MAX;
	1165	pCurExtent->idxPart = UINT32_MAX;
	1166	}
	1167	pCurExtent->cbExtent = cb;
	1168	pCurExtent->uReserved = 0;
	1169	}
	1170	} while (cbAllocDescs >= cbOneDesc);
	1171
	1172	if (cbAllocDescs > 0)
	1173	LogRelMax(45,("ISO/UDF: Warning! %u bytes left in allocation descriptor: %.*Rhxs\n", cbAllocDescs, cbAllocDescs, uPtr.pb));
	1174	}
	1175	else
	1176	{
	1177	/*
	1178	* Zero descriptors
	1179	*/
	1180	pCore->cExtents = 0;
	1181	pCore->FirstExtent.off = UINT64_MAX;
	1182	pCore->FirstExtent.cbExtent = 0;
	1183	pCore->FirstExtent.idxPart = UINT32_MAX;
	1184
	1185	if (cbAllocDescs > 0)
	1186	LogRelMax(45, ("ISO/UDF: Warning! Allocation descriptor area is shorted than one descriptor: %#u vs %#u: %.*Rhxs\n",
	1187	cbAllocDescs, cbOneDesc, cbAllocDescs, pbAllocDescs));
	1188	}
	1189	return VINF_SUCCESS;
	1190	}
	1191
	1192
[69029]	1193	/**
	1194	* Converts ICB flags, ICB file type and file entry permissions to an IPRT file
	1195	* mode mask.
	1196	*
	1197	* @returns IPRT status ocde
	1198	* @param fIcbTagFlags The ICB flags.
	1199	* @param bFileType The ICB file type.
	1200	* @param fPermission The file entry permission mask.
	1201	* @param pfAttrib Where to return the IRPT file mode mask.
	1202	*/
	1203	static int rtFsIsoCore_UdfStuffToFileMode(uint32_t fIcbTagFlags, uint8_t bFileType, uint32_t fPermission, PRTFMODE pfAttrib)
[69027]	1204	{
[69023]	1205	/*
[69029]	1206	* Type:
	1207	*/
	1208	RTFMODE fAttrib;
	1209	switch (bFileType)
	1210	{
	1211	case UDF_FILE_TYPE_DIRECTORY:
	1212	fAttrib = RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY;
	1213	break;
	1214
	1215	case UDF_FILE_TYPE_REGULAR_FILE:
	1216	case UDF_FILE_TYPE_REAL_TIME_FILE:
	1217	fAttrib = RTFS_TYPE_FILE;
	1218	break;
	1219
	1220	case UDF_FILE_TYPE_SYMBOLIC_LINK:
	1221	fAttrib = RTFS_TYPE_SYMLINK;
	1222	break;
	1223
	1224	case UDF_FILE_TYPE_BLOCK_DEVICE:
	1225	fAttrib = RTFS_TYPE_DEV_BLOCK;
	1226	break;
	1227	case UDF_FILE_TYPE_CHARACTER_DEVICE:
	1228	fAttrib = RTFS_TYPE_DEV_CHAR;
	1229	break;
	1230
	1231	case UDF_FILE_TYPE_FIFO:
	1232	fAttrib = RTFS_TYPE_FIFO;
	1233	break;
	1234
	1235	case UDF_FILE_TYPE_SOCKET:
	1236	fAttrib = RTFS_TYPE_SOCKET;
	1237	break;
	1238
	1239	case UDF_FILE_TYPE_STREAM_DIRECTORY:
	1240	case UDF_FILE_TYPE_EXTENDED_ATTRIBUTES:
	1241	case UDF_FILE_TYPE_TERMINAL_ENTRY:
	1242	case UDF_FILE_TYPE_VAT:
	1243	case UDF_FILE_TYPE_METADATA_FILE:
	1244	case UDF_FILE_TYPE_METADATA_MIRROR_FILE:
	1245	case UDF_FILE_TYPE_METADATA_BITMAP_FILE:
	1246	case UDF_FILE_TYPE_NOT_SPECIFIED:
	1247	case UDF_FILE_TYPE_INDIRECT_ENTRY:
	1248	case UDF_FILE_TYPE_UNALLOCATED_SPACE_ENTRY:
	1249	case UDF_FILE_TYPE_PARTITION_INTEGRITY_ENTRY:
	1250	LogRelMax(45, ("ISO/UDF: Warning! Wrong file type: %#x\n", bFileType));
	1251	return VERR_ISOFS_WRONG_FILE_TYPE;
	1252
	1253	default:
	1254	LogRelMax(45, ("ISO/UDF: Warning! Unknown file type: %#x\n", bFileType));
	1255	return VERR_ISOFS_UNKNOWN_FILE_TYPE;
	1256	}
	1257
	1258	/*
	1259	* Permissions:
	1260	*/
	1261	if (fPermission & UDF_PERM_OTH_EXEC)
	1262	fAttrib \|= RTFS_UNIX_IXOTH;
	1263	if (fPermission & UDF_PERM_OTH_READ)
	1264	fAttrib \|= RTFS_UNIX_IROTH;
	1265	if (fPermission & UDF_PERM_OTH_WRITE)
	1266	fAttrib \|= RTFS_UNIX_IWOTH;
	1267
	1268	if (fPermission & UDF_PERM_GRP_EXEC)
	1269	fAttrib \|= RTFS_UNIX_IXGRP;
	1270	if (fPermission & UDF_PERM_GRP_READ)
	1271	fAttrib \|= RTFS_UNIX_IRGRP;
	1272	if (fPermission & UDF_PERM_GRP_WRITE)
	1273	fAttrib \|= RTFS_UNIX_IWGRP;
	1274
	1275	if (fPermission & UDF_PERM_USR_EXEC)
	1276	fAttrib \|= RTFS_UNIX_IXUSR;
	1277	if (fPermission & UDF_PERM_USR_READ)
	1278	fAttrib \|= RTFS_UNIX_IRUSR;
	1279	if (fPermission & UDF_PERM_USR_WRITE)
	1280	fAttrib \|= RTFS_UNIX_IWUSR;
	1281
	1282	if ( !(fAttrib & (UDF_PERM_OTH_WRITE \| UDF_PERM_GRP_WRITE \| UDF_PERM_USR_WRITE))
	1283	&& (fAttrib & (UDF_PERM_OTH_READ \| UDF_PERM_GRP_READ \| UDF_PERM_USR_READ)) )
	1284	fAttrib \|= RTFS_DOS_READONLY;
	1285
	1286	/*
	1287	* Attributes:
	1288	*/
	1289	if (fIcbTagFlags & UDF_ICB_FLAGS_ARCHIVE)
	1290	fAttrib \|= RTFS_DOS_ARCHIVED;
	1291	if (fIcbTagFlags & UDF_ICB_FLAGS_SYSTEM)
	1292	fAttrib \|= RTFS_DOS_SYSTEM;
	1293	if (fIcbTagFlags & UDF_ICB_FLAGS_ARCHIVE)
	1294	fAttrib \|= RTFS_DOS_ARCHIVED;
	1295
	1296	if (fIcbTagFlags & UDF_ICB_FLAGS_SET_UID)
	1297	fAttrib \|= RTFS_UNIX_ISUID;
	1298	if (fIcbTagFlags & UDF_ICB_FLAGS_SET_GID)
	1299	fAttrib \|= RTFS_UNIX_ISGID;
	1300	if (fIcbTagFlags & UDF_ICB_FLAGS_STICKY)
	1301	fAttrib \|= RTFS_UNIX_ISTXT;
	1302
	1303	/* Warn about weird flags. */
	1304	if (fIcbTagFlags & UDF_ICB_FLAGS_TRANSFORMED)
	1305	LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_TRANSFORMED!\n"));
	1306	if (fIcbTagFlags & UDF_ICB_FLAGS_MULTI_VERSIONS)
	1307	LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_MULTI_VERSIONS!\n"));
	1308	if (fIcbTagFlags & UDF_ICB_FLAGS_STREAM)
	1309	LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_STREAM!\n"));
	1310	if (fIcbTagFlags & UDF_ICB_FLAGS_RESERVED_MASK)
	1311	LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_RESERVED_MASK (%#x)!\n", fIcbTagFlags & UDF_ICB_FLAGS_RESERVED_MASK));
	1312
	1313	*pfAttrib = fAttrib;
	1314	return VINF_SUCCESS;
	1315	}
	1316
	1317
	1318	/**
	1319	* Initialize/update a core object structure from an UDF extended file entry.
	1320	*
	1321	* @returns IPRT status code
	1322	* @param pCore The core object structure to initialize.
	1323	* @param pFileEntry The file entry.
	1324	* @param idxDefaultPart The default data partition.
	1325	* @param pcProcessed Variable to increment on success.
	1326	* @param pVol The volume instance.
	1327	*/
	1328	static int rtFsIsoCore_InitFromUdfIcbExFileEntry(PRTFSISOCORE pCore, PCUDFEXFILEENTRY pFileEntry, uint32_t idxDefaultPart,
	1329	uint32_t *pcProcessed, PRTFSISOVOL pVol)
	1330	{
	1331	#ifdef LOG_ENABLED
	1332	/*
	1333	* Log it.
	1334	*/
	1335	if (LogIs2Enabled())
	1336	{
	1337	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", IcbTag.cEntiresBeforeThis);
	1338	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.uStrategyType);
	1339	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[0]);
	1340	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[1]);
	1341	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.cMaxEntries);
	1342	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bReserved);
	1343	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bFileType);
	1344	UDF_LOG2_MEMBER_LBADDR(pFileEntry, IcbTag.ParentIcb);
	1345	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.fFlags);
	1346	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uid);
	1347	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", gid);
	1348	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", fPermissions);
	1349	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", cHardlinks);
	1350	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", uRecordFormat);
	1351	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", fRecordDisplayAttribs);
	1352	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbRecord);
	1353	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbData);
	1354	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbObject);
	1355	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cLogicalBlocks);
	1356	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, AccessTime);
	1357	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ModificationTime);
	1358	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, BirthTime);
	1359	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ChangeTime);
	1360	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uCheckpoint);
	1361	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uReserved);
	1362	UDF_LOG2_MEMBER_LONGAD(pFileEntry, ExtAttribIcb);
	1363	UDF_LOG2_MEMBER_LONGAD(pFileEntry, StreamDirIcb);
	1364	UDF_LOG2_MEMBER_ENTITY_ID(pFileEntry, idImplementation);
	1365	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", INodeId);
	1366	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbExtAttribs);
	1367	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbAllocDescs);
	1368	if (pFileEntry->cbExtAttribs > 0)
	1369	Log2((pFileEntry->cbExtAttribs <= 16 ? "ISO/UDF: %-32s %.Rhxs\n" : "ISO/UDF: %-32s\n%.RhxD\n",
	1370	"abExtAttribs:", pFileEntry->cbExtAttribs, pFileEntry->abExtAttribs));
	1371	if (pFileEntry->cbAllocDescs > 0)
	1372	switch (pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK)
	1373	{
	1374	case UDF_ICB_FLAGS_AD_TYPE_SHORT:
	1375	{
	1376	PCUDFSHORTAD paDescs = (PCUDFSHORTAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs];
	1377	uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]);
	1378	for (uint32_t i = 0; i < cDescs; i++)
	1379	Log2(("ISO/UDF: ShortAD[%u]: %#010RX32 LB %#010RX32; type=%u\n",
	1380	i, paDescs[i].off, paDescs[i].cb, paDescs[i].uType));
	1381	break;
	1382	}
	1383	case UDF_ICB_FLAGS_AD_TYPE_LONG:
	1384	{
	1385	PCUDFLONGAD paDescs = (PCUDFLONGAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs];
	1386	uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]);
	1387	for (uint32_t i = 0; i < cDescs; i++)
	1388	Log2(("ISO/UDF: LongAD[%u]: %#06RX16:%#010RX32 LB %#010RX32; type=%u iu=%.6Rhxs\n",
	1389	i, paDescs[i].Location.uPartitionNo, paDescs[i].Location.off,
	1390	paDescs[i].cb, paDescs[i].uType, &paDescs[i].ImplementationUse));
	1391	break;
	1392	}
	1393	default:
	1394	Log2(("ISO/UDF: %-32s Type=%u\n%.*RhxD\n",
	1395	"abExtAttribs:", pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK,
	1396	pFileEntry->cbAllocDescs, &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]));
	1397	break;
	1398	}
	1399	}
	1400	#endif
	1401
	1402	/*
[69027]	1403	* Basic sanity checking of what we use.
[69023]	1404	*/
[73097]	1405	if ( RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
[69029]	1406	> pVol->Udf.VolInfo.cbBlock
[69027]	1407	\|\| (pFileEntry->cbExtAttribs & 3) != 0
[69029]	1408	\|\| pFileEntry->cbExtAttribs >= pVol->Udf.VolInfo.cbBlock
[69027]	1409	\|\| (pFileEntry->cbAllocDescs & 3) != 0
[69029]	1410	\|\| pFileEntry->cbAllocDescs >= pVol->Udf.VolInfo.cbBlock)
[69023]	1411	{
[69029]	1412	LogRelMax(45, ("ISO/UDF: Extended file entry (ICB) is bad size values: cbAllocDesc=%#x cbExtAttribs=%#x (cbBlock=%#x)\n",
	1413	pFileEntry->cbAllocDescs, pFileEntry->cbExtAttribs, pVol->Udf.VolInfo.cbBlock));
[69027]	1414	return VERR_ISOFS_BAD_FILE_ENTRY;
	1415	}
[69023]	1416
[69029]	1417	//pCore->uid = pFileEntry->uid;
	1418	//pCore->gid = pFileEntry->gid;
	1419	//pCore->cHardlinks = RT_MIN(pFileEntry->cHardlinks, 1);
	1420	pCore->cbObject = pFileEntry->cbData;
	1421	//pCore->cbAllocated = pFileEntry->cLogicalBlocks << pVol->Udf.VolInfo.cShiftBlock;
[69048]	1422	pCore->idINode = pFileEntry->INodeId;
[69029]	1423
	1424	rtFsIsoUdfTimestamp2TimeSpec(&pCore->AccessTime, &pFileEntry->AccessTime);
	1425	rtFsIsoUdfTimestamp2TimeSpec(&pCore->ModificationTime, &pFileEntry->ModificationTime);
	1426	rtFsIsoUdfTimestamp2TimeSpec(&pCore->BirthTime, &pFileEntry->BirthTime);
	1427	rtFsIsoUdfTimestamp2TimeSpec(&pCore->ChangeTime, &pFileEntry->ChangeTime);
	1428
	1429	if ( pFileEntry->uRecordFormat
	1430	\|\| pFileEntry->fRecordDisplayAttribs
	1431	\|\| pFileEntry->cbRecord)
	1432	LogRelMax(45, ("ISO/UDF: uRecordFormat=%#x fRecordDisplayAttribs=%#x cbRecord=%#x\n",
	1433	pFileEntry->uRecordFormat, pFileEntry->fRecordDisplayAttribs, pFileEntry->cbRecord));
	1434
[69027]	1435	/*
[69029]	1436	* Conver the file mode.
[69027]	1437	*/
[69029]	1438	int rc = rtFsIsoCore_UdfStuffToFileMode(pFileEntry->IcbTag.fFlags, pFileEntry->IcbTag.bFileType,
	1439	pFileEntry->fPermissions, &pCore->fAttrib);
	1440	if (RT_SUCCESS(rc))
	1441	{
	1442	/*
	1443	* Convert extent info.
	1444	*/
	1445	rc = rtFsIsoCore_InitExtentsUdfIcbEntry(pCore,
[69027]	1446	&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs],
	1447	pFileEntry->cbAllocDescs,
	1448	pFileEntry->IcbTag.fFlags,
	1449	idxDefaultPart,
[69029]	1450	((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock)
[73097]	1451	+ RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
[69029]	1452	pVol);
	1453	if (RT_SUCCESS(rc))
	1454	{
	1455	/*
	1456	* We're good.
	1457	*/
	1458	*pcProcessed += 1;
	1459	return VINF_SUCCESS;
	1460	}
	1461
	1462	/* Just in case. */
	1463	if (pCore->paExtents)
	1464	{
	1465	RTMemFree(pCore->paExtents);
	1466	pCore->paExtents = NULL;
	1467	}
	1468	pCore->cExtents = 0;
	1469	}
	1470	return rc;
	1471	}
	1472
	1473
	1474	/**
	1475	* Initialize/update a core object structure from an UDF file entry.
	1476	*
	1477	* @returns IPRT status code
	1478	* @param pCore The core object structure to initialize.
	1479	* @param pFileEntry The file entry.
	1480	* @param idxDefaultPart The default data partition.
	1481	* @param pcProcessed Variable to increment on success.
	1482	* @param pVol The volume instance.
	1483	*/
	1484	static int rtFsIsoCore_InitFromUdfIcbFileEntry(PRTFSISOCORE pCore, PCUDFFILEENTRY pFileEntry, uint32_t idxDefaultPart,
	1485	uint32_t *pcProcessed, PRTFSISOVOL pVol)
	1486	{
	1487	#ifdef LOG_ENABLED
	1488	/*
	1489	* Log it.
	1490	*/
	1491	if (LogIs2Enabled())
[69027]	1492	{
[69029]	1493	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", IcbTag.cEntiresBeforeThis);
	1494	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.uStrategyType);
	1495	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[0]);
	1496	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[1]);
	1497	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.cMaxEntries);
	1498	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bReserved);
	1499	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bFileType);
	1500	UDF_LOG2_MEMBER_LBADDR(pFileEntry, IcbTag.ParentIcb);
	1501	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.fFlags);
	1502	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uid);
	1503	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", gid);
	1504	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", fPermissions);
	1505	UDF_LOG2_MEMBER(pFileEntry, "#06RX16", cHardlinks);
	1506	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", uRecordFormat);
	1507	UDF_LOG2_MEMBER(pFileEntry, "#04RX8", fRecordDisplayAttribs);
	1508	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbRecord);
	1509	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbData);
	1510	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cLogicalBlocks);
	1511	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, AccessTime);
	1512	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ModificationTime);
	1513	UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ChangeTime);
	1514	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uCheckpoint);
	1515	UDF_LOG2_MEMBER_LONGAD(pFileEntry, ExtAttribIcb);
	1516	UDF_LOG2_MEMBER_ENTITY_ID(pFileEntry, idImplementation);
	1517	UDF_LOG2_MEMBER(pFileEntry, "#018RX64", INodeId);
	1518	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbExtAttribs);
	1519	UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbAllocDescs);
	1520	if (pFileEntry->cbExtAttribs > 0)
	1521	Log2((pFileEntry->cbExtAttribs <= 16 ? "ISO/UDF: %-32s %.Rhxs\n" : "ISO/UDF: %-32s\n%.RhxD\n",
	1522	"abExtAttribs:", pFileEntry->cbExtAttribs, pFileEntry->abExtAttribs));
	1523	if (pFileEntry->cbAllocDescs > 0)
	1524	switch (pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK)
	1525	{
	1526	case UDF_ICB_FLAGS_AD_TYPE_SHORT:
	1527	{
	1528	PCUDFSHORTAD paDescs = (PCUDFSHORTAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs];
	1529	uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]);
	1530	for (uint32_t i = 0; i < cDescs; i++)
	1531	Log2(("ISO/UDF: ShortAD[%u]: %#010RX32 LB %#010RX32; type=%u\n",
	1532	i, paDescs[i].off, paDescs[i].cb, paDescs[i].uType));
	1533	break;
	1534	}
	1535	case UDF_ICB_FLAGS_AD_TYPE_LONG:
	1536	{
	1537	PCUDFLONGAD paDescs = (PCUDFLONGAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs];
	1538	uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]);
	1539	for (uint32_t i = 0; i < cDescs; i++)
	1540	Log2(("ISO/UDF: LongAD[%u]: %#06RX16:%#010RX32 LB %#010RX32; type=%u iu=%.6Rhxs\n",
	1541	i, paDescs[i].Location.uPartitionNo, paDescs[i].Location.off,
	1542	paDescs[i].cb, paDescs[i].uType, &paDescs[i].ImplementationUse));
	1543	break;
	1544	}
	1545	default:
	1546	Log2(("ISO/UDF: %-32s Type=%u\n%.*RhxD\n",
	1547	"abExtAttribs:", pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK,
	1548	pFileEntry->cbAllocDescs, &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]));
	1549	break;
	1550	}
[69027]	1551	}
[69029]	1552	#endif
[69023]	1553
[69029]	1554	/*
	1555	* Basic sanity checking of what we use.
	1556	*/
[73097]	1557	if ( RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs
[69029]	1558	> pVol->Udf.VolInfo.cbBlock
	1559	\|\| (pFileEntry->cbExtAttribs & 3) != 0
	1560	\|\| pFileEntry->cbExtAttribs >= pVol->Udf.VolInfo.cbBlock
	1561	\|\| (pFileEntry->cbAllocDescs & 3) != 0
	1562	\|\| pFileEntry->cbAllocDescs >= pVol->Udf.VolInfo.cbBlock)
	1563	{
	1564	LogRelMax(45, ("ISO/UDF: File entry (ICB) is bad size values: cbAllocDesc=%#x cbExtAttribs=%#x (cbBlock=%#x)\n",
	1565	pFileEntry->cbAllocDescs, pFileEntry->cbExtAttribs, pVol->Udf.VolInfo.cbBlock));
	1566	return VERR_ISOFS_BAD_FILE_ENTRY;
	1567	}
[69023]	1568
[69029]	1569	//pCore->uid = pFileEntry->uid;
	1570	//pCore->gid = pFileEntry->gid;
	1571	//pCore->cHardlinks = RT_MIN(pFileEntry->cHardlinks, 1);
	1572	pCore->cbObject = pFileEntry->cbData;
	1573	//pCore->cbAllocated = pFileEntry->cLogicalBlocks << pVol->Udf.VolInfo.cShiftBlock;
[69048]	1574	pCore->idINode = pFileEntry->INodeId;
[69023]	1575
[69029]	1576	rtFsIsoUdfTimestamp2TimeSpec(&pCore->AccessTime, &pFileEntry->AccessTime);
	1577	rtFsIsoUdfTimestamp2TimeSpec(&pCore->ModificationTime, &pFileEntry->ModificationTime);
	1578	rtFsIsoUdfTimestamp2TimeSpec(&pCore->ChangeTime, &pFileEntry->ChangeTime);
	1579	pCore->BirthTime = pCore->ModificationTime;
	1580	if (RTTimeSpecCompare(&pCore->BirthTime, &pCore->ChangeTime) > 0)
	1581	pCore->BirthTime = pCore->ChangeTime;
	1582	if (RTTimeSpecCompare(&pCore->BirthTime, &pCore->AccessTime) > 0)
	1583	pCore->BirthTime = pCore->AccessTime;
	1584
	1585	if ( pFileEntry->uRecordFormat
	1586	\|\| pFileEntry->fRecordDisplayAttribs
	1587	\|\| pFileEntry->cbRecord)
	1588	LogRelMax(45, ("ISO/UDF: uRecordFormat=%#x fRecordDisplayAttribs=%#x cbRecord=%#x\n",
	1589	pFileEntry->uRecordFormat, pFileEntry->fRecordDisplayAttribs, pFileEntry->cbRecord));
	1590
[69023]	1591	/*
[69029]	1592	* Conver the file mode.
[69023]	1593	*/
[69029]	1594	int rc = rtFsIsoCore_UdfStuffToFileMode(pFileEntry->IcbTag.fFlags, pFileEntry->IcbTag.bFileType,
	1595	pFileEntry->fPermissions, &pCore->fAttrib);
	1596	if (RT_SUCCESS(rc))
	1597	{
	1598	/*
	1599	* Convert extent info.
	1600	*/
	1601	rc = rtFsIsoCore_InitExtentsUdfIcbEntry(pCore,
	1602	&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs],
	1603	pFileEntry->cbAllocDescs,
	1604	pFileEntry->IcbTag.fFlags,
	1605	idxDefaultPart,
	1606	((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock)
[73097]	1607	+ RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs,
[69029]	1608	pVol);
	1609	if (RT_SUCCESS(rc))
	1610	{
	1611	/*
	1612	* We're good.
	1613	*/
	1614	*pcProcessed += 1;
	1615	return VINF_SUCCESS;
	1616	}
	1617
	1618	/* Just in case. */
	1619	if (pCore->paExtents)
	1620	{
	1621	RTMemFree(pCore->paExtents);
	1622	pCore->paExtents = NULL;
	1623	}
	1624	pCore->cExtents = 0;
	1625	}
	1626	return rc;
[69027]	1627	}
[69023]	1628
[69029]	1629
	1630	/**
	1631	* Recursive helper for rtFsIsoCore_InitFromUdfIcbAndFileIdDesc.
	1632	*
	1633	* @returns IRPT status code.
	1634	* @param pCore The core structure to initialize.
	1635	* @param AllocDesc The ICB allocation descriptor.
	1636	* @param pbBuf The buffer, one logical block in size.
	1637	* @param cNestings The number of recursive nestings (should be zero).
	1638	* @param pcProcessed Variable to update when we've processed something
	1639	* useful.
	1640	* @param pcIndirections Variable tracing the number of indirections we've
	1641	* taken during the processing. This is used to
	1642	* prevent us from looping forever on a bad chain
	1643	* @param pVol The volue instance data.
	1644	*/
[69027]	1645	static int rtFsIsoCore_InitFromUdfIcbRecursive(PRTFSISOCORE pCore, UDFLONGAD AllocDesc, uint8_t *pbBuf, uint32_t cNestings,
[69029]	1646	uint32_t pcProcessed, uint32_t pcIndirections, PRTFSISOVOL pVol)
[69027]	1647	{
	1648	if (cNestings >= 8)
	1649	return VERR_ISOFS_TOO_DEEP_ICB_RECURSION;
[69023]	1650
[69027]	1651	for (;;)
[69023]	1652	{
[69027]	1653	if (*pcIndirections >= 32)
	1654	return VERR_ISOFS_TOO_MANY_ICB_INDIRECTIONS;
	1655
[69023]	1656	/*
[69027]	1657	* Check the basic validity of the allocation descriptor.
[69023]	1658	*/
[69027]	1659	if ( AllocDesc.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED
	1660	&& AllocDesc.cb >= sizeof(UDFICBTAG) )
	1661	{ /* likely */ }
	1662	else if (AllocDesc.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED)
[69023]	1663	{
[69027]	1664	Log(("ISO/UDF: ICB has alloc type %d!\n", AllocDesc.uType));
	1665	return VINF_SUCCESS;
[69023]	1666	}
[69027]	1667	else
	1668	{
	1669	LogRelMax(45, ("ISO/UDF: ICB is too small: %u bytes\n", AllocDesc.cb));
[69035]	1670	return AllocDesc.cb == 0 ? VINF_SUCCESS : VERR_ISOFS_ICB_ENTRY_TOO_SMALL;
[69027]	1671	}
[69023]	1672
[69027]	1673	/*
	1674	* Process it block by block.
	1675	*/
[69029]	1676	uint32_t cBlocks = (AllocDesc.cb + pVol->Udf.VolInfo.cbBlock - 1) >> pVol->Udf.VolInfo.cShiftBlock;
[69027]	1677	for (uint32_t idxBlock = 0; ; idxBlock++)
[69023]	1678	{
[69027]	1679	/*
	1680	* Read a block
	1681	*/
[69029]	1682	size_t cbToRead = RT_MIN(pVol->Udf.VolInfo.cbBlock, AllocDesc.cb);
	1683	int rc = rtFsIsoVolUdfVpRead(pVol, AllocDesc.Location.uPartitionNo, AllocDesc.Location.off + idxBlock, 0,
[69027]	1684	pbBuf, cbToRead);
	1685	if (RT_FAILURE(rc))
	1686	return rc;
[69029]	1687	if (cbToRead < pVol->Udf.VolInfo.cbBlock)
	1688	RT_BZERO(&pbBuf[cbToRead], pVol->Udf.VolInfo.cbBlock - cbToRead);
[69023]	1689
[69027]	1690	/*
	1691	* Verify the TAG.
	1692	*/
	1693	PUDFICBHDR pHdr = (PUDFICBHDR)pbBuf;
[69029]	1694	rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pHdr->Tag, pVol->Udf.VolInfo.cbBlock, UINT16_MAX,
[69027]	1695	AllocDesc.Location.off + idxBlock, NULL);
	1696	if (RT_FAILURE(rc))
	1697	return rc;
	1698
	1699	/*
	1700	* Do specific processing.
	1701	*/
	1702	if (pHdr->Tag.idTag == UDF_TAG_ID_FILE_ENTRY)
	1703	rc = rtFsIsoCore_InitFromUdfIcbFileEntry(pCore, (PCUDFFILEENTRY)pHdr, AllocDesc.Location.uPartitionNo,
[69029]	1704	pcProcessed, pVol);
[69027]	1705	else if (pHdr->Tag.idTag == UDF_TAG_ID_EXTENDED_FILE_ENTRY)
[69029]	1706	rc = rtFsIsoCore_InitFromUdfIcbExFileEntry(pCore, (PCUDFEXFILEENTRY)pHdr, AllocDesc.Location.uPartitionNo,
	1707	pcProcessed, pVol);
[69027]	1708	else if (pHdr->Tag.idTag == UDF_TAG_ID_INDIRECT_ENTRY)
	1709	{
	1710	PUDFINDIRECTENTRY pIndir = (PUDFINDIRECTENTRY)pHdr;
	1711	*pcIndirections += 1;
	1712	if (pIndir->IndirectIcb.cb != 0)
	1713	{
	1714	if (idxBlock + 1 == cBlocks)
	1715	{
	1716	AllocDesc = pIndir->IndirectIcb;
	1717	Log2(("ISO/UDF: ICB: Indirect entry - looping: %x:%#010RX32 LB %#x; uType=%d\n",
	1718	AllocDesc.Location.uPartitionNo, AllocDesc.Location.off, AllocDesc.cb, AllocDesc.uType));
	1719	break;
	1720	}
	1721	Log2(("ISO/UDF: ICB: Indirect entry - recursing: %x:%#010RX32 LB %#x; uType=%d\n",
	1722	pIndir->IndirectIcb.Location.uPartitionNo, pIndir->IndirectIcb.Location.off,
	1723	pIndir->IndirectIcb.cb, pIndir->IndirectIcb.uType));
	1724	rc = rtFsIsoCore_InitFromUdfIcbRecursive(pCore, pIndir->IndirectIcb, pbBuf, cNestings,
[69029]	1725	pcProcessed, pcIndirections, pVol);
[69027]	1726	}
	1727	else
	1728	Log(("ISO/UDF: zero length indirect entry\n"));
	1729	}
	1730	else if (pHdr->Tag.idTag == UDF_TAG_ID_TERMINAL_ENTRY)
	1731	{
	1732	Log2(("ISO/UDF: Terminal ICB entry\n"));
	1733	return VINF_SUCCESS;
	1734	}
	1735	else if (pHdr->Tag.idTag == UDF_TAG_ID_UNALLOCATED_SPACE_ENTRY)
	1736	{
	1737	Log2(("ISO/UDF: Unallocated space entry: skipping\n"));
	1738	/* Ignore since we don't do writing (UDFUNALLOCATEDSPACEENTRY) */
	1739	}
	1740	else
	1741	{
	1742	LogRelMax(90, ("ISO/UDF: Unknown ICB type %#x\n", pHdr->Tag.idTag));
	1743	return VERR_ISOFS_UNSUPPORTED_ICB;
	1744	}
	1745	if (RT_FAILURE(rc))
	1746	return rc;
	1747
	1748	/*
	1749	* Advance.
	1750	*/
	1751	if (idxBlock + 1 >= cBlocks)
	1752	return VINF_SUCCESS;
[69023]	1753	}
	1754
[69027]	1755	/* If we get here, we've jumped thru an indirect entry. */
	1756	}
	1757	/* never reached */
	1758	}
[69023]	1759
	1760
[69027]	1761
[69029]	1762	/**
	1763	* Initialize a core structure from an UDF ICB range and optionally a file ID.
	1764	*
	1765	* @returns IPRT status code.
	1766	* @param pCore The core structure to initialize.
	1767	* Caller must've ZEROed this structure!
	1768	* @param pAllocDesc The ICB allocation descriptor.
[69035]	1769	* @param pFid The file ID descriptor. Optional.
[69048]	1770	* @param offInDir The offset of the file ID descriptor in the
	1771	* parent directory. This is used when looking up
	1772	* shared directory objects. (Pass 0 for root.)
[69029]	1773	* @param pVol The instance.
[69048]	1774	*
	1775	* @note Caller must check for UDF_FILE_FLAGS_DELETED before calling if the
	1776	* object is supposed to be used for real stuff.
[69029]	1777	*/
[69027]	1778	static int rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(PRTFSISOCORE pCore, PCUDFLONGAD pAllocDesc,
[69048]	1779	PCUDFFILEIDDESC pFid, uintptr_t offInDir, PRTFSISOVOL pVol)
[69027]	1780	{
[69029]	1781	Assert(pCore->cRefs == 0);
	1782	Assert(pCore->cExtents == 0);
	1783	Assert(pCore->paExtents == NULL);
	1784	Assert(pCore->pVol == NULL);
	1785
[69035]	1786	/*
	1787	* Some size sanity checking.
	1788	*/
	1789	if (pAllocDesc->cb <= _64K)
	1790	{
	1791	if (pAllocDesc->cb >= sizeof(UDFICBHDR))
	1792	{ /* likely */ }
	1793	else
	1794	{
	1795	Log(("rtFsIsoCore_InitFromUdfIcbAndFileIdDesc: ICB too small: %#04x:%010RX32 LB %#x\n",
	1796	pAllocDesc->Location.uPartitionNo, pAllocDesc->Location.off, pAllocDesc->cb));
	1797	return VERR_ISOFS_ICB_TOO_SMALL;
	1798	}
	1799	}
	1800	else
	1801	{
	1802	Log(("rtFsIsoCore_InitFromUdfIcbAndFileIdDesc: ICB too big: %#04x:%010RX32 LB %#x\n",
	1803	pAllocDesc->Location.uPartitionNo, pAllocDesc->Location.off, pAllocDesc->cb));
	1804	return VERR_ISOFS_ICB_TOO_BIG;
	1805	}
[69027]	1806
	1807	/*
	1808	* Allocate a temporary buffer, one logical block in size.
	1809	*/
[69029]	1810	uint8_t * const pbBuf = (uint8_t *)RTMemTmpAlloc(pVol->Udf.VolInfo.cbBlock);
[69027]	1811	if (pbBuf)
	1812	{
	1813	uint32_t cProcessed = 0;
	1814	uint32_t cIndirections = 0;
[69029]	1815	int rc = rtFsIsoCore_InitFromUdfIcbRecursive(pCore, *pAllocDesc, pbBuf, 0, &cProcessed, &cIndirections, pVol);
[69027]	1816	RTMemTmpFree(pbBuf);
	1817	if (RT_SUCCESS(rc))
	1818	{
	1819	if (cProcessed > 0)
[69029]	1820	{
[69048]	1821	if (pFid)
	1822	{
	1823	if (pFid->fFlags & UDF_FILE_FLAGS_HIDDEN)
	1824	pCore->fAttrib \|= RTFS_DOS_HIDDEN;
	1825	if (pFid->fFlags & UDF_FILE_FLAGS_DELETED)
	1826	pCore->fAttrib = (pCore->fAttrib & ~RTFS_TYPE_MASK) \| RTFS_TYPE_WHITEOUT;
	1827	}
[69035]	1828
[69048]	1829	pCore->cRefs = 1;
	1830	pCore->pVol = pVol;
	1831	pCore->offDirRec = offInDir;
[69027]	1832	return VINF_SUCCESS;
[69029]	1833	}
[69027]	1834	rc = VERR_ISOFS_NO_DIRECT_ICB_ENTRIES;
	1835	}
[69048]	1836
	1837	/* White-out fix. Caller must be checking for UDF_FILE_FLAGS_DELETED */
	1838	if ( pFid
	1839	&& (pFid->fFlags & UDF_FILE_FLAGS_DELETED))
	1840	{
	1841	pCore->fAttrib = (pCore->fAttrib & ~RTFS_TYPE_MASK) \| RTFS_TYPE_WHITEOUT;
	1842	return VINF_SUCCESS;
	1843	}
[69027]	1844	return rc;
[69023]	1845	}
[69029]	1846
	1847	pCore->pVol = NULL;
[69027]	1848	return VERR_NO_TMP_MEMORY;
[69023]	1849	}
	1850
	1851
[66735]	1852	/**
[69029]	1853	* Simple UDF read function.
	1854	*
	1855	* This deals with extent mappings as well as virtual partition related block
	1856	* mapping and such.
	1857	*
	1858	* @returns VBox status code.
	1859	* @param pCore The core object to read data from.
	1860	* @param offRead The offset to start reading at.
	1861	* @param pvBuf The output buffer.
	1862	* @param cbToRead The number of bytes to read.
	1863	* @param pcbRead Where to return the number of bytes read.
[69048]	1864	* @param poffPosMov Where to return the number of bytes to move the read
	1865	* position. Optional. (Essentially same as pcbRead
	1866	* except without the behavior change.)
[69029]	1867	*/
[69048]	1868	static int rtFsIsoCore_ReadWorker(PRTFSISOCORE pCore, uint64_t offRead, void *pvBuf, size_t cbToRead,
	1869	size_t pcbRead, size_t poffPosMov)
[69029]	1870	{
	1871	/*
	1872	* Check for EOF.
	1873	*/
	1874	if (offRead >= pCore->cbObject)
	1875	{
[69048]	1876	if (poffPosMov)
	1877	*poffPosMov = 0;
[69029]	1878	if (pcbRead)
	1879	{
	1880	*pcbRead = 0;
	1881	return VINF_EOF;
	1882	}
	1883	return VERR_EOF;
	1884	}
[69048]	1885	int rcRet = VINF_SUCCESS;
[69029]	1886	if ( cbToRead > pCore->cbObject
	1887	\|\| offRead + cbToRead > pCore->cbObject)
	1888	{
	1889	if (!pcbRead)
[69048]	1890	{
	1891	if (poffPosMov)
	1892	*poffPosMov = 0;
[69029]	1893	return VERR_EOF;
[69048]	1894	}
[69029]	1895	cbToRead = pCore->cbObject - offRead;
[69048]	1896	rcRet = VINF_EOF;
[69029]	1897	}
	1898
[69048]	1899	uint64_t cbActual = 0;
	1900
[69029]	1901	/*
	1902	* Don't bother looking up the extent if we're not going to
[69048]	1903	* read anything from it.
[69029]	1904	*/
[69048]	1905	if (cbToRead > 0)
[69029]	1906	{
[69048]	1907	/*
	1908	* Locate the first extent.
	1909	*/
	1910	uint64_t offExtent = 0;
	1911	uint32_t iExtent = 0;
	1912	PCRTFSISOEXTENT pCurExtent = &pCore->FirstExtent;
	1913	if (offRead < pCurExtent->cbExtent)
	1914	{ /* likely */ }
	1915	else
	1916	do
[69029]	1917	{
[69048]	1918	offExtent += pCurExtent->cbExtent;
	1919	pCurExtent = &pCore->paExtents[iExtent++];
	1920	if (iExtent >= pCore->cExtents)
	1921	{
	1922	memset(pvBuf, 0, cbToRead);
[69029]	1923
[69048]	1924	if (pcbRead)
	1925	*pcbRead = cbToRead;
	1926	if (poffPosMov)
	1927	*poffPosMov = cbToRead;
	1928	return rcRet;
	1929	}
	1930	} while (offExtent < offRead);
	1931	Assert(offRead - offExtent < pCurExtent->cbExtent);
[69029]	1932
[69048]	1933	/*
	1934	* Do the reading part.
	1935	*/
	1936	PRTFSISOVOL pVol = pCore->pVol;
	1937	for (;;)
[69029]	1938	{
[69048]	1939	uint64_t offIntoExtent = offRead - offExtent;
	1940	size_t cbThisRead = pCurExtent->cbExtent - offIntoExtent;
	1941	if (cbThisRead > cbToRead)
	1942	cbThisRead = cbToRead;
	1943
	1944	if (pCurExtent->off == UINT64_MAX)
	1945	RT_BZERO(pvBuf, cbThisRead);
[69029]	1946	else
	1947	{
[69048]	1948	int rc2;
	1949	if (pCurExtent->idxPart == UINT32_MAX)
	1950	rc2 = RTVfsFileReadAt(pVol->hVfsBacking, pCurExtent->off + offIntoExtent, pvBuf, cbThisRead, NULL);
	1951	else
[69029]	1952	{
[69048]	1953	Assert(pVol->enmType == RTFSISOVOLTYPE_UDF);
	1954	if (pCurExtent->idxPart < pVol->Udf.VolInfo.cPartitions)
[69029]	1955	{
[69048]	1956	PRTFSISOVOLUDFPMAP pPart = &pVol->Udf.VolInfo.paPartitions[pCurExtent->idxPart];
	1957	switch (pPart->bType)
	1958	{
	1959	case RTFSISO_UDF_PMAP_T_PLAIN:
	1960	rc2 = RTVfsFileReadAt(pVol->hVfsBacking, pPart->offByteLocation + pCurExtent->off + offIntoExtent,
	1961	pvBuf, cbThisRead, NULL);
	1962	break;
	1963
	1964	default:
	1965	AssertFailed();
	1966	rc2 = VERR_ISOFS_IPE_1;
	1967	break;
	1968	}
[69029]	1969	}
[69048]	1970	else
	1971	{
	1972	Log(("ISO/UDF: Invalid partition index %#x (offset %#RX64), max partitions %#x; iExtent=%#x\n",
	1973	pCurExtent->idxPart, pCurExtent->off + offIntoExtent, pVol->Udf.VolInfo.cPartitions, iExtent));
	1974	rc2 = VERR_ISOFS_INVALID_PARTITION_INDEX;
	1975	}
[69029]	1976	}
[69048]	1977	if (RT_FAILURE(rc2))
[69029]	1978	{
[69048]	1979	rcRet = rc2;
	1980	break;
[69029]	1981	}
	1982	}
[69048]	1983
	1984	/*
	1985	* Advance the buffer position and check if we're done (probable).
	1986	*/
	1987	cbActual += cbThisRead;
	1988	cbToRead -= cbThisRead;
	1989	if (!cbToRead)
	1990	break;
	1991	pvBuf = (uint8_t *)pvBuf + cbThisRead;
	1992
	1993	/*
	1994	* Advance to the next extent.
	1995	*/
	1996	offExtent += pCurExtent->cbExtent;
	1997	pCurExtent = &pCore->paExtents[iExtent++];
	1998	if (iExtent >= pCore->cExtents)
[69029]	1999	{
[69048]	2000	memset(pvBuf, 0, cbToRead);
	2001	cbActual += cbToRead;
	2002	break;
[69029]	2003	}
	2004	}
[69048]	2005	}
	2006	else
	2007	Assert(rcRet == VINF_SUCCESS);
[69029]	2008
[69048]	2009	if (poffPosMov)
	2010	*poffPosMov = cbActual;
	2011	if (pcbRead)
	2012	*pcbRead = cbActual;
	2013	return rcRet;
[69029]	2014	}
	2015
	2016
	2017	/**
[68694]	2018	* Worker for rtFsIsoFile_QueryInfo and rtFsIsoDir_QueryInfo.
[66735]	2019	*/
[68694]	2020	static int rtFsIsoCore_QueryInfo(PRTFSISOCORE pCore, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
[66735]	2021	{
[66765]	2022	pObjInfo->cbObject = pCore->cbObject;
	2023	pObjInfo->cbAllocated = RT_ALIGN_64(pCore->cbObject, pCore->pVol->cbBlock);
	2024	pObjInfo->AccessTime = pCore->AccessTime;
	2025	pObjInfo->ModificationTime = pCore->ModificationTime;
	2026	pObjInfo->ChangeTime = pCore->ChangeTime;
	2027	pObjInfo->BirthTime = pCore->BirthTime;
	2028	pObjInfo->Attr.fMode = pCore->fAttrib;
[66735]	2029	pObjInfo->Attr.enmAdditional = enmAddAttr;
	2030
	2031	switch (enmAddAttr)
	2032	{
[69013]	2033	case RTFSOBJATTRADD_NOTHING: RT_FALL_THRU();
[66735]	2034	case RTFSOBJATTRADD_UNIX:
	2035	pObjInfo->Attr.u.Unix.uid = NIL_RTUID;
	2036	pObjInfo->Attr.u.Unix.gid = NIL_RTGID;
	2037	pObjInfo->Attr.u.Unix.cHardlinks = 1;
	2038	pObjInfo->Attr.u.Unix.INodeIdDevice = 0;
[69048]	2039	pObjInfo->Attr.u.Unix.INodeId = pCore->idINode;
[66735]	2040	pObjInfo->Attr.u.Unix.fFlags = 0;
[67559]	2041	pObjInfo->Attr.u.Unix.GenerationId = pCore->uVersion;
[66735]	2042	pObjInfo->Attr.u.Unix.Device = 0;
	2043	break;
	2044	case RTFSOBJATTRADD_UNIX_OWNER:
	2045	pObjInfo->Attr.u.UnixOwner.uid = 0;
	2046	pObjInfo->Attr.u.UnixOwner.szName[0] = '\0';
	2047	break;
	2048	case RTFSOBJATTRADD_UNIX_GROUP:
	2049	pObjInfo->Attr.u.UnixGroup.gid = 0;
	2050	pObjInfo->Attr.u.UnixGroup.szName[0] = '\0';
	2051	break;
	2052	case RTFSOBJATTRADD_EASIZE:
	2053	pObjInfo->Attr.u.EASize.cb = 0;
	2054	break;
	2055	default:
	2056	return VERR_INVALID_PARAMETER;
	2057	}
[94280]	2058
	2059	if ( pCore->fHaveRockInfo
	2060	&& enmAddAttr != RTFSOBJATTRADD_NOTHING)
	2061	{
	2062	/** @todo Read the the rock info for this entry. */
	2063	}
	2064
[66735]	2065	return VINF_SUCCESS;
	2066	}
	2067
	2068
	2069	/**
[68694]	2070	* Worker for rtFsIsoFile_Close and rtFsIsoDir_Close that does common work.
[66765]	2071	*
	2072	* @param pCore The common shared structure.
	2073	*/
[68694]	2074	static void rtFsIsoCore_Destroy(PRTFSISOCORE pCore)
[66765]	2075	{
	2076	if (pCore->pParentDir)
[68694]	2077	rtFsIsoDirShrd_RemoveOpenChild(pCore->pParentDir, pCore);
[66765]	2078	if (pCore->paExtents)
	2079	{
	2080	RTMemFree(pCore->paExtents);
	2081	pCore->paExtents = NULL;
	2082	}
	2083	}
	2084
	2085
	2086	/**
	2087	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
	2088	*/
[68694]	2089	static DECLCALLBACK(int) rtFsIsoFile_Close(void *pvThis)
[66765]	2090	{
[68694]	2091	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
	2092	LogFlow(("rtFsIsoFile_Close(%p/%p)\n", pThis, pThis->pShared));
[66765]	2093
[68694]	2094	PRTFSISOFILESHRD pShared = pThis->pShared;
[66765]	2095	pThis->pShared = NULL;
	2096	if (pShared)
	2097	{
	2098	if (ASMAtomicDecU32(&pShared->Core.cRefs) == 0)
	2099	{
[68694]	2100	LogFlow(("rtFsIsoFile_Close: Destroying shared structure %p\n", pShared));
	2101	rtFsIsoCore_Destroy(&pShared->Core);
[66765]	2102	RTMemFree(pShared);
	2103	}
	2104	}
	2105	return VINF_SUCCESS;
	2106	}
	2107
	2108
	2109	/**
	2110	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
	2111	*/
[68694]	2112	static DECLCALLBACK(int) rtFsIsoFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
[66765]	2113	{
[68694]	2114	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
	2115	return rtFsIsoCore_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr);
[66765]	2116	}
	2117
	2118
	2119	/**
[66735]	2120	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
	2121	*/
[100908]	2122	static DECLCALLBACK(int) rtFsIsoFile_Read(void pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
[66735]	2123	{
[68694]	2124	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
	2125	PRTFSISOFILESHRD pShared = pThis->pShared;
[69048]	2126	AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3);
[66735]	2127	RT_NOREF(fBlocking);
	2128
[69048]	2129	#if 1
	2130	/* Apply default offset. */
	2131	if (off == -1)
	2132	off = pThis->offFile;
	2133	else
	2134	AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3);
	2135
	2136	/* Do the read. */
	2137	size_t offDelta = 0;
	2138	int rc = rtFsIsoCore_ReadWorker(&pShared->Core, off, (uint8_t *)pSgBuf->paSegs[0].pvSeg,
	2139	pSgBuf->paSegs[0].cbSeg, pcbRead, &offDelta);
	2140
	2141	/* Update the file position and return. */
	2142	pThis->offFile = off + offDelta;
[100908]	2143	RTSgBufAdvance(pSgBuf, offDelta);
	2144
[69048]	2145	return rc;
	2146	#else
	2147
	2148
[66735]	2149	/*
	2150	* Check for EOF.
	2151	*/
	2152	if (off == -1)
	2153	off = pThis->offFile;
[66765]	2154	if ((uint64_t)off >= pShared->Core.cbObject)
[66735]	2155	{
	2156	if (pcbRead)
	2157	{
	2158	*pcbRead = 0;
	2159	return VINF_EOF;
	2160	}
	2161	return VERR_EOF;
	2162	}
	2163
[69035]	2164	if (pShared->Core.pVol->enmType == RTFSISOVOLTYPE_UDF)
	2165	{
	2166	return VERR_ISOFS_UDF_NOT_IMPLEMENTED;
	2167	}
[66735]	2168
	2169	/*
	2170	* Simple case: File has a single extent.
	2171	*/
	2172	int rc = VINF_SUCCESS;
	2173	size_t cbRead = 0;
[66765]	2174	uint64_t cbFileLeft = pShared->Core.cbObject - (uint64_t)off;
[66735]	2175	size_t cbLeft = pSgBuf->paSegs[0].cbSeg;
	2176	uint8_t pbDst = (uint8_t )pSgBuf->paSegs[0].pvSeg;
[66765]	2177	if (pShared->Core.cExtents == 1)
[66735]	2178	{
	2179	if (cbLeft > 0)
	2180	{
	2181	size_t cbToRead = cbLeft;
	2182	if (cbToRead > cbFileLeft)
	2183	cbToRead = (size_t)cbFileLeft;
[69027]	2184	rc = RTVfsFileReadAt(pShared->Core.pVol->hVfsBacking, pShared->Core.FirstExtent.off + off, pbDst, cbToRead, NULL);
[66735]	2185	if (RT_SUCCESS(rc))
	2186	{
	2187	off += cbToRead;
	2188	pbDst += cbToRead;
	2189	cbRead += cbToRead;
	2190	cbFileLeft -= cbToRead;
	2191	cbLeft -= cbToRead;
	2192	}
	2193	}
	2194	}
	2195	/*
	2196	* Complicated case: Work the file content extent by extent.
	2197	*/
	2198	else
	2199	{
	2200	return VERR_NOT_IMPLEMENTED; /** @todo multi-extent stuff . */
	2201	}
	2202
	2203	/* Update the offset and return. */
	2204	pThis->offFile = off;
	2205	if (pcbRead)
	2206	*pcbRead = cbRead;
	2207	return VINF_SUCCESS;
[69048]	2208	#endif
[66735]	2209	}
	2210
	2211
	2212	/**
	2213	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
	2214	*/
[68694]	2215	static DECLCALLBACK(int) rtFsIsoFile_Flush(void *pvThis)
[66735]	2216	{
	2217	RT_NOREF(pvThis);
	2218	return VINF_SUCCESS;
	2219	}
	2220
	2221
	2222	/**
	2223	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
	2224	*/
[68694]	2225	static DECLCALLBACK(int) rtFsIsoFile_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
[66735]	2226	uint32_t *pfRetEvents)
	2227	{
	2228	NOREF(pvThis);
	2229	int rc;
	2230	if (fEvents != RTPOLL_EVT_ERROR)
	2231	{
	2232	*pfRetEvents = fEvents & ~RTPOLL_EVT_ERROR;
	2233	rc = VINF_SUCCESS;
	2234	}
	2235	else if (fIntr)
	2236	rc = RTThreadSleep(cMillies);
	2237	else
	2238	{
	2239	uint64_t uMsStart = RTTimeMilliTS();
	2240	do
	2241	rc = RTThreadSleep(cMillies);
	2242	while ( rc == VERR_INTERRUPTED
	2243	&& !fIntr
	2244	&& RTTimeMilliTS() - uMsStart < cMillies);
	2245	if (rc == VERR_INTERRUPTED)
	2246	rc = VERR_TIMEOUT;
	2247	}
	2248	return rc;
	2249	}
	2250
	2251
	2252	/**
	2253	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
	2254	*/
[68694]	2255	static DECLCALLBACK(int) rtFsIsoFile_Tell(void *pvThis, PRTFOFF poffActual)
[66735]	2256	{
[68694]	2257	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
[66735]	2258	*poffActual = pThis->offFile;
	2259	return VINF_SUCCESS;
	2260	}
	2261
	2262
	2263	/**
	2264	* @interface_method_impl{RTVFSFILEOPS,pfnSeek}
	2265	*/
[68694]	2266	static DECLCALLBACK(int) rtFsIsoFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual)
[66735]	2267	{
[68694]	2268	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
[66735]	2269	RTFOFF offNew;
	2270	switch (uMethod)
	2271	{
	2272	case RTFILE_SEEK_BEGIN:
	2273	offNew = offSeek;
	2274	break;
	2275	case RTFILE_SEEK_END:
[66765]	2276	offNew = (RTFOFF)pThis->pShared->Core.cbObject + offSeek;
[66735]	2277	break;
	2278	case RTFILE_SEEK_CURRENT:
	2279	offNew = (RTFOFF)pThis->offFile + offSeek;
	2280	break;
	2281	default:
	2282	return VERR_INVALID_PARAMETER;
	2283	}
	2284	if (offNew >= 0)
	2285	{
[93510]	2286	pThis->offFile = offNew;
	2287	*poffActual = offNew;
	2288	return VINF_SUCCESS;
[66735]	2289	}
	2290	return VERR_NEGATIVE_SEEK;
	2291	}
	2292
	2293
	2294	/**
	2295	* @interface_method_impl{RTVFSFILEOPS,pfnQuerySize}
	2296	*/
[68694]	2297	static DECLCALLBACK(int) rtFsIsoFile_QuerySize(void pvThis, uint64_t pcbFile)
[66735]	2298	{
[68694]	2299	PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis;
[66765]	2300	*pcbFile = pThis->pShared->Core.cbObject;
[66735]	2301	return VINF_SUCCESS;
	2302	}
	2303
	2304
	2305	/**
[67849]	2306	* ISO FS file operations.
[66735]	2307	*/
[69048]	2308	DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtFsIsoFileOps =
[66735]	2309	{
	2310	{ /* Stream */
	2311	{ /* Obj */
	2312	RTVFSOBJOPS_VERSION,
	2313	RTVFSOBJTYPE_FILE,
	2314	"FatFile",
[68694]	2315	rtFsIsoFile_Close,
	2316	rtFsIsoFile_QueryInfo,
[94291]	2317	NULL,
[66735]	2318	RTVFSOBJOPS_VERSION
	2319	},
	2320	RTVFSIOSTREAMOPS_VERSION,
	2321	RTVFSIOSTREAMOPS_FEAT_NO_SG,
[68694]	2322	rtFsIsoFile_Read,
[69955]	2323	NULL /Write/,
[68694]	2324	rtFsIsoFile_Flush,
	2325	rtFsIsoFile_PollOne,
	2326	rtFsIsoFile_Tell,
[66735]	2327	NULL /pfnSkip/,
	2328	NULL /pfnZeroFill/,
	2329	RTVFSIOSTREAMOPS_VERSION,
	2330	},
	2331	RTVFSFILEOPS_VERSION,
	2332	0,
	2333	{ /* ObjSet */
	2334	RTVFSOBJSETOPS_VERSION,
[73097]	2335	RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj),
[69955]	2336	NULL /SetMode/,
	2337	NULL /SetTimes/,
	2338	NULL /SetOwner/,
[66735]	2339	RTVFSOBJSETOPS_VERSION
	2340	},
[68694]	2341	rtFsIsoFile_Seek,
	2342	rtFsIsoFile_QuerySize,
[69977]	2343	NULL /SetSize/,
	2344	NULL /QueryMaxSize/,
[66735]	2345	RTVFSFILEOPS_VERSION
	2346	};
	2347
	2348
	2349	/**
[69048]	2350	* Instantiates a new file, from ISO 9660 info.
[66735]	2351	*
	2352	* @returns IPRT status code.
[69924]	2353	* @param pThis The ISO volume instance.
[66765]	2354	* @param pParentDir The parent directory (shared part).
[66735]	2355	* @param pDirRec The directory record.
	2356	* @param cDirRecs Number of directory records if more than one.
	2357	* @param offDirRec The byte offset of the directory record.
	2358	* @param offEntryInDir The byte offset of the directory entry in the parent
	2359	* directory.
	2360	* @param fOpen RTFILE_O_XXX flags.
[67559]	2361	* @param uVersion The file version number (since the caller already
	2362	* parsed the filename, we don't want to repeat the
	2363	* effort here).
[94280]	2364	* @param pRockInfo Optional rock ridge info for the file.
[66735]	2365	* @param phVfsFile Where to return the file handle.
	2366	*/
[68694]	2367	static int rtFsIsoFile_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec, uint32_t cDirRecs,
[94280]	2368	uint64_t offDirRec, uint64_t fOpen, uint32_t uVersion, PCRTFSISOROCKINFO pRockInfo,
	2369	PRTVFSFILE phVfsFile)
[66735]	2370	{
	2371	AssertPtr(pParentDir);
	2372
[66765]	2373	/*
	2374	* Create a VFS object.
	2375	*/
[68694]	2376	PRTFSISOFILEOBJ pNewFile;
[69048]	2377	int rc = RTVfsNewFile(&g_rtFsIsoFileOps, sizeof(pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK /use volume lock*/,
[66735]	2378	phVfsFile, (void **)&pNewFile);
	2379	if (RT_SUCCESS(rc))
	2380	{
	2381	/*
[66765]	2382	* Look for existing shared object, create a new one if necessary.
[66735]	2383	*/
[68694]	2384	PRTFSISOFILESHRD pShared = (PRTFSISOFILESHRD)rtFsIsoDir_LookupShared(pParentDir, offDirRec);
[69048]	2385	if (pShared)
[66765]	2386	{
[69048]	2387	LogFlow(("rtFsIsoFile_New9660: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n",
	2388	pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent));
	2389	pNewFile->offFile = 0;
	2390	pNewFile->pShared = pShared;
	2391	return VINF_SUCCESS;
	2392	}
	2393
	2394	pShared = (PRTFSISOFILESHRD)RTMemAllocZ(sizeof(*pShared));
	2395	if (pShared)
	2396	{
[94280]	2397	rc = rtFsIsoCore_InitFrom9660DirRec(&pShared->Core, pDirRec, cDirRecs, offDirRec, uVersion, pRockInfo, pThis);
[69048]	2398	if (RT_SUCCESS(rc))
	2399	{
	2400	rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core);
	2401	LogFlow(("rtFsIsoFile_New9660: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n",
	2402	pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent));
	2403	pNewFile->offFile = 0;
	2404	pNewFile->pShared = pShared;
	2405	return VINF_SUCCESS;
	2406	}
	2407	RTMemFree(pShared);
	2408	}
	2409	else
	2410	rc = VERR_NO_MEMORY;
	2411
	2412	/* Destroy the file object. */
	2413	pNewFile->offFile = 0;
	2414	pNewFile->pShared = NULL;
	2415	RTVfsFileRelease(*phVfsFile);
	2416	}
	2417	*phVfsFile = NIL_RTVFSFILE;
	2418	return rc;
	2419	}
	2420
	2421
	2422	/**
	2423	* Instantiates a new file, from UDF info.
	2424	*
	2425	* @returns IPRT status code.
[69924]	2426	* @param pThis The ISO volume instance.
[69048]	2427	* @param pParentDir The parent directory (shared part).
	2428	* @param pFid The file ID descriptor. (Points to parent directory
	2429	* content.)
	2430	* @param fOpen RTFILE_O_XXX flags.
	2431	* @param phVfsFile Where to return the file handle.
	2432	*/
	2433	static int rtFsIsoFile_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid,
	2434	uint64_t fOpen, PRTVFSFILE phVfsFile)
	2435	{
	2436	AssertPtr(pParentDir);
	2437	uintptr_t const offInDir = (uintptr_t)pFid - (uintptr_t)pParentDir->pbDir;
	2438	Assert(offInDir < pParentDir->cbDir);
	2439	Assert(!(pFid->fFlags & UDF_FILE_FLAGS_DELETED));
	2440	Assert(!(pFid->fFlags & UDF_FILE_FLAGS_DIRECTORY));
	2441
	2442	/*
	2443	* Create a VFS object.
	2444	*/
	2445	PRTFSISOFILEOBJ pNewFile;
	2446	int rc = RTVfsNewFile(&g_rtFsIsoFileOps, sizeof(pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK /use volume lock*/,
	2447	phVfsFile, (void **)&pNewFile);
	2448	if (RT_SUCCESS(rc))
	2449	{
	2450	/*
	2451	* Look for existing shared object. Make sure it's a file.
	2452	*/
	2453	PRTFSISOFILESHRD pShared = (PRTFSISOFILESHRD)rtFsIsoDir_LookupShared(pParentDir, offInDir);
	2454	if (pShared)
	2455	{
	2456	if (!RTFS_IS_FILE(pShared->Core.fAttrib))
	2457	{
	2458	LogFlow(("rtFsIsoFile_NewUdf: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n",
	2459	pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent));
	2460	pNewFile->offFile = 0;
	2461	pNewFile->pShared = pShared;
	2462	return VINF_SUCCESS;
	2463	}
	2464	}
	2465	/*
	2466	* Create a shared object for this alleged file.
	2467	*/
	2468	else
	2469	{
[68694]	2470	pShared = (PRTFSISOFILESHRD)RTMemAllocZ(sizeof(*pShared));
[66765]	2471	if (pShared)
	2472	{
[69048]	2473	rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&pShared->Core, &pFid->Icb, pFid, offInDir, pThis);
[67568]	2474	if (RT_SUCCESS(rc))
	2475	{
[69048]	2476	if (RTFS_IS_FILE(pShared->Core.fAttrib))
	2477	{
	2478	rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core);
	2479
	2480	LogFlow(("rtFsIsoFile_NewUdf: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n",
	2481	pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent));
	2482	pNewFile->offFile = 0;
	2483	pNewFile->pShared = pShared;
	2484	return VINF_SUCCESS;
	2485	}
	2486	rtFsIsoCore_Destroy(&pShared->Core);
[67568]	2487	}
[69048]	2488	RTMemFree(pShared);
[66765]	2489	}
[69048]	2490	else
	2491	rc = VERR_NO_MEMORY;
[66765]	2492	}
[66735]	2493
[69048]	2494	/* Destroy the file object. */
	2495	pNewFile->offFile = 0;
	2496	pNewFile->pShared = NULL;
	2497	RTVfsFileRelease(*phVfsFile);
[66735]	2498	}
	2499	*phVfsFile = NIL_RTVFSFILE;
	2500	return rc;
	2501	}
	2502
	2503
	2504	/**
[66765]	2505	* Looks up the shared structure for a child.
	2506	*
	2507	* @returns Referenced pointer to the shared structure, NULL if not found.
	2508	* @param pThis The directory.
	2509	* @param offDirRec The directory record offset of the child.
	2510	*/
[68694]	2511	static PRTFSISOCORE rtFsIsoDir_LookupShared(PRTFSISODIRSHRD pThis, uint64_t offDirRec)
[66765]	2512	{
[68694]	2513	PRTFSISOCORE pCur;
	2514	RTListForEach(&pThis->OpenChildren, pCur, RTFSISOCORE, Entry)
[66765]	2515	{
	2516	if (pCur->offDirRec == offDirRec)
	2517	{
	2518	uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs);
[66767]	2519	Assert(cRefs > 1); RT_NOREF(cRefs);
[66765]	2520	return pCur;
	2521	}
	2522	}
	2523	return NULL;
	2524	}
[66735]	2525
[66765]	2526
[67569]	2527	#ifdef RT_STRICT
[66735]	2528	/**
[67568]	2529	* Checks if @a pNext is an extent of @a pFirst.
	2530	*
	2531	* @returns true if @a pNext is the next extent, false if not
	2532	* @param pFirst The directory record describing the first or the
	2533	* previous extent.
	2534	* @param pNext The directory record alleged to be the next extent.
	2535	*/
[68694]	2536	DECLINLINE(bool) rtFsIsoDir_Is9660DirRecNextExtent(PCISO9660DIRREC pFirst, PCISO9660DIRREC pNext)
[67568]	2537	{
	2538	if (RT_LIKELY(pNext->bFileIdLength == pFirst->bFileIdLength))
	2539	{
	2540	if (RT_LIKELY((pNext->fFileFlags \| ISO9660_FILE_FLAGS_MULTI_EXTENT) == pFirst->fFileFlags))
	2541	{
	2542	if (RT_LIKELY(memcmp(pNext->achFileId, pFirst->achFileId, pNext->bFileIdLength) == 0))
	2543	return true;
	2544	}
	2545	}
	2546	return false;
	2547	}
[67569]	2548	#endif /* RT_STRICT */
[67568]	2549
	2550
	2551	/**
[94280]	2552	* Parses rock ridge information if present in the directory entry.
	2553	*
	2554	* @param pVol The volume structure.
	2555	* @param pParseInfo Parse info and output.
	2556	* @param pbSys The system area of the directory record.
	2557	* @param cbSys The number of bytes present in the sys area.
	2558	* @param fIsFirstDirRec Set if this is the '.' directory entry in the
	2559	* root directory. (Some entries applies only to
	2560	* it.)
	2561	* @param fContinuationRecord Set if we're processing a continuation record in
	2562	* living in the abRockBuf.
	2563	*/
	2564	static void rtFsIsoDirShrd_ParseRockRidgeData(PRTFSISOVOL pVol, PRTFSISOROCKINFO pParseInfo, uint8_t const *pbSys,
	2565	size_t cbSys, bool fIsFirstDirRec, bool fContinuationRecord)
	2566	{
	2567	while (cbSys >= 4)
	2568	{
	2569	/*
	2570	* Check header length and advance the sys variables.
	2571	*/
	2572	PCISO9660SUSPUNION pUnion = (PCISO9660SUSPUNION)pbSys;
	2573	if ( pUnion->Hdr.cbEntry > cbSys
	2574	\|\| pUnion->Hdr.cbEntry < sizeof(pUnion->Hdr))
	2575	{
	2576	Log4(("rtFsIsoDir_ParseRockRidgeData: cbEntry=%#x cbSys=%#x (%#x %#x)\n",
	2577	pUnion->Hdr.cbEntry, cbSys, pUnion->Hdr.bSig1, pUnion->Hdr.bSig2));
	2578	break;
	2579	}
	2580	pbSys += pUnion->Hdr.cbEntry;
	2581	cbSys -= pUnion->Hdr.cbEntry;
	2582
	2583	/*
	2584	* Process fields.
	2585	*/
	2586	uint16_t const uSig = SUSP_MAKE_SIG(pUnion->Hdr.bSig1, pUnion->Hdr.bSig2);
	2587	switch (uSig)
	2588	{
	2589	/*
	2590	* System use sharing protocol entries.
	2591	*/
	2592	case SUSP_MAKE_SIG(ISO9660SUSPCE_SIG1, ISO9660SUSPCE_SIG2):
	2593	{
	2594	if (RT_BE2H_U32(pUnion->CE.offBlock.be) != RT_LE2H_U32(pUnion->CE.offBlock.le))
	2595	Log4(("rtFsIsoDir_ParseRockRidgeData: Invalid CE offBlock field: be=%#x vs le=%#x\n",
	2596	RT_BE2H_U32(pUnion->CE.offBlock.be), RT_LE2H_U32(pUnion->CE.offBlock.le)));
	2597	else if (RT_BE2H_U32(pUnion->CE.cbData.be) != RT_LE2H_U32(pUnion->CE.cbData.le))
	2598	Log4(("rtFsIsoDir_ParseRockRidgeData: Invalid CE cbData field: be=%#x vs le=%#x\n",
	2599	RT_BE2H_U32(pUnion->CE.cbData.be), RT_LE2H_U32(pUnion->CE.cbData.le)));
	2600	else if (RT_BE2H_U32(pUnion->CE.offData.be) != RT_LE2H_U32(pUnion->CE.offData.le))
	2601	Log4(("rtFsIsoDir_ParseRockRidgeData: Invalid CE offData field: be=%#x vs le=%#x\n",
	2602	RT_BE2H_U32(pUnion->CE.offData.be), RT_LE2H_U32(pUnion->CE.offData.le)));
	2603	else if (!fContinuationRecord)
	2604	{
	2605	uint64_t offData = ISO9660_GET_ENDIAN(&pUnion->CE.offBlock) * (uint64_t)ISO9660_SECTOR_SIZE;
	2606	offData += ISO9660_GET_ENDIAN(&pUnion->CE.offData);
	2607	uint32_t cbData = ISO9660_GET_ENDIAN(&pUnion->CE.cbData);
	2608	if (cbData <= sizeof(pVol->abRockBuf) - (uint32_t)(offData & ISO9660_SECTOR_OFFSET_MASK))
	2609	{
	2610	RTCritSectEnter(&pVol->RockBufLock);
	2611
	2612	AssertCompile(sizeof(pVol->abRockBuf) == ISO9660_SECTOR_SIZE);
	2613	uint64_t offDataBlock = offData & ~(uint64_t)ISO9660_SECTOR_OFFSET_MASK;
	2614	if (pVol->offRockBuf == offDataBlock)
	2615	rtFsIsoDirShrd_ParseRockRidgeData(pVol, pParseInfo,
	2616	&pVol->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK],
	2617	cbData, fIsFirstDirRec, true /fContinuationRecord/);
	2618	else
	2619	{
	2620	int rc = RTVfsFileReadAt(pVol->hVfsBacking, offDataBlock,
	2621	pVol->abRockBuf, sizeof(pVol->abRockBuf), NULL);
	2622	if (RT_SUCCESS(rc))
	2623	rtFsIsoDirShrd_ParseRockRidgeData(pVol, pParseInfo,
	2624	&pVol->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK],
	2625	cbData, fIsFirstDirRec, true /fContinuationRecord/);
	2626	else
	2627	Log4(("rtFsIsoDir_ParseRockRidgeData: Error reading continuation record at %#RX64: %Rrc\n",
	2628	offDataBlock, rc));
	2629	}
	2630
	2631	RTCritSectLeave(&pVol->RockBufLock);
	2632	}
	2633	else
	2634	Log4(("rtFsIsoDir_ParseRockRidgeData: continuation record isn't within a sector! offData=%#RX64 cbData=%#RX32\n",
	2635	cbData, offData));
	2636	}
	2637	else
	2638	Log4(("rtFsIsoDir_ParseRockRidgeData: nested continuation record!\n"));
	2639	break;
	2640	}
	2641
	2642	case SUSP_MAKE_SIG(ISO9660SUSPSP_SIG1, ISO9660SUSPSP_SIG2): /* SP */
	2643	if ( pUnion->Hdr.cbEntry != ISO9660SUSPSP_LEN
	2644	\|\| pUnion->Hdr.bVersion != ISO9660SUSPSP_VER
	2645	\|\| pUnion->SP.bCheck1 != ISO9660SUSPSP_CHECK1
	2646	\|\| pUnion->SP.bCheck2 != ISO9660SUSPSP_CHECK2
	2647	\|\| pUnion->SP.cbSkip > UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]))
	2648	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SP' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x), bCheck1=%#x (vs %#x), bCheck2=%#x (vs %#x), cbSkip=%#x (vs max %#x)\n",
	2649	pUnion->Hdr.cbEntry, ISO9660SUSPSP_LEN, pUnion->Hdr.bVersion, ISO9660SUSPSP_VER,
	2650	pUnion->SP.bCheck1, ISO9660SUSPSP_CHECK1, pUnion->SP.bCheck2, ISO9660SUSPSP_CHECK2,
	2651	pUnion->SP.cbSkip, UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]) ));
	2652	else if (!fIsFirstDirRec)
	2653	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignorining 'SP' entry in non-root directory record\n"));
	2654	else if (pParseInfo->fSuspSeenSP)
	2655	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignorining additional 'SP' entry\n"));
	2656	else
	2657	{
	2658	pVol->offSuspSkip = pUnion->SP.cbSkip;
	2659	if (pUnion->SP.cbSkip != 0)
	2660	Log4(("rtFsIsoDir_ParseRockRidgeData: SP: cbSkip=%#x\n", pUnion->SP.cbSkip));
	2661	}
	2662	break;
	2663
	2664	case SUSP_MAKE_SIG(ISO9660SUSPER_SIG1, ISO9660SUSPER_SIG2): /* ER */
	2665	if ( pUnion->Hdr.cbEntry > RT_UOFFSETOF(ISO9660SUSPER, achPayload) + (uint32_t)pUnion->ER.cchIdentifier
	2666	+ (uint32_t)pUnion->ER.cchDescription + (uint32_t)pUnion->ER.cchSource
	2667	\|\| pUnion->Hdr.bVersion != ISO9660SUSPER_VER)
	2668	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'ER' entry: cbEntry=%#x bVersion=%#x (vs %#x) cchIdentifier=%#x cchDescription=%#x cchSource=%#x\n",
	2669	pUnion->Hdr.cbEntry, pUnion->Hdr.bVersion, ISO9660SUSPER_VER, pUnion->ER.cchIdentifier,
	2670	pUnion->ER.cchDescription, pUnion->ER.cchSource));
	2671	else if (!fIsFirstDirRec)
	2672	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignorining 'ER' entry in non-root directory record\n"));
	2673	else if ( pUnion->ER.bVersion == 1 /* RRIP detection */
	2674	&& ( (pUnion->ER.cchIdentifier >= 4 && strncmp(pUnion->ER.achPayload, ISO9660_RRIP_ID, 4 /RRIP/) == 0)
	2675	\|\| (pUnion->ER.cchIdentifier >= 10 && strncmp(pUnion->ER.achPayload, RT_STR_TUPLE(ISO9660_RRIP_1_12_ID)) == 0) ))
	2676	{
	2677	Log4(("rtFsIsoDir_ParseRockRidgeData: Rock Ridge 'ER' entry: v%u id='%.s' desc='%.s' source='%.*s'\n",
	2678	pUnion->ER.bVersion, pUnion->ER.cchIdentifier, pUnion->ER.achPayload,
	2679	pUnion->ER.cchDescription, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier],
	2680	pUnion->ER.cchSource, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier + pUnion->ER.cchDescription]));
	2681	pVol->fHaveRock = true;
	2682	pParseInfo->cRockEntries++;
	2683	}
	2684	else
	2685	Log4(("rtFsIsoDir_ParseRockRidgeData: Unknown extension in 'ER' entry: v%u id='%.s' desc='%.s' source='%.*s'\n",
	2686	pUnion->ER.bVersion, pUnion->ER.cchIdentifier, pUnion->ER.achPayload,
	2687	pUnion->ER.cchDescription, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier],
	2688	pUnion->ER.cchSource, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier + pUnion->ER.cchDescription]));
	2689	break;
	2690
	2691	case SUSP_MAKE_SIG(ISO9660SUSPPD_SIG1, ISO9660SUSPPD_SIG2): /* PD - ignored */
	2692	case SUSP_MAKE_SIG(ISO9660SUSPST_SIG1, ISO9660SUSPST_SIG2): /* ST - ignore for now */
	2693	case SUSP_MAKE_SIG(ISO9660SUSPES_SIG1, ISO9660SUSPES_SIG2): /* ES - ignore for now */
	2694	break;
	2695
	2696	/*
	2697	* Rock ridge interchange protocol entries.
	2698	*/
	2699	case SUSP_MAKE_SIG(ISO9660RRIPRR_SIG1, ISO9660RRIPRR_SIG2): /* RR */
	2700	if ( pUnion->RR.Hdr.cbEntry != ISO9660RRIPRR_LEN
	2701	\|\| pUnion->RR.Hdr.bVersion != ISO9660RRIPRR_VER)
	2702	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'RR' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x\n",
	2703	pUnion->RR.Hdr.cbEntry, ISO9660RRIPRR_LEN, pUnion->RR.Hdr.bVersion, ISO9660RRIPRR_VER, pUnion->RR.fFlags));
	2704	else
	2705	pParseInfo->cRockEntries++; /* otherwise ignored */
	2706	break;
	2707
	2708	case SUSP_MAKE_SIG(ISO9660RRIPPX_SIG1, ISO9660RRIPPX_SIG2): /* PX */
	2709	if ( ( pUnion->PX.Hdr.cbEntry != ISO9660RRIPPX_LEN
	2710	&& pUnion->PX.Hdr.cbEntry != ISO9660RRIPPX_LEN_NO_INODE)
	2711	\|\| pUnion->PX.Hdr.bVersion != ISO9660RRIPPX_VER
	2712	\|\| RT_BE2H_U32(pUnion->PX.fMode.be) != RT_LE2H_U32(pUnion->PX.fMode.le)
	2713	\|\| RT_BE2H_U32(pUnion->PX.cHardlinks.be) != RT_LE2H_U32(pUnion->PX.cHardlinks.le)
	2714	\|\| RT_BE2H_U32(pUnion->PX.uid.be) != RT_LE2H_U32(pUnion->PX.uid.le)
	2715	\|\| RT_BE2H_U32(pUnion->PX.gid.be) != RT_LE2H_U32(pUnion->PX.gid.le)
	2716	\|\| ( pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN
	2717	&& RT_BE2H_U32(pUnion->PX.INode.be) != RT_LE2H_U32(pUnion->PX.INode.le)) )
	2718	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'PX' entry: cbEntry=%#x (vs %#x or %#x), bVersion=%#x (vs %#x) fMode=%#x/%#x cHardlinks=%#x/%#x uid=%#x/%#x gid=%#x/%#x inode=%#x/%#x\n",
	2719	pUnion->PX.Hdr.cbEntry, ISO9660RRIPPX_LEN, ISO9660RRIPPX_LEN_NO_INODE,
	2720	pUnion->PX.Hdr.bVersion, ISO9660RRIPPX_VER,
	2721	RT_BE2H_U32(pUnion->PX.fMode.be), RT_LE2H_U32(pUnion->PX.fMode.le),
	2722	RT_BE2H_U32(pUnion->PX.cHardlinks.be), RT_LE2H_U32(pUnion->PX.cHardlinks.le),
	2723	RT_BE2H_U32(pUnion->PX.uid.be), RT_LE2H_U32(pUnion->PX.uid.le),
	2724	RT_BE2H_U32(pUnion->PX.gid.be), RT_LE2H_U32(pUnion->PX.gid.le),
	2725	pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN ? RT_BE2H_U32(pUnion->PX.INode.be) : 0,
	2726	pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN ? RT_LE2H_U32(pUnion->PX.INode.le) : 0 ));
	2727	else
	2728	{
	2729	if ( RTFS_IS_DIRECTORY(ISO9660_GET_ENDIAN(&pUnion->PX.fMode))
	2730	== RTFS_IS_DIRECTORY(pParseInfo->Info.Attr.fMode))
	2731	pParseInfo->Info.Attr.fMode = ISO9660_GET_ENDIAN(&pUnion->PX.fMode);
	2732	else
	2733	Log4(("rtFsIsoDir_ParseRockRidgeData: 'PX' entry changes directory-ness: fMode=%#x, existing %#x; ignored\n",
	2734	ISO9660_GET_ENDIAN(&pUnion->PX.fMode), pParseInfo->Info.Attr.fMode));
	2735	pParseInfo->Info.Attr.u.Unix.cHardlinks = ISO9660_GET_ENDIAN(&pUnion->PX.cHardlinks);
	2736	pParseInfo->Info.Attr.u.Unix.uid = ISO9660_GET_ENDIAN(&pUnion->PX.uid);
	2737	pParseInfo->Info.Attr.u.Unix.gid = ISO9660_GET_ENDIAN(&pUnion->PX.gid);
	2738	/* ignore inode */
	2739	pParseInfo->cRockEntries++;
	2740	}
	2741	break;
	2742
	2743	case SUSP_MAKE_SIG(ISO9660RRIPPN_SIG1, ISO9660RRIPPN_SIG2): /* PN */
	2744	if ( pUnion->PN.Hdr.cbEntry != ISO9660RRIPPN_LEN
	2745	\|\| pUnion->PN.Hdr.bVersion != ISO9660RRIPPN_VER
	2746	\|\| RT_BE2H_U32(pUnion->PN.Major.be) != RT_LE2H_U32(pUnion->PN.Major.le)
	2747	\|\| RT_BE2H_U32(pUnion->PN.Minor.be) != RT_LE2H_U32(pUnion->PN.Minor.le))
	2748	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'PN' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) Major=%#x/%#x Minor=%#x/%#x\n",
	2749	pUnion->PN.Hdr.cbEntry, ISO9660RRIPPN_LEN, pUnion->PN.Hdr.bVersion, ISO9660RRIPPN_VER,
	2750	RT_BE2H_U32(pUnion->PN.Major.be), RT_LE2H_U32(pUnion->PN.Major.le),
	2751	RT_BE2H_U32(pUnion->PN.Minor.be), RT_LE2H_U32(pUnion->PN.Minor.le) ));
	2752	else if (RTFS_IS_DIRECTORY(pParseInfo->Info.Attr.fMode))
	2753	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignorning 'PN' entry for directory (%#x/%#x)\n",
	2754	ISO9660_GET_ENDIAN(&pUnion->PN.Major), ISO9660_GET_ENDIAN(&pUnion->PN.Minor) ));
	2755	else
	2756	{
	2757	pParseInfo->Info.Attr.u.Unix.Device = RTDEV_MAKE(ISO9660_GET_ENDIAN(&pUnion->PN.Major),
	2758	ISO9660_GET_ENDIAN(&pUnion->PN.Minor));
	2759	pParseInfo->cRockEntries++;
	2760	}
	2761	break;
	2762
	2763	case SUSP_MAKE_SIG(ISO9660RRIPTF_SIG1, ISO9660RRIPTF_SIG2): /* TF */
	2764	if ( pUnion->TF.Hdr.bVersion != ISO9660RRIPTF_VER
	2765	\|\| pUnion->TF.Hdr.cbEntry < Iso9660RripTfCalcLength(pUnion->TF.fFlags))
	2766	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'TF' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x\n",
	2767	pUnion->TF.Hdr.cbEntry, Iso9660RripTfCalcLength(pUnion->TF.fFlags),
	2768	pUnion->TF.Hdr.bVersion, ISO9660RRIPTF_VER, RT_BE2H_U32(pUnion->TF.fFlags) ));
	2769	else if (!(pUnion->TF.fFlags & ISO9660RRIPTF_F_LONG_FORM))
	2770	{
	2771	PCISO9660RECTIMESTAMP pTimestamp = (PCISO9660RECTIMESTAMP)&pUnion->TF.abPayload[0];
	2772	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_BIRTH)
	2773	{
	2774	rtFsIso9660DateTime2TimeSpec(&pParseInfo->Info.BirthTime, pTimestamp);
	2775	pTimestamp++;
	2776	}
	2777	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_MODIFY)
	2778	{
	2779	rtFsIso9660DateTime2TimeSpec(&pParseInfo->Info.ModificationTime, pTimestamp);
	2780	pTimestamp++;
	2781	}
	2782	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_ACCESS)
	2783	{
	2784	rtFsIso9660DateTime2TimeSpec(&pParseInfo->Info.AccessTime, pTimestamp);
	2785	pTimestamp++;
	2786	}
	2787	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_CHANGE)
	2788	{
	2789	rtFsIso9660DateTime2TimeSpec(&pParseInfo->Info.ChangeTime, pTimestamp);
	2790	pTimestamp++;
	2791	}
	2792	pParseInfo->cRockEntries++;
	2793	}
	2794	else
	2795	{
	2796	PCISO9660TIMESTAMP pTimestamp = (PCISO9660TIMESTAMP)&pUnion->TF.abPayload[0];
	2797	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_BIRTH)
	2798	{
	2799	rtFsIso9660DateTime2TimeSpecIfValid(&pParseInfo->Info.BirthTime, pTimestamp);
	2800	pTimestamp++;
	2801	}
	2802	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_MODIFY)
	2803	{
	2804	rtFsIso9660DateTime2TimeSpecIfValid(&pParseInfo->Info.ModificationTime, pTimestamp);
	2805	pTimestamp++;
	2806	}
	2807	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_ACCESS)
	2808	{
	2809	rtFsIso9660DateTime2TimeSpecIfValid(&pParseInfo->Info.AccessTime, pTimestamp);
	2810	pTimestamp++;
	2811	}
	2812	if (pUnion->TF.fFlags & ISO9660RRIPTF_F_CHANGE)
	2813	{
	2814	rtFsIso9660DateTime2TimeSpecIfValid(&pParseInfo->Info.ChangeTime, pTimestamp);
	2815	pTimestamp++;
	2816	}
	2817	pParseInfo->cRockEntries++;
	2818	}
	2819	break;
	2820
	2821	case SUSP_MAKE_SIG(ISO9660RRIPSF_SIG1, ISO9660RRIPSF_SIG2): /* SF */
	2822	Log4(("rtFsIsoDir_ParseRockRidgeData: Sparse file support not yet implemented!\n"));
	2823	break;
	2824
	2825	case SUSP_MAKE_SIG(ISO9660RRIPSL_SIG1, ISO9660RRIPSL_SIG2): /* SL */
	2826	if ( pUnion->SL.Hdr.bVersion != ISO9660RRIPSL_VER
	2827	\|\| pUnion->SL.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2])
	2828	\|\| (pUnion->SL.fFlags & ~ISO9660RRIP_SL_F_CONTINUE)
	2829	\|\| (pUnion->SL.abComponents[0] & ISO9660RRIP_SL_C_RESERVED_MASK) )
	2830	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x comp[0].fFlags=%#x\n",
	2831	pUnion->SL.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2]),
	2832	pUnion->SL.Hdr.bVersion, ISO9660RRIPSL_VER, pUnion->SL.fFlags, pUnion->SL.abComponents[0]));
	2833	else if (pParseInfo->fSeenLastSL)
	2834	Log4(("rtFsIsoDir_ParseRockRidgeData: Unexpected 'SL!' entry\n"));
	2835	else
	2836	{
	2837	pParseInfo->cRockEntries++;
	2838	pParseInfo->fSeenLastSL = !(pUnion->SL.fFlags & ISO9660RRIP_SL_F_CONTINUE); /* used in loop */
	2839
	2840	size_t offDst = pParseInfo->cchLinkTarget;
	2841	uint8_t const *pbSrc = &pUnion->SL.abComponents[0];
	2842	uint8_t cbSrcLeft = pUnion->SL.Hdr.cbEntry - RT_UOFFSETOF(ISO9660RRIPSL, abComponents);
	2843	while (cbSrcLeft >= 2)
	2844	{
	2845	uint8_t const fFlags = pbSrc[0];
	2846	uint8_t cchCopy = pbSrc[1];
	2847	uint8_t const cbSkip = cchCopy + 2;
	2848	if (cbSkip > cbSrcLeft)
	2849	{
	2850	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' component: component flags=%#x, component length+2=%#x vs %#x left\n",
	2851	fFlags, cbSkip, cbSrcLeft));
	2852	break;
	2853	}
	2854
	2855	const char *pszCopy;
	2856	switch (fFlags & ~ISO9660RRIP_SL_C_CONTINUE)
	2857	{
	2858	case 0:
	2859	pszCopy = (const char *)&pbSrc[2];
	2860	break;
	2861
	2862	case ISO9660RRIP_SL_C_CURRENT:
	2863	if (cchCopy != 0)
	2864	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' component: CURRENT + %u bytes, ignoring bytes\n", cchCopy));
	2865	pszCopy = ".";
	2866	cchCopy = 1;
	2867	break;
	2868
	2869	case ISO9660RRIP_SL_C_PARENT:
	2870	if (cchCopy != 0)
	2871	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' component: PARENT + %u bytes, ignoring bytes\n", cchCopy));
	2872	pszCopy = "..";
	2873	cchCopy = 2;
	2874	break;
	2875
	2876	case ISO9660RRIP_SL_C_ROOT:
	2877	if (cchCopy != 0)
	2878	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' component: ROOT + %u bytes, ignoring bytes\n", cchCopy));
	2879	pszCopy = "/";
	2880	cchCopy = 1;
	2881	break;
	2882
	2883	default:
	2884	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'SL' component: component flags=%#x (bad), component length=%#x vs %#x left\n",
	2885	fFlags, cchCopy, cbSrcLeft));
	2886	pszCopy = NULL;
	2887	cchCopy = 0;
	2888	break;
	2889	}
	2890
	2891	if (offDst + cchCopy < sizeof(pParseInfo->szLinkTarget))
	2892	{
	2893	memcpy(&pParseInfo->szLinkTarget[offDst], pszCopy, cchCopy);
	2894	offDst += cchCopy;
	2895	}
	2896	else
	2897	{
	2898	Log4(("rtFsIsoDir_ParseRockRidgeData: 'SL' constructs a too long target! '%.s%.s'\n",
	2899	offDst, pParseInfo->szLinkTarget, cchCopy, pszCopy));
	2900	memcpy(&pParseInfo->szLinkTarget[offDst], pszCopy, sizeof(pParseInfo->szLinkTarget) - offDst - 1);
	2901	offDst = sizeof(pParseInfo->szLinkTarget) - 1;
	2902	pParseInfo->fOverflowSL = true;
	2903	break;
	2904	}
	2905
	2906	/* Advance */
	2907	pbSrc += cbSkip;
	2908	cbSrcLeft -= cbSkip;
	2909
	2910	/* Append slash if appropriate. */
	2911	if ( !(fFlags & ISO9660RRIP_SL_C_CONTINUE)
	2912	&& (cbSrcLeft >= 2 \|\| !pParseInfo->fSeenLastSL) )
	2913	{
	2914	if (offDst + 1 < sizeof(pParseInfo->szLinkTarget))
	2915	pParseInfo->szLinkTarget[offDst++] = '/';
	2916	else
	2917	{
	2918	Log4(("rtFsIsoDir_ParseRockRidgeData: 'SL' constructs a too long target! '%.*s/'\n",
	2919	offDst, pParseInfo->szLinkTarget));
	2920	pParseInfo->fOverflowSL = true;
	2921	break;
	2922	}
	2923	}
	2924	}
	2925	Assert(offDst < sizeof(pParseInfo->szLinkTarget));
	2926	pParseInfo->szLinkTarget[offDst] = '\0';
[94282]	2927	pParseInfo->cchLinkTarget = (uint16_t)offDst;
[94280]	2928	}
	2929	break;
	2930
	2931	case SUSP_MAKE_SIG(ISO9660RRIPNM_SIG1, ISO9660RRIPNM_SIG2): /* NM */
	2932	if ( pUnion->NM.Hdr.bVersion != ISO9660RRIPNM_VER
	2933	\|\| pUnion->NM.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPNM, achName)
	2934	\|\| (pUnion->NM.fFlags & ISO9660RRIP_NM_F_RESERVED_MASK) )
	2935	Log4(("rtFsIsoDir_ParseRockRidgeData: Malformed 'NM' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x %.*Rhxs\n",
	2936	pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName),
	2937	pUnion->NM.Hdr.bVersion, ISO9660RRIPNM_VER, pUnion->NM.fFlags,
	2938	pUnion->NM.Hdr.cbEntry - RT_MIN(pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName)),
	2939	&pUnion->NM.achName[0] ));
	2940	else if (pParseInfo->fSeenLastNM)
	2941	Log4(("rtFsIsoDir_ParseRockRidgeData: Unexpected 'NM' entry!\n"));
	2942	else
	2943	{
	2944	pParseInfo->cRockEntries++;
	2945	pParseInfo->fSeenLastNM = !(pUnion->NM.fFlags & ISO9660RRIP_NM_F_CONTINUE);
	2946
	2947	uint8_t const cchName = pUnion->NM.Hdr.cbEntry - (uint8_t)RT_UOFFSETOF(ISO9660RRIPNM, achName);
	2948	if (pUnion->NM.fFlags & (ISO9660RRIP_NM_F_CURRENT \| ISO9660RRIP_NM_F_PARENT))
	2949	{
	2950	if (cchName == 0 && pParseInfo->szName[0] == '\0')
	2951	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignoring 'NM' entry for '.' and '..'\n"));
	2952	else
	2953	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignoring malformed 'NM' using '.' or '..': fFlags=%#x cchName=%#x %.*Rhxs; szRockNameBuf='%s'\n",
	2954	pUnion->NM.fFlags, cchName, cchName, pUnion->NM.achName, pParseInfo->szName));
	2955	pParseInfo->szName[0] = '\0';
	2956	pParseInfo->cchName = 0;
	2957	pParseInfo->fSeenLastNM = true;
	2958	}
	2959	else
	2960	{
	2961	size_t offDst = pParseInfo->cchName;
	2962	if (offDst + cchName < sizeof(pParseInfo->szName))
	2963	{
	2964	memcpy(&pParseInfo->szName[offDst], pUnion->NM.achName, cchName);
	2965	offDst += cchName;
	2966	pParseInfo->szName[offDst] = '\0';
	2967	pParseInfo->cchName = (uint16_t)offDst;
	2968	}
	2969	else
	2970	{
	2971	Log4(("rtFsIsoDir_ParseRockRidgeData: 'NM' constructs a too long name, ignoring it all: '%s%.*s'\n",
	2972	pParseInfo->szName, cchName, pUnion->NM.achName));
	2973	pParseInfo->szName[0] = '\0';
	2974	pParseInfo->cchName = 0;
	2975	pParseInfo->fSeenLastNM = true;
	2976	}
	2977	}
	2978	}
	2979	break;
	2980
	2981	case SUSP_MAKE_SIG(ISO9660RRIPCL_SIG1, ISO9660RRIPCL_SIG2): /* CL - just warn for now. */
	2982	case SUSP_MAKE_SIG(ISO9660RRIPPL_SIG1, ISO9660RRIPPL_SIG2): /* PL - just warn for now. */
	2983	case SUSP_MAKE_SIG(ISO9660RRIPRE_SIG1, ISO9660RRIPRE_SIG2): /* RE - just warn for now. */
	2984	Log4(("rtFsIsoDir_ParseRockRidgeData: Ignorning directory relocation entry '%c%c'!\n", pUnion->Hdr.bSig1, pUnion->Hdr.bSig2));
	2985	break;
	2986
	2987	default:
	2988	Log4(("rtFsIsoDir_ParseRockRidgeData: Unknown SUSP entry: %#x %#x, %#x bytes, v%u\n",
	2989	pUnion->Hdr.bSig1, pUnion->Hdr.bSig2, pUnion->Hdr.cbEntry, pUnion->Hdr.bVersion));
	2990	break;
	2991	}
	2992	}
	2993
	2994	/*
	2995	* Set the valid flag if we found anything of interest.
	2996	*/
	2997	if (pParseInfo->cRockEntries > 1)
	2998	pParseInfo->fValid = true;
	2999	}
	3000
	3001
	3002	/**
	3003	* Initializes the rock info structure with info from the standard ISO-9660
	3004	* directory record.
	3005	*
	3006	* @param pRockInfo The structure to initialize.
	3007	* @param pDirRec The directory record to take basic data from.
	3008	*/
	3009	static void rtFsIsoDirShrd_InitRockInfo(PRTFSISOROCKINFO pRockInfo, PCISO9660DIRREC pDirRec)
	3010	{
	3011	pRockInfo->fValid = false;
	3012	pRockInfo->fSuspSeenSP = false;
	3013	pRockInfo->fSeenLastNM = false;
	3014	pRockInfo->fSeenLastSL = false;
	3015	pRockInfo->fOverflowSL = false;
	3016	pRockInfo->cRockEntries = 0;
	3017	pRockInfo->cchName = 0;
	3018	pRockInfo->cchLinkTarget = 0;
	3019	pRockInfo->szName[0] = '\0';
	3020	pRockInfo->szName[sizeof(pRockInfo->szName) - 1] = '\0';
	3021	pRockInfo->szLinkTarget[0] = '\0';
	3022	pRockInfo->szLinkTarget[sizeof(pRockInfo->szLinkTarget) - 1] = '\0';
	3023	pRockInfo->Info.cbObject = ISO9660_GET_ENDIAN(&pDirRec->cbData);
	3024	pRockInfo->Info.cbAllocated = pRockInfo->Info.cbObject;
	3025	rtFsIso9660DateTime2TimeSpec(&pRockInfo->Info.AccessTime, &pDirRec->RecTime);
	3026	pRockInfo->Info.ModificationTime = pRockInfo->Info.AccessTime;
	3027	pRockInfo->Info.ChangeTime = pRockInfo->Info.AccessTime;
	3028	pRockInfo->Info.BirthTime = pRockInfo->Info.AccessTime;
	3029	pRockInfo->Info.Attr.fMode = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY
	3030	? RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY \| 0555
	3031	: RTFS_TYPE_FILE \| RTFS_DOS_ARCHIVED \| 0444;
	3032	if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_HIDDEN)
	3033	pRockInfo->Info.Attr.fMode \|= RTFS_DOS_HIDDEN;
	3034	pRockInfo->Info.Attr.enmAdditional = RTFSOBJATTRADD_UNIX;
	3035	pRockInfo->Info.Attr.u.Unix.uid = NIL_RTUID;
	3036	pRockInfo->Info.Attr.u.Unix.gid = NIL_RTGID;
	3037	pRockInfo->Info.Attr.u.Unix.cHardlinks = 1;
	3038	pRockInfo->Info.Attr.u.Unix.INodeIdDevice = 0;
	3039	pRockInfo->Info.Attr.u.Unix.INodeId = 0;
	3040	pRockInfo->Info.Attr.u.Unix.fFlags = 0;
	3041	pRockInfo->Info.Attr.u.Unix.GenerationId = 0;
	3042	pRockInfo->Info.Attr.u.Unix.Device = 0;
	3043	}
	3044
	3045
	3046	static void rtFsIsoDirShrd_ParseRockForDirRec(PRTFSISODIRSHRD pThis, PCISO9660DIRREC pDirRec, PRTFSISOROCKINFO pRockInfo)
	3047	{
	3048	rtFsIsoDirShrd_InitRockInfo(pRockInfo, pDirRec); /* Always! */
	3049
	3050	PRTFSISOVOL const pVol = pThis->Core.pVol;
	3051	uint8_t cbSys = pDirRec->cbDirRec - RT_UOFFSETOF(ISO9660DIRREC, achFileId)
	3052	- pDirRec->bFileIdLength - !(pDirRec->bFileIdLength & 1);
	3053	uint8_t const pbSys = (uint8_t const )&pDirRec->achFileId[pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1)];
	3054	if (cbSys >= 4 + pVol->offSuspSkip)
	3055	{
	3056	pbSys += pVol->offSuspSkip;
	3057	cbSys -= pVol->offSuspSkip;
	3058	rtFsIsoDirShrd_ParseRockRidgeData(pVol, pRockInfo, pbSys, cbSys,
	3059	false /fIsFirstDirRec/, false /fContinuationRecord/);
	3060	}
	3061	}
	3062
	3063
	3064	static void rtFsIsoDirShrd_ParseRockForRoot(PRTFSISODIRSHRD pThis, PCISO9660DIRREC pDirRec)
	3065	{
	3066	uint8_t const cbSys = pDirRec->cbDirRec - RT_UOFFSETOF(ISO9660DIRREC, achFileId)
	3067	- pDirRec->bFileIdLength - !(pDirRec->bFileIdLength & 1);
	3068	uint8_t const * const pbSys = (uint8_t const *)&pDirRec->achFileId[pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1)];
	3069	if (cbSys >= 4)
	3070	{
	3071	RTFSISOROCKINFO RockInfo;
	3072	rtFsIsoDirShrd_InitRockInfo(&RockInfo, pDirRec);
	3073	rtFsIsoDirShrd_ParseRockRidgeData(pThis->Core.pVol, &RockInfo, pbSys, cbSys,
	3074	true /fIsFirstDirRec/, false /fContinuationRecord/);
	3075	if (RockInfo.fValid)
	3076	{
	3077	pThis->Core.fHaveRockInfo = true;
	3078	pThis->Core.BirthTime = RockInfo.Info.BirthTime;
	3079	pThis->Core.ChangeTime = RockInfo.Info.ChangeTime;
	3080	pThis->Core.AccessTime = RockInfo.Info.AccessTime;
	3081	pThis->Core.ModificationTime = RockInfo.Info.ModificationTime;
	3082	if (RTFS_IS_DIRECTORY(RockInfo.Info.Attr.fMode))
	3083	pThis->Core.fAttrib = RockInfo.Info.Attr.fMode;
	3084	}
	3085	}
	3086	}
	3087
	3088
	3089	/**
	3090	* Compares rock ridge information if present in the directory entry.
	3091	*
	3092	* @param pThis The shared directory structure.
	3093	* @param pbSys The system area of the directory record.
	3094	* @param cbSys The number of bytes present in the sys area.
	3095	* @param pNameCmp The name comparsion data.
	3096	* @param fContinuationRecord Set if we're processing a continuation record in
	3097	* living in the abRockBuf.
	3098	*/
	3099	static int rtFsIsoDirShrd_CompareRockRidgeName(PRTFSISODIRSHRD pThis, uint8_t const *pbSys, size_t cbSys,
	3100	PRTFSISOROCKNAMECOMP pNameCmp, bool fContinuationRecord)
	3101	{
	3102	PRTFSISOVOL const pVol = pThis->Core.pVol;
	3103
	3104	/*
	3105	* Do skipping if specified.
	3106	*/
	3107	if (pVol->offSuspSkip)
	3108	{
	3109	if (cbSys <= pVol->offSuspSkip)
	3110	return fContinuationRecord ? VERR_MORE_DATA : VERR_MISMATCH;
	3111	pbSys += pVol->offSuspSkip;
	3112	cbSys -= pVol->offSuspSkip;
	3113	}
	3114
	3115	while (cbSys >= 4)
	3116	{
	3117	/*
	3118	* Check header length and advance the sys variables.
	3119	*/
	3120	PCISO9660SUSPUNION pUnion = (PCISO9660SUSPUNION)pbSys;
	3121	if ( pUnion->Hdr.cbEntry > cbSys
	3122	&& pUnion->Hdr.cbEntry < sizeof(pUnion->Hdr))
	3123	{
	3124	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: cbEntry=%#x cbSys=%#x (%#x %#x)\n",
	3125	pUnion->Hdr.cbEntry, cbSys, pUnion->Hdr.bSig1, pUnion->Hdr.bSig2));
	3126	break;
	3127	}
	3128	pbSys += pUnion->Hdr.cbEntry;
	3129	cbSys -= pUnion->Hdr.cbEntry;
	3130
	3131	/*
	3132	* Process the fields we need, nothing else.
	3133	*/
	3134	uint16_t const uSig = SUSP_MAKE_SIG(pUnion->Hdr.bSig1, pUnion->Hdr.bSig2);
	3135
	3136
	3137	/*
	3138	* CE - continuation entry
	3139	*/
	3140	if (uSig == SUSP_MAKE_SIG(ISO9660SUSPCE_SIG1, ISO9660SUSPCE_SIG2))
	3141	{
	3142	if (RT_BE2H_U32(pUnion->CE.offBlock.be) != RT_LE2H_U32(pUnion->CE.offBlock.le))
	3143	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Invalid CE offBlock field: be=%#x vs le=%#x\n",
	3144	RT_BE2H_U32(pUnion->CE.offBlock.be), RT_LE2H_U32(pUnion->CE.offBlock.le)));
	3145	else if (RT_BE2H_U32(pUnion->CE.cbData.be) != RT_LE2H_U32(pUnion->CE.cbData.le))
	3146	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Invalid CE cbData field: be=%#x vs le=%#x\n",
	3147	RT_BE2H_U32(pUnion->CE.cbData.be), RT_LE2H_U32(pUnion->CE.cbData.le)));
	3148	else if (RT_BE2H_U32(pUnion->CE.offData.be) != RT_LE2H_U32(pUnion->CE.offData.le))
	3149	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Invalid CE offData field: be=%#x vs le=%#x\n",
	3150	RT_BE2H_U32(pUnion->CE.offData.be), RT_LE2H_U32(pUnion->CE.offData.le)));
	3151	else if (!fContinuationRecord)
	3152	{
	3153	uint64_t offData = ISO9660_GET_ENDIAN(&pUnion->CE.offBlock) * (uint64_t)ISO9660_SECTOR_SIZE;
	3154	offData += ISO9660_GET_ENDIAN(&pUnion->CE.offData);
	3155	uint32_t cbData = ISO9660_GET_ENDIAN(&pUnion->CE.cbData);
	3156	if (cbData <= sizeof(pVol->abRockBuf) - (uint32_t)(offData & ISO9660_SECTOR_OFFSET_MASK))
	3157	{
	3158	RTCritSectEnter(&pVol->RockBufLock);
	3159
	3160	AssertCompile(sizeof(pVol->abRockBuf) == ISO9660_SECTOR_SIZE);
	3161	uint64_t offDataBlock = offData & ~(uint64_t)ISO9660_SECTOR_OFFSET_MASK;
	3162	int rc;
	3163	if (pVol->offRockBuf == offDataBlock)
	3164	rc = rtFsIsoDirShrd_CompareRockRidgeName(pThis, &pVol->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK],
	3165	cbData, pNameCmp, true /fContinuationRecord/);
	3166	else
	3167	{
	3168	rc = RTVfsFileReadAt(pVol->hVfsBacking, offDataBlock, pVol->abRockBuf, sizeof(pVol->abRockBuf), NULL);
	3169	if (RT_SUCCESS(rc))
	3170	rc = rtFsIsoDirShrd_CompareRockRidgeName(pThis, &pVol->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK],
	3171	cbData, pNameCmp, true /fContinuationRecord/);
	3172	else
	3173	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Error reading continuation record at %#RX64: %Rrc\n",
	3174	offDataBlock, rc));
	3175	}
	3176
	3177	RTCritSectLeave(&pVol->RockBufLock);
	3178	if (rc != VERR_MORE_DATA)
	3179	return rc;
	3180	}
	3181	else
	3182	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: continuation record isn't within a sector! offData=%#RX64 cbData=%#RX32\n",
	3183	cbData, offData));
	3184	}
	3185	else
	3186	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: nested continuation record!\n"));
	3187	}
	3188	/*
	3189	* NM - Name entry.
	3190	*
	3191	* The character set is supposed to be limited to the portable filename
	3192	* character set defined in section 2.2.2.60 of POSIX.1: A-Za-z0-9._-
	3193	* If there are any other characters used, we consider them as UTF-8
	3194	* for reasons of simplicitiy, however we do not make any effort dealing
	3195	* with codepoint encodings across NM records for now because it is
	3196	* probably a complete waste of time.
	3197	*/
	3198	else if (uSig == SUSP_MAKE_SIG(ISO9660RRIPNM_SIG1, ISO9660RRIPNM_SIG2))
	3199	{
	3200	if ( pUnion->NM.Hdr.bVersion != ISO9660RRIPNM_VER
	3201	\|\| pUnion->NM.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPNM, achName)
	3202	\|\| (pUnion->NM.fFlags & ISO9660RRIP_NM_F_RESERVED_MASK) )
	3203	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Malformed 'NM' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x %.*Rhxs\n",
	3204	pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName),
	3205	pUnion->NM.Hdr.bVersion, ISO9660RRIPNM_VER, pUnion->NM.fFlags,
	3206	pUnion->NM.Hdr.cbEntry - RT_MIN(pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName)),
	3207	&pUnion->NM.achName[0] ));
	3208	else
	3209	{
	3210	uint8_t const cchName = pUnion->NM.Hdr.cbEntry - (uint8_t)RT_UOFFSETOF(ISO9660RRIPNM, achName);
	3211	if (!(pUnion->NM.fFlags & (ISO9660RRIP_NM_F_CURRENT \| ISO9660RRIP_NM_F_PARENT)))
	3212	{ /* likely */ }
	3213	else
	3214	{
	3215	if (cchName == 0)
	3216	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Ignoring 'NM' entry for '.' and '..'\n"));
	3217	else
	3218	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: Ignoring malformed 'NM' using '.' or '..': fFlags=%#x cchName=%#x %.*Rhxs\n",
	3219	pUnion->NM.fFlags, cchName, cchName, pUnion->NM.achName));
	3220	pNameCmp->offMatched = ~(size_t)0 / 2;
	3221	return VERR_MISMATCH;
	3222	}
	3223	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: 'NM': fFlags=%#x cchName=%#x '%.s' (%.Rhxs); offMatched=%#zx cchEntry=%#zx\n",
	3224	pUnion->NM.fFlags, cchName, cchName, pUnion->NM.achName, cchName, pUnion->NM.achName, pNameCmp->offMatched, pNameCmp->cchEntry));
	3225	AssertReturn(pNameCmp->offMatched < pNameCmp->cchEntry, VERR_MISMATCH);
	3226
	3227	if (RTStrNICmp(&pNameCmp->pszEntry[pNameCmp->offMatched], pUnion->NM.achName, cchName) == 0)
	3228	{
	3229	/** @todo Incorrectly ASSUMES all upper and lower codepoints have the same
	3230	* encoding length. However, since this shouldn't be UTF-8, but plain
	3231	* limited ASCII that's not really all that important. */
	3232	pNameCmp->offMatched += cchName;
	3233	if (!(pUnion->NM.fFlags & ISO9660RRIP_NM_F_CONTINUE))
	3234	{
	3235	if (pNameCmp->offMatched >= pNameCmp->cchEntry)
	3236	{
	3237	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: 'NM': returning VINF_SUCCESS\n"));
	3238	return VINF_SUCCESS;
	3239	}
	3240	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: 'NM': returning VERR_MISMATCH - %zu unmatched bytes\n",
	3241	pNameCmp->cchEntry - pNameCmp->offMatched));
	3242	return VERR_MISMATCH;
	3243	}
	3244	if (pNameCmp->offMatched >= pNameCmp->cchEntry)
	3245	{
	3246	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: 'NM': returning VERR_MISMATCH - match full name but ISO9660RRIP_NM_F_CONTINUE is set!\n"));
	3247	return VERR_MISMATCH;
	3248	}
	3249	}
	3250	else
	3251	{
	3252	Log4(("rtFsIsoDirShrd_CompareRockRidgeName: 'NM': returning VERR_MISMATCH - mismatch\n"));
	3253	pNameCmp->offMatched = ~(size_t)0 / 2;
	3254	return VERR_MISMATCH;
	3255	}
	3256	}
	3257	}
	3258	}
	3259	return fContinuationRecord ? VERR_MORE_DATA : VERR_MISMATCH;
	3260	}
	3261
	3262
	3263	/**
	3264	* Worker for rtFsIsoDir_FindEntry9660 that compares a name with the rock ridge
	3265	* info in the directory record, if present.
	3266	*
	3267	* @returns true if equal, false if not.
	3268	* @param pThis The directory.
	3269	* @param pDirRec The directory record.
	3270	* @param pszEntry The string to compare with.
	3271	* @param cbEntry The length of @a pszEntry including terminator.
	3272	*/
	3273	static bool rtFsIsoDir_IsEntryEqualRock(PRTFSISODIRSHRD pThis, PCISO9660DIRREC pDirRec, const char *pszEntry, size_t cbEntry)
	3274	{
	3275	/*
	3276	* Is there room for any rock ridge data?
	3277	*/
	3278	uint8_t const cbSys = pDirRec->cbDirRec - RT_UOFFSETOF(ISO9660DIRREC, achFileId)
	3279	- pDirRec->bFileIdLength - !(pDirRec->bFileIdLength & 1);
	3280	uint8_t const * const pbSys = (uint8_t const *)&pDirRec->achFileId[pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1)];
	3281	if (cbSys >= 4)
	3282	{
	3283	RTFSISOROCKNAMECOMP NameCmp;
	3284	NameCmp.pszEntry = pszEntry;
	3285	NameCmp.cchEntry = cbEntry - 1;
	3286	NameCmp.offMatched = 0;
	3287	int rc = rtFsIsoDirShrd_CompareRockRidgeName(pThis, pbSys, cbSys, &NameCmp, false /fContinuationRecord/);
	3288	if (rc == VINF_SUCCESS)
	3289	return true;
	3290	}
	3291	return false;
	3292	}
	3293
	3294
	3295	/**
[69048]	3296	* Worker for rtFsIsoDir_FindEntry9660 that compares a UTF-16BE name with a
[67559]	3297	* directory record.
	3298	*
	3299	* @returns true if equal, false if not.
	3300	* @param pDirRec The directory record.
	3301	* @param pwszEntry The UTF-16BE string to compare with.
	3302	* @param cbEntry The compare string length in bytes (sans zero
	3303	* terminator).
	3304	* @param cwcEntry The compare string length in RTUTF16 units.
	3305	* @param puVersion Where to return any file version number.
	3306	*/
[68694]	3307	DECL_FORCE_INLINE(bool) rtFsIsoDir_IsEntryEqualUtf16Big(PCISO9660DIRREC pDirRec, PCRTUTF16 pwszEntry, size_t cbEntry,
	3308	size_t cwcEntry, uint32_t *puVersion)
[67559]	3309	{
	3310	/* ASSUME directories cannot have any version tags. */
	3311	if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)
	3312	{
	3313	if (RT_LIKELY(pDirRec->bFileIdLength != cbEntry))
	3314	return false;
	3315	if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0))
	3316	return false;
	3317	}
	3318	else
	3319	{
	3320	size_t cbNameDelta = (size_t)pDirRec->bFileIdLength - cbEntry;
	3321	if (RT_LIKELY(cbNameDelta > (size_t)12 /* ;12345 */))
	3322	return false;
	3323	if (cbNameDelta == 0)
	3324	{
	3325	if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0))
	3326	return false;
	3327	*puVersion = 1;
	3328	}
	3329	else
	3330	{
	3331	if (RT_LIKELY(RT_MAKE_U16(pDirRec->achFileId[cbEntry + 1], pDirRec->achFileId[cbEntry]) != ';'))
	3332	return false;
	3333	if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0))
	3334	return false;
	3335	uint32_t uVersion;
	3336	size_t cwcVersion = rtFsIso9660GetVersionLengthUtf16Big((PCRTUTF16)pDirRec->achFileId,
	3337	pDirRec->bFileIdLength, &uVersion);
	3338	if (RT_LIKELY(cwcVersion * sizeof(RTUTF16) == cbNameDelta))
	3339	*puVersion = uVersion;
	3340	else
	3341	return false;
	3342	}
	3343	}
[67570]	3344
	3345	/* (No need to check for dot and dot-dot here, because cbEntry must be a
	3346	multiple of two.) */
	3347	Assert(!(cbEntry & 1));
[67559]	3348	return true;
	3349	}
	3350
	3351
	3352	/**
[69048]	3353	* Worker for rtFsIsoDir_FindEntry9660 that compares an ASCII name with a
[67559]	3354	* directory record.
	3355	*
	3356	* @returns true if equal, false if not.
	3357	* @param pDirRec The directory record.
	3358	* @param pszEntry The uppercased ASCII string to compare with.
	3359	* @param cchEntry The length of the compare string.
	3360	* @param puVersion Where to return any file version number.
[93081]	3361	*
	3362	* @note We're using RTStrNICmpAscii here because of non-conforming ISOs with
	3363	* entirely lowercase name or mixed cased names.
[67559]	3364	*/
[68694]	3365	DECL_FORCE_INLINE(bool) rtFsIsoDir_IsEntryEqualAscii(PCISO9660DIRREC pDirRec, const char *pszEntry, size_t cchEntry,
[93081]	3366	uint32_t *puVersion)
[67559]	3367	{
	3368	/* ASSUME directories cannot have any version tags. */
	3369	if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)
	3370	{
	3371	if (RT_LIKELY(pDirRec->bFileIdLength != cchEntry))
	3372	return false;
[93081]	3373	if (RT_LIKELY(RTStrNICmpAscii(pDirRec->achFileId, pszEntry, cchEntry) != 0))
[67559]	3374	return false;
	3375	}
	3376	else
	3377	{
	3378	size_t cchNameDelta = (size_t)pDirRec->bFileIdLength - cchEntry;
	3379	if (RT_LIKELY(cchNameDelta > (size_t)6 /* ;12345 */))
	3380	return false;
	3381	if (cchNameDelta == 0)
	3382	{
[93081]	3383	if (RT_LIKELY(RTStrNICmpAscii(pDirRec->achFileId, pszEntry, cchEntry) != 0))
[67559]	3384	return false;
	3385	*puVersion = 1;
	3386	}
	3387	else
	3388	{
	3389	if (RT_LIKELY(pDirRec->achFileId[cchEntry] != ';'))
	3390	return false;
[93081]	3391	if (RT_LIKELY(RTStrNICmpAscii(pDirRec->achFileId, pszEntry, cchEntry) != 0))
[67559]	3392	return false;
	3393	uint32_t uVersion;
	3394	size_t cchVersion = rtFsIso9660GetVersionLengthAscii(pDirRec->achFileId, pDirRec->bFileIdLength, &uVersion);
	3395	if (RT_LIKELY(cchVersion == cchNameDelta))
	3396	*puVersion = uVersion;
	3397	else
	3398	return false;
	3399	}
	3400	}
[67570]	3401
	3402	/* Don't match the 'dot' and 'dot-dot' directory records. */
	3403	if (RT_LIKELY( pDirRec->bFileIdLength != 1
	3404	\|\| (uint8_t)pDirRec->achFileId[0] > (uint8_t)0x01))
	3405	return true;
	3406	return false;
[67559]	3407	}
	3408
	3409
	3410	/**
[66735]	3411	* Locates a directory entry in a directory.
	3412	*
	3413	* @returns IPRT status code.
	3414	* @retval VERR_FILE_NOT_FOUND if not found.
	3415	* @param pThis The directory to search.
	3416	* @param pszEntry The entry to look for.
	3417	* @param poffDirRec Where to return the offset of the directory record
	3418	* on the disk.
	3419	* @param ppDirRec Where to return the pointer to the directory record
	3420	* (the whole directory is buffered).
	3421	* @param pcDirRecs Where to return the number of directory records
	3422	* related to this entry.
	3423	* @param pfMode Where to return the file type, rock ridge adjusted.
[67559]	3424	* @param puVersion Where to return the file version number.
[94280]	3425	* @param pRockInfo Where to return rock ridge info. This is NULL if
	3426	* the volume didn't advertise any rock ridge info.
[66735]	3427	*/
[94280]	3428	static int rtFsIsoDir_FindEntry9660(PRTFSISODIRSHRD pThis, const char pszEntry, uint64_t poffDirRec, PCISO9660DIRREC *ppDirRec,
	3429	uint32_t pcDirRecs, PRTFMODE pfMode, uint32_t puVersion, PRTFSISOROCKINFO pRockInfo)
[66735]	3430	{
[69035]	3431	Assert(pThis->Core.pVol->enmType != RTFSISOVOLTYPE_UDF);
	3432
[66735]	3433	/* Set return values. */
	3434	*poffDirRec = UINT64_MAX;
	3435	*ppDirRec = NULL;
	3436	*pcDirRecs = 1;
	3437	*pfMode = UINT32_MAX;
[67559]	3438	*puVersion = 0;
[94280]	3439	if (pRockInfo)
	3440	pRockInfo->fValid = false;
[66735]	3441
	3442	/*
	3443	* If we're in UTF-16BE mode, convert the input name to UTF-16BE. Otherwise try
	3444	* uppercase it into a ISO 9660 compliant name.
	3445	*/
	3446	int rc;
[94280]	3447	bool const fIsUtf16 = pThis->Core.pVol->fIsUtf16;
	3448	size_t cwcEntry = 0;
	3449	size_t cbEntry = 0;
	3450	size_t cchUpper = ~(size_t)0;
[66735]	3451	union
	3452	{
	3453	RTUTF16 wszEntry[260 + 1];
	3454	struct
	3455	{
	3456	char szUpper[255 + 1];
	3457	char szRock[260 + 1];
	3458	} s;
	3459	} uBuf;
	3460	if (fIsUtf16)
	3461	{
	3462	PRTUTF16 pwszEntry = uBuf.wszEntry;
[67334]	3463	rc = RTStrToUtf16BigEx(pszEntry, RTSTR_MAX, &pwszEntry, RT_ELEMENTS(uBuf.wszEntry), &cwcEntry);
[66735]	3464	if (RT_FAILURE(rc))
[69048]	3465	return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc;
[66735]	3466	cbEntry = cwcEntry * 2;
	3467	}
	3468	else
	3469	{
	3470	rc = RTStrCopy(uBuf.s.szUpper, sizeof(uBuf.s.szUpper), pszEntry);
[69048]	3471	if (RT_FAILURE(rc))
	3472	return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc;
	3473	RTStrToUpper(uBuf.s.szUpper);
	3474	cchUpper = strlen(uBuf.s.szUpper);
[94280]	3475	cbEntry = strlen(pszEntry) + 1;
[66735]	3476	}
	3477
	3478	/*
	3479	* Scan the directory buffer by buffer.
	3480	*/
	3481	uint32_t offEntryInDir = 0;
	3482	uint32_t const cbDir = pThis->Core.cbObject;
[66768]	3483	while (offEntryInDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= cbDir)
[66735]	3484	{
	3485	PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pThis->pbDir[offEntryInDir];
	3486
	3487	/* If null length, skip to the next sector. */
	3488	if (pDirRec->cbDirRec == 0)
	3489	offEntryInDir = (offEntryInDir + pThis->Core.pVol->cbSector) & ~(pThis->Core.pVol->cbSector - 1U);
	3490	else
	3491	{
[94280]	3492	/*
	3493	* Try match the filename.
	3494	*/
	3495	/** @todo not sure if it's a great idea to match both name spaces... */
	3496	if (RT_LIKELY( fIsUtf16
	3497	? !rtFsIsoDir_IsEntryEqualUtf16Big(pDirRec, uBuf.wszEntry, cbEntry, cwcEntry, puVersion)
	3498	&& ( !pRockInfo
	3499	\|\| !rtFsIsoDir_IsEntryEqualRock(pThis, pDirRec, pszEntry, cbEntry))
	3500	: ( !pRockInfo
	3501	\|\| !rtFsIsoDir_IsEntryEqualRock(pThis, pDirRec, pszEntry, cbEntry))
	3502	&& !rtFsIsoDir_IsEntryEqualAscii(pDirRec, uBuf.s.szUpper, cchUpper, puVersion) ))
[66735]	3503	{
[94280]	3504	/* Advance */
	3505	offEntryInDir += pDirRec->cbDirRec;
	3506	continue;
[66735]	3507	}
[94280]	3508
	3509	/*
	3510	* Get info for the entry.
	3511	*/
	3512	if (!pRockInfo)
	3513	*pfMode = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY
	3514	? 0755 \| RTFS_TYPE_DIRECTORY \| RTFS_DOS_DIRECTORY
	3515	: 0644 \| RTFS_TYPE_FILE;
[66735]	3516	else
	3517	{
[94280]	3518	rtFsIsoDirShrd_ParseRockForDirRec(pThis, pDirRec, pRockInfo);
	3519	*pfMode = pRockInfo->Info.Attr.fMode;
[66735]	3520	}
[69027]	3521	*poffDirRec = pThis->Core.FirstExtent.off + offEntryInDir;
[66735]	3522	*ppDirRec = pDirRec;
[67568]	3523
	3524	/*
	3525	* Deal with the unlikely scenario of multi extent records.
	3526	*/
	3527	if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT))
	3528	*pcDirRecs = 1;
	3529	else
	3530	{
	3531	offEntryInDir += pDirRec->cbDirRec;
	3532
	3533	uint32_t cDirRecs = 1;
	3534	while (offEntryInDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= cbDir)
	3535	{
	3536	PCISO9660DIRREC pDirRec2 = (PCISO9660DIRREC)&pThis->pbDir[offEntryInDir];
	3537	if (pDirRec2->cbDirRec != 0)
	3538	{
[68694]	3539	Assert(rtFsIsoDir_Is9660DirRecNextExtent(pDirRec, pDirRec2));
[67568]	3540	cDirRecs++;
	3541	if (!(pDirRec2->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT))
	3542	break;
	3543	offEntryInDir += pDirRec2->cbDirRec;
	3544	}
	3545	else
	3546	offEntryInDir = (offEntryInDir + pThis->Core.pVol->cbSector) & ~(pThis->Core.pVol->cbSector - 1U);
	3547	}
	3548
	3549	*pcDirRecs = cDirRecs;
	3550	}
[66735]	3551	return VINF_SUCCESS;
	3552	}
	3553	}
	3554
	3555	return VERR_FILE_NOT_FOUND;
	3556	}
	3557
	3558
	3559	/**
[69048]	3560	* Locates a directory entry in a directory.
	3561	*
	3562	* @returns IPRT status code.
	3563	* @retval VERR_FILE_NOT_FOUND if not found.
	3564	* @param pThis The directory to search.
	3565	* @param pszEntry The entry to look for.
	3566	* @param ppFid Where to return the pointer to the file ID entry.
	3567	* (Points to the directory content.)
	3568	*/
	3569	static int rtFsIsoDir_FindEntryUdf(PRTFSISODIRSHRD pThis, const char pszEntry, PCUDFFILEIDDESC ppFid)
	3570	{
	3571	Assert(pThis->Core.pVol->enmType == RTFSISOVOLTYPE_UDF);
	3572	*ppFid = NULL;
	3573
	3574	/*
	3575	* Recode the entry name as 8-bit (if possible) and 16-bit strings.
	3576	* This also disposes of entries that definitely are too long.
	3577	*/
	3578	size_t cb8Bit;
	3579	bool fSimple;
	3580	size_t cb16Bit;
	3581	size_t cwc16Bit;
	3582	uint8_t ab8Bit[255];
	3583	RTUTF16 wsz16Bit[255];
	3584
	3585	/* 16-bit */
	3586	PRTUTF16 pwsz16Bit = wsz16Bit;
	3587	int rc = RTStrToUtf16BigEx(pszEntry, RTSTR_MAX, &pwsz16Bit, RT_ELEMENTS(wsz16Bit), &cwc16Bit);
	3588	if (RT_SUCCESS(rc))
	3589	cb16Bit = 1 + cwc16Bit * sizeof(RTUTF16);
	3590	else
	3591	return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc;
	3592
	3593	/* 8-bit (can't possibly overflow) */
	3594	fSimple = true;
	3595	cb8Bit = 0;
	3596	const char *pszSrc = pszEntry;
	3597	for (;;)
	3598	{
	3599	RTUNICP uc;
[69049]	3600	int rc2 = RTStrGetCpEx(&pszSrc, &uc);
	3601	AssertRCReturn(rc2, rc2);
[69048]	3602	if (uc <= 0x7f)
	3603	{
	3604	if (uc)
	3605	ab8Bit[cb8Bit++] = (uint8_t)uc;
	3606	else
	3607	break;
	3608	}
	3609	else if (uc <= 0xff)
	3610	{
	3611	ab8Bit[cb8Bit++] = (uint8_t)uc;
	3612	fSimple = false;
	3613	}
	3614	else
	3615	{
	3616	cb8Bit = UINT32_MAX / 2;
	3617	break;
	3618	}
	3619	}
	3620	Assert(cb8Bit <= sizeof(ab8Bit) \|\| cb8Bit == UINT32_MAX / 2);
	3621	cb8Bit++;
	3622
	3623	/*
	3624	* Scan the directory content.
	3625	*/
	3626	uint32_t offDesc = 0;
	3627	uint32_t const cbDir = pThis->Core.cbObject;
	3628	while (offDesc + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) <= cbDir)
	3629	{
	3630	PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pThis->pbDir[offDesc];
	3631	uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid);
	3632	if ( offDesc + cbFid <= cbDir
	3633	&& pFid->Tag.idTag == UDF_TAG_ID_FILE_ID_DESC)
	3634	{ /* likely */ }
	3635	else
	3636	break;
	3637
	3638	uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid);
	3639	if (*pbName == 16)
	3640	{
	3641	if (cb16Bit == pFid->cbName)
	3642	{
	3643	if (RTUtf16BigNICmp((PCRTUTF16)(&pbName[1]), wsz16Bit, cwc16Bit) == 0)
	3644	{
	3645	*ppFid = pFid;
	3646	return VINF_SUCCESS;
	3647	}
	3648	}
	3649	}
	3650	else if (*pbName == 8)
	3651	{
	3652	if ( cb8Bit == pFid->cbName
	3653	&& cb8Bit != UINT16_MAX)
	3654	{
	3655	if (fSimple)
	3656	{
	3657	if (RTStrNICmp((const char )&pbName[1], (const char )ab8Bit, cb8Bit - 1) == 0)
	3658	{
	3659	*ppFid = pFid;
	3660	return VINF_SUCCESS;
	3661	}
	3662	}
	3663	else
	3664	{
	3665	size_t cch = cb8Bit - 1;
	3666	size_t off;
	3667	for (off = 0; off < cch; off++)
	3668	{
	3669	RTUNICP uc1 = ab8Bit[off];
	3670	RTUNICP uc2 = pbName[off + 1];
	3671	if ( uc1 == uc2
	3672	\|\| RTUniCpToLower(uc1) == RTUniCpToLower(uc2)
	3673	\|\| RTUniCpToUpper(uc1) == RTUniCpToUpper(uc2))
	3674	{ /* matches */ }
	3675	else
	3676	break;
	3677	}
	3678	if (off == cch)
	3679	{
	3680	*ppFid = pFid;
	3681	return VINF_SUCCESS;
	3682	}
	3683	}
	3684	}
	3685	}
	3686
	3687	/* advance */
	3688	offDesc += cbFid;
	3689	}
	3690
	3691	return VERR_FILE_NOT_FOUND;
	3692	}
	3693
	3694
	3695	/**
[66765]	3696	* Releases a reference to a shared directory structure.
	3697	*
	3698	* @param pShared The shared directory structure.
[66735]	3699	*/
[68694]	3700	static void rtFsIsoDirShrd_Release(PRTFSISODIRSHRD pShared)
[66735]	3701	{
[66765]	3702	uint32_t cRefs = ASMAtomicDecU32(&pShared->Core.cRefs);
	3703	Assert(cRefs < UINT32_MAX / 2);
	3704	if (cRefs == 0)
[66735]	3705	{
[68694]	3706	LogFlow(("rtFsIsoDirShrd_Release: Destroying shared structure %p\n", pShared));
[66765]	3707	Assert(pShared->Core.cRefs == 0);
	3708	if (pShared->pbDir)
	3709	{
	3710	RTMemFree(pShared->pbDir);
	3711	pShared->pbDir = NULL;
	3712	}
[68694]	3713	rtFsIsoCore_Destroy(&pShared->Core);
[66765]	3714	RTMemFree(pShared);
[66735]	3715	}
	3716	}
	3717
	3718
	3719	/**
[66765]	3720	* Retains a reference to a shared directory structure.
	3721	*
	3722	* @param pShared The shared directory structure.
	3723	*/
[68694]	3724	static void rtFsIsoDirShrd_Retain(PRTFSISODIRSHRD pShared)
[66765]	3725	{
	3726	uint32_t cRefs = ASMAtomicIncU32(&pShared->Core.cRefs);
	3727	Assert(cRefs > 1); NOREF(cRefs);
	3728	}
	3729
	3730
	3731
	3732	/**
	3733	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
	3734	*/
[68694]	3735	static DECLCALLBACK(int) rtFsIsoDir_Close(void *pvThis)
[66765]	3736	{
[68694]	3737	PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis;
	3738	LogFlow(("rtFsIsoDir_Close(%p/%p)\n", pThis, pThis->pShared));
[66765]	3739
[68694]	3740	PRTFSISODIRSHRD pShared = pThis->pShared;
[66765]	3741	pThis->pShared = NULL;
	3742	if (pShared)
[68694]	3743	rtFsIsoDirShrd_Release(pShared);
[66765]	3744	return VINF_SUCCESS;
	3745	}
	3746
	3747
	3748	/**
	3749	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
	3750	*/
[68694]	3751	static DECLCALLBACK(int) rtFsIsoDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
[66765]	3752	{
[68694]	3753	PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis;
	3754	return rtFsIsoCore_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr);
[66765]	3755	}
	3756
	3757
	3758	/**
[69813]	3759	* @interface_method_impl{RTVFSDIROPS,pfnOpen}
	3760	*/
	3761	static DECLCALLBACK(int) rtFsIsoDir_Open(void pvThis, const char pszEntry, uint64_t fOpen,
	3762	uint32_t fFlags, PRTVFSOBJ phVfsObj)
	3763	{
	3764	PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis;
	3765	PRTFSISODIRSHRD pShared = pThis->pShared;
[69828]	3766	int rc;
[69813]	3767
	3768	/*
	3769	* We cannot create or replace anything, just open stuff.
	3770	*/
[69828]	3771	if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN
	3772	\|\| (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE)
	3773	{ /* likely */ }
	3774	else
[69813]	3775	return VERR_WRITE_PROTECT;
	3776
	3777	/*
[69924]	3778	* Special cases '.' and '..'
[69828]	3779	*/
	3780	if (pszEntry[0] == '.')
	3781	{
	3782	PRTFSISODIRSHRD pSharedToOpen;
	3783	if (pszEntry[1] == '\0')
	3784	pSharedToOpen = pShared;
	3785	else if (pszEntry[1] == '.' && pszEntry[2] == '\0')
	3786	{
	3787	pSharedToOpen = pShared->Core.pParentDir;
	3788	if (!pSharedToOpen)
	3789	pSharedToOpen = pShared;
	3790	}
	3791	else
	3792	pSharedToOpen = NULL;
	3793	if (pSharedToOpen)
	3794	{
	3795	if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
	3796	{
	3797	rtFsIsoDirShrd_Retain(pSharedToOpen);
	3798	RTVFSDIR hVfsDir;
	3799	rc = rtFsIsoDir_NewWithShared(pShared->Core.pVol, pSharedToOpen, &hVfsDir);
	3800	if (RT_SUCCESS(rc))
	3801	{
	3802	*phVfsObj = RTVfsObjFromDir(hVfsDir);
	3803	RTVfsDirRelease(hVfsDir);
	3804	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
	3805	}
	3806	}
	3807	else
	3808	rc = VERR_IS_A_DIRECTORY;
	3809	return rc;
	3810	}
	3811	}
	3812
	3813	/*
[69813]	3814	* Try open whatever it is.
	3815	*/
	3816	if (pShared->Core.pVol->enmType != RTFSISOVOLTYPE_UDF)
	3817	{
[69828]	3818
[69813]	3819	/*
	3820	* ISO 9660
	3821	*/
[94280]	3822	PCISO9660DIRREC pDirRec;
	3823	uint64_t offDirRec;
	3824	uint32_t cDirRecs;
	3825	RTFMODE fMode;
	3826	uint32_t uVersion;
	3827	PRTFSISOROCKINFO pRockInfo = NULL;
	3828	if (pShared->Core.pVol->fHaveRock)
	3829	pRockInfo = (PRTFSISOROCKINFO)alloca(sizeof(*pRockInfo));
	3830	rc = rtFsIsoDir_FindEntry9660(pShared, pszEntry, &offDirRec, &pDirRec, &cDirRecs, &fMode, &uVersion, pRockInfo);
[69813]	3831	Log2(("rtFsIsoDir_Open: FindEntry9660(,%s,) -> %Rrc\n", pszEntry, rc));
	3832	if (RT_SUCCESS(rc))
	3833	{
	3834	switch (fMode & RTFS_TYPE_MASK)
	3835	{
	3836	case RTFS_TYPE_FILE:
	3837	if (fFlags & RTVFSOBJ_F_OPEN_FILE)
	3838	{
	3839	RTVFSFILE hVfsFile;
[94280]	3840	rc = rtFsIsoFile_New9660(pShared->Core.pVol, pShared, pDirRec, cDirRecs, offDirRec, fOpen,
	3841	uVersion, pRockInfo && pRockInfo->fValid ? pRockInfo : NULL, &hVfsFile);
[69813]	3842	if (RT_SUCCESS(rc))
	3843	{
	3844	*phVfsObj = RTVfsObjFromFile(hVfsFile);
	3845	RTVfsFileRelease(hVfsFile);
	3846	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
	3847	}
	3848	}
	3849	else
	3850	rc = VERR_IS_A_FILE;
	3851	break;
	3852
	3853	case RTFS_TYPE_DIRECTORY:
	3854	if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
	3855	{
	3856	RTVFSDIR hVfsDir;
[94280]	3857	rc = rtFsIsoDir_New9660(pShared->Core.pVol, pShared, pDirRec, cDirRecs, offDirRec,
	3858	pRockInfo && pRockInfo->fValid ? pRockInfo : NULL, &hVfsDir);
[69813]	3859	if (RT_SUCCESS(rc))
	3860	{
	3861	*phVfsObj = RTVfsObjFromDir(hVfsDir);
	3862	RTVfsDirRelease(hVfsDir);
	3863	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
	3864	}
	3865	}
	3866	else
	3867	rc = VERR_IS_A_DIRECTORY;
	3868	break;
	3869
	3870	case RTFS_TYPE_SYMLINK:
	3871	case RTFS_TYPE_DEV_BLOCK:
	3872	case RTFS_TYPE_DEV_CHAR:
	3873	case RTFS_TYPE_FIFO:
	3874	case RTFS_TYPE_SOCKET:
	3875	case RTFS_TYPE_WHITEOUT:
	3876	rc = VERR_NOT_IMPLEMENTED;
	3877	break;
	3878
	3879	default:
	3880	rc = VERR_PATH_NOT_FOUND;
	3881	break;
	3882	}
	3883	}
	3884	}
	3885	else
	3886	{
	3887	/*
	3888	* UDF
	3889	*/
	3890	PCUDFFILEIDDESC pFid;
	3891	rc = rtFsIsoDir_FindEntryUdf(pShared, pszEntry, &pFid);
	3892	Log2(("rtFsIsoDir_Open: FindEntryUdf(,%s,) -> %Rrc\n", pszEntry, rc));
	3893	if (RT_SUCCESS(rc))
	3894	{
	3895	if (!(pFid->fFlags & UDF_FILE_FLAGS_DELETED))
	3896	{
	3897	if (!(pFid->fFlags & UDF_FILE_FLAGS_DIRECTORY))
	3898	{
	3899	if (fFlags & RTVFSOBJ_F_OPEN_FILE)
	3900	{
	3901	RTVFSFILE hVfsFile;
	3902	rc = rtFsIsoFile_NewUdf(pShared->Core.pVol, pShared, pFid, fOpen, &hVfsFile);
	3903	if (RT_SUCCESS(rc))
	3904	{
	3905	*phVfsObj = RTVfsObjFromFile(hVfsFile);
	3906	RTVfsFileRelease(hVfsFile);
	3907	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
	3908	}
	3909	}
	3910	else
	3911	rc = VERR_IS_A_FILE;
	3912	}
	3913	else
	3914	{
	3915	if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)
	3916	{
	3917	RTVFSDIR hVfsDir;
	3918	rc = rtFsIsoDir_NewUdf(pShared->Core.pVol, pShared, pFid, &hVfsDir);
	3919	if (RT_SUCCESS(rc))
	3920	{
	3921	*phVfsObj = RTVfsObjFromDir(hVfsDir);
	3922	RTVfsDirRelease(hVfsDir);
	3923	AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3);
	3924	}
	3925	}
	3926	else
	3927	rc = VERR_IS_A_DIRECTORY;
	3928	}
	3929	}
	3930	/* We treat UDF_FILE_FLAGS_DELETED like RTFS_TYPE_WHITEOUT for now. */
	3931	else
	3932	rc = VERR_PATH_NOT_FOUND;
	3933	}
	3934	}
	3935	return rc;
	3936
	3937	}
	3938
	3939
	3940	/**
[66735]	3941	* @interface_method_impl{RTVFSDIROPS,pfnCreateDir}
	3942	*/
[68694]	3943	static DECLCALLBACK(int) rtFsIsoDir_CreateDir(void pvThis, const char pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir)
[66735]	3944	{
	3945	RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir);
[66742]	3946	return VERR_WRITE_PROTECT;
[66735]	3947	}
	3948
	3949
	3950	/**
	3951	* @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink}
	3952	*/
[68694]	3953	static DECLCALLBACK(int) rtFsIsoDir_OpenSymlink(void pvThis, const char pszSymlink, PRTVFSSYMLINK phVfsSymlink)
[66735]	3954	{
	3955	RT_NOREF(pvThis, pszSymlink, phVfsSymlink);
	3956	return VERR_NOT_SUPPORTED;
	3957	}
	3958
	3959
	3960	/**
	3961	* @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink}
	3962	*/
[68694]	3963	static DECLCALLBACK(int) rtFsIsoDir_CreateSymlink(void pvThis, const char pszSymlink, const char *pszTarget,
	3964	RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink)
[66735]	3965	{
	3966	RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink);
[66742]	3967	return VERR_WRITE_PROTECT;
[66735]	3968	}
	3969
	3970
	3971	/**
	3972	* @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry}
	3973	*/
[68694]	3974	static DECLCALLBACK(int) rtFsIsoDir_UnlinkEntry(void pvThis, const char pszEntry, RTFMODE fType)
[66735]	3975	{
	3976	RT_NOREF(pvThis, pszEntry, fType);
[66742]	3977	return VERR_WRITE_PROTECT;
[66735]	3978	}
	3979
	3980
	3981	/**
[66762]	3982	* @interface_method_impl{RTVFSDIROPS,pfnRenameEntry}
	3983	*/
[68694]	3984	static DECLCALLBACK(int) rtFsIsoDir_RenameEntry(void pvThis, const char pszEntry, RTFMODE fType, const char *pszNewName)
[66762]	3985	{
	3986	RT_NOREF(pvThis, pszEntry, fType, pszNewName);
	3987	return VERR_WRITE_PROTECT;
	3988	}
	3989
	3990
	3991	/**
[66735]	3992	* @interface_method_impl{RTVFSDIROPS,pfnRewindDir}
	3993	*/
[68694]	3994	static DECLCALLBACK(int) rtFsIsoDir_RewindDir(void *pvThis)
[66735]	3995	{
[68694]	3996	PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis;
[66766]	3997	pThis->offDir = 0;
	3998	return VINF_SUCCESS;
[66735]	3999	}
	4000
	4001
	4002	/**
[69035]	4003	* The ISO 9660 worker for rtFsIsoDir_ReadDir
[66735]	4004	*/
[69048]	4005	static int rtFsIsoDir_ReadDir9660(PRTFSISODIROBJ pThis, PRTFSISODIRSHRD pShared, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
	4006	RTFSOBJATTRADD enmAddAttr)
[66735]	4007	{
[94280]	4008	PRTFSISOROCKINFO pRockInfo = NULL;
	4009	if (pShared->Core.pVol->fHaveRock)
	4010	pRockInfo = (PRTFSISOROCKINFO)alloca(sizeof(*pRockInfo));
	4011
[66767]	4012	while (pThis->offDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= pShared->cbDir)
	4013	{
	4014	PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pShared->pbDir[pThis->offDir];
	4015
	4016	/* If null length, skip to the next sector. */
	4017	if (pDirRec->cbDirRec == 0)
	4018	pThis->offDir = (pThis->offDir + pShared->Core.pVol->cbSector) & ~(pShared->Core.pVol->cbSector - 1U);
	4019	else
	4020	{
	4021	/*
	4022	* Do names first as they may cause overflows.
	4023	*/
[67559]	4024	uint32_t uVersion = 0;
[66767]	4025	if ( pDirRec->bFileIdLength == 1
	4026	&& pDirRec->achFileId[0] == '\0')
	4027	{
[66768]	4028	if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2)
[66767]	4029	{
[66768]	4030	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2;
[69048]	4031	Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW (dot)\n"));
[66767]	4032	return VERR_BUFFER_OVERFLOW;
	4033	}
	4034	pDirEntry->cbName = 1;
	4035	pDirEntry->szName[0] = '.';
	4036	pDirEntry->szName[1] = '\0';
	4037	}
	4038	else if ( pDirRec->bFileIdLength == 1
[66768]	4039	&& pDirRec->achFileId[0] == '\1')
[66767]	4040	{
[66768]	4041	if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 3)
[66767]	4042	{
[66768]	4043	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 3;
[69048]	4044	Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW (dot-dot)\n"));
[66767]	4045	return VERR_BUFFER_OVERFLOW;
	4046	}
	4047	pDirEntry->cbName = 2;
	4048	pDirEntry->szName[0] = '.';
	4049	pDirEntry->szName[1] = '.';
	4050	pDirEntry->szName[2] = '\0';
	4051	}
	4052	else if (pShared->Core.pVol->fIsUtf16)
	4053	{
[67559]	4054	PCRTUTF16 pawcSrc = (PCRTUTF16)&pDirRec->achFileId[0];
	4055	size_t cwcSrc = pDirRec->bFileIdLength / sizeof(RTUTF16);
	4056	size_t cwcVer = !(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)
	4057	? rtFsIso9660GetVersionLengthUtf16Big(pawcSrc, cwcSrc, &uVersion) : 0;
	4058	size_t cchNeeded = 0;
[66768]	4059	size_t cbDst = *pcbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName);
[67559]	4060	char *pszDst = pDirEntry->szName;
	4061
	4062	int rc = RTUtf16BigToUtf8Ex(pawcSrc, cwcSrc - cwcVer, &pszDst, cbDst, &cchNeeded);
	4063	if (RT_SUCCESS(rc))
	4064	pDirEntry->cbName = (uint16_t)cchNeeded;
	4065	else if (rc == VERR_BUFFER_OVERFLOW)
[66767]	4066	{
[67559]	4067	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchNeeded + 1;
[69048]	4068	Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW - cbDst=%zu cchNeeded=%zu (UTF-16BE)\n", cbDst, cchNeeded));
[67559]	4069	return VERR_BUFFER_OVERFLOW;
	4070	}
	4071	else
	4072	{
	4073	ssize_t cchNeeded2 = RTStrPrintf2(pszDst, cbDst, "bad-name-%#x", pThis->offDir);
	4074	if (cchNeeded2 >= 0)
	4075	pDirEntry->cbName = (uint16_t)cchNeeded2;
[66767]	4076	else
	4077	{
[67559]	4078	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + (size_t)-cchNeeded2;
[66767]	4079	return VERR_BUFFER_OVERFLOW;
	4080	}
	4081	}
	4082	}
	4083	else
	4084	{
	4085	/* This is supposed to be upper case ASCII, however, purge the encoding anyway. */
[67559]	4086	size_t cchVer = !(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)
	4087	? rtFsIso9660GetVersionLengthAscii(pDirRec->achFileId, pDirRec->bFileIdLength, &uVersion) : 0;
	4088	size_t cchName = pDirRec->bFileIdLength - cchVer;
	4089	size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchName + 1;
[66767]	4090	if (*pcbDirEntry < cbNeeded)
	4091	{
[69048]	4092	Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (ASCII)\n", *pcbDirEntry, cbNeeded));
[66767]	4093	*pcbDirEntry = cbNeeded;
	4094	return VERR_BUFFER_OVERFLOW;
	4095	}
[67559]	4096	pDirEntry->cbName = (uint16_t)cchName;
	4097	memcpy(pDirEntry->szName, pDirRec->achFileId, cchName);
	4098	pDirEntry->szName[cchName] = '\0';
[66767]	4099	RTStrPurgeEncoding(pDirEntry->szName);
	4100	}
	4101	pDirEntry->cwcShortName = 0;
	4102	pDirEntry->wszShortName[0] = '\0';
	4103
	4104	/*
[68694]	4105	* To avoid duplicating code in rtFsIsoCore_InitFrom9660DirRec and
	4106	* rtFsIsoCore_QueryInfo, we create a dummy RTFSISOCORE on the stack.
[66767]	4107	*/
[68694]	4108	RTFSISOCORE TmpObj;
[66767]	4109	RT_ZERO(TmpObj);
[68694]	4110	rtFsIsoCore_InitFrom9660DirRec(&TmpObj, pDirRec, 1 /* cDirRecs - see below why 1 */,
[94280]	4111	pThis->offDir + pShared->Core.FirstExtent.off, uVersion, NULL, pShared->Core.pVol);
[68694]	4112	int rc = rtFsIsoCore_QueryInfo(&TmpObj, &pDirEntry->Info, enmAddAttr);
[66767]	4113
	4114	/*
[94280]	4115	* Look for rock ridge info associated with this entry
	4116	* and merge that into the record.
	4117	*/
	4118	if (pRockInfo)
	4119	{
	4120	rtFsIsoDirShrd_ParseRockForDirRec(pShared, pDirRec, pRockInfo);
	4121	if (pRockInfo->fValid)
	4122	{
	4123	if ( pRockInfo->fSeenLastNM
	4124	&& pRockInfo->cchName > 0
	4125	&& !pShared->Core.pVol->fIsUtf16
	4126	&& ( pDirRec->bFileIdLength != 1
	4127	\|\| ( pDirRec->achFileId[0] != '\0' /* . */
	4128	&& pDirRec->achFileId[0] != '\1'))) /* .. */
	4129	{
	4130	size_t const cchName = pRockInfo->cchName;
	4131	Assert(strlen(pRockInfo->szName) == cchName);
	4132	size_t const cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchName + 1;
	4133	if (*pcbDirEntry < cbNeeded)
	4134	{
	4135	Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (Rock)\n", *pcbDirEntry, cbNeeded));
	4136	*pcbDirEntry = cbNeeded;
	4137	return VERR_BUFFER_OVERFLOW;
	4138	}
	4139	pDirEntry->cbName = (uint16_t)cchName;
	4140	memcpy(pDirEntry->szName, pRockInfo->szName, cchName);
	4141	pDirEntry->szName[cchName] = '\0';
	4142
	4143	RTStrPurgeEncoding(pDirEntry->szName);
	4144	}
	4145	}
	4146	}
	4147
	4148	/*
[67568]	4149	* Update the directory location and handle multi extent records.
	4150	*
	4151	* Multi extent records only affect the file size and the directory location,
[94280]	4152	* so we deal with it here instead of involving rtFsIsoCore_InitFrom9660DirRec
[67568]	4153	* which would potentially require freeing memory and such.
[66767]	4154	*/
[67568]	4155	if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT))
	4156	{
[69048]	4157	Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc));
[67568]	4158	pThis->offDir += pDirRec->cbDirRec;
	4159	}
	4160	else
	4161	{
	4162	uint32_t cExtents = 1;
	4163	uint32_t offDir = pThis->offDir + pDirRec->cbDirRec;
	4164	while (offDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= pShared->cbDir)
	4165	{
	4166	PCISO9660DIRREC pDirRec2 = (PCISO9660DIRREC)&pShared->pbDir[offDir];
	4167	if (pDirRec2->cbDirRec != 0)
	4168	{
	4169	pDirEntry->Info.cbObject += ISO9660_GET_ENDIAN(&pDirRec2->cbData);
	4170	offDir += pDirRec2->cbDirRec;
	4171	cExtents++;
	4172	if (!(pDirRec2->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT))
	4173	break;
	4174	}
	4175	else
	4176	offDir = (offDir + pShared->Core.pVol->cbSector) & ~(pShared->Core.pVol->cbSector - 1U);
	4177	}
[69048]	4178	Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x, %u extents ending at %#07x: %s (rc=%Rrc)\n",
[67568]	4179	pThis->offDir, cExtents, offDir, pDirEntry->szName, rc));
	4180	pThis->offDir = offDir;
	4181	}
	4182
[66767]	4183	return rc;
	4184	}
	4185	}
	4186
[69048]	4187	Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x: VERR_NO_MORE_FILES\n", pThis->offDir));
[66767]	4188	return VERR_NO_MORE_FILES;
[66735]	4189	}
	4190
	4191
	4192	/**
[69035]	4193	* The UDF worker for rtFsIsoDir_ReadDir
	4194	*/
	4195	static int rtFsIsoDir_ReadDirUdf(PRTFSISODIROBJ pThis, PRTFSISODIRSHRD pShared, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry,
	4196	RTFSOBJATTRADD enmAddAttr)
	4197	{
	4198	/*
	4199	* At offset zero we've got the '.' entry. This has to be generated
	4200	* manually as it's not part of the directory content. The directory
	4201	* offset has to be faked for this too, so offDir == 0 indicates the '.'
	4202	* entry whereas offDir == 1 is the first file id descriptor.
	4203	*/
	4204	if (pThis->offDir == 0)
	4205	{
	4206	if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2)
	4207	{
	4208	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2;
	4209	Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW (dot)\n"));
	4210	return VERR_BUFFER_OVERFLOW;
	4211	}
	4212	pDirEntry->cbName = 1;
	4213	pDirEntry->szName[0] = '.';
	4214	pDirEntry->szName[1] = '\0';
	4215	pDirEntry->cwcShortName = 0;
	4216	pDirEntry->wszShortName[0] = '\0';
	4217
	4218	int rc = rtFsIsoCore_QueryInfo(&pShared->Core, &pDirEntry->Info, enmAddAttr);
	4219
	4220	Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc));
	4221	pThis->offDir = 1;
	4222	return rc;
	4223	}
	4224
	4225	/*
	4226	* Do the directory content.
	4227	*/
	4228	while (pThis->offDir + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) <= pShared->cbDir + 1)
	4229	{
	4230	PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pShared->pbDir[pThis->offDir - 1];
	4231	uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid);
	4232
	4233	if (pThis->offDir + cbFid <= pShared->cbDir + 1)
	4234	{ /* likely */ }
	4235	else
	4236	break;
	4237
	4238	/*
	4239	* Do names first as they may cause overflows.
	4240	*/
	4241	if (pFid->cbName > 1)
	4242	{
	4243	uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid);
	4244	uint32_t cbSrc = pFid->cbName;
	4245	if (*pbName == 8)
	4246	{
	4247	/* Figure out the UTF-8 length first. */
	4248	bool fSimple = true;
	4249	uint32_t cchDst = 0;
	4250	for (uint32_t offSrc = 1; offSrc < cbSrc; offSrc++)
	4251	if (!(pbName[offSrc] & 0x80))
	4252	cchDst++;
	4253	else
	4254	{
	4255	cchDst += 2;
	4256	fSimple = false;
	4257	}
	4258
	4259	size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchDst + 1;
	4260	if (*pcbDirEntry >= cbNeeded)
	4261	{
	4262	if (fSimple)
	4263	{
	4264	Assert(cbSrc - 1 == cchDst);
	4265	memcpy(pDirEntry->szName, &pbName[1], cchDst);
	4266	pDirEntry->szName[cchDst] = '\0';
	4267	}
	4268	else
	4269	{
	4270	char *pszDst = pDirEntry->szName;
	4271	for (uint32_t offSrc = 1; offSrc < cbSrc; offSrc++)
	4272	pszDst = RTStrPutCp(pszDst, pbName[offSrc]);
	4273	*pszDst = '\0';
	4274	Assert((size_t)(pszDst - &pDirEntry->szName[0]) == cchDst);
	4275	}
	4276	}
	4277	else
	4278	{
	4279	Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (8-bit)\n", *pcbDirEntry, cbNeeded));
	4280	*pcbDirEntry = cbNeeded;
	4281	return VERR_BUFFER_OVERFLOW;
	4282	}
	4283	}
	4284	else
	4285	{
	4286	/* Let RTUtf16BigToUtf8Ex do the bounds checking. */
	4287	char *pszDst = pDirEntry->szName;
	4288	size_t cbDst = *pcbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName);
	4289	size_t cchNeeded = 0;
	4290	int rc;
	4291	if (*pbName == 16)
	4292	rc = RTUtf16BigToUtf8Ex((PCRTUTF16)(pbName + 1), (cbSrc - 1) / sizeof(RTUTF16), &pszDst, cbDst, &cchNeeded);
	4293	else
	4294	rc = VERR_INVALID_NAME;
	4295	if (RT_SUCCESS(rc))
	4296	pDirEntry->cbName = (uint16_t)cchNeeded;
	4297	else if (rc == VERR_BUFFER_OVERFLOW)
	4298	{
	4299	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchNeeded + 1;
	4300	Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cchNeeded=%zu (16-bit)\n", cbDst, cchNeeded));
	4301	return VERR_BUFFER_OVERFLOW;
	4302	}
	4303	else
	4304	{
	4305	LogRelMax(90, ("ISO/UDF: Malformed directory entry name at %#x: %.*Rhxs\n", pThis->offDir - 1, cbSrc, pbName));
	4306	ssize_t cchNeeded2 = RTStrPrintf2(pszDst, cbDst, "bad-name-%#x", pThis->offDir - 1);
	4307	if (cchNeeded2 >= 0)
	4308	pDirEntry->cbName = (uint16_t)cchNeeded2;
	4309	else
	4310	{
	4311	*pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + (size_t)-cchNeeded2;
	4312	return VERR_BUFFER_OVERFLOW;
	4313	}
	4314	}
	4315	}
	4316	}
	4317	else if (pFid->fFlags & UDF_FILE_FLAGS_PARENT)
	4318	{
	4319	size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2 + 1;
	4320	if (*pcbDirEntry < cbNeeded)
	4321	{
	4322	Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (dot-dot)\n", *pcbDirEntry, cbNeeded));
	4323	*pcbDirEntry = cbNeeded;
	4324	return VERR_BUFFER_OVERFLOW;
	4325	}
	4326	pDirEntry->cbName = 2;
	4327	pDirEntry->szName[0] = '.';
	4328	pDirEntry->szName[1] = '.';
	4329	pDirEntry->szName[2] = '\0';
	4330	}
	4331	else
	4332	{
	4333	size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 1;
	4334	if (*pcbDirEntry < cbNeeded)
	4335	{
	4336	Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (empty)\n", *pcbDirEntry, cbNeeded));
	4337	*pcbDirEntry = cbNeeded;
	4338	return VERR_BUFFER_OVERFLOW;
	4339	}
	4340	pDirEntry->cbName = 0;
	4341	pDirEntry->szName[0] = '\0';
	4342	}
	4343
	4344	pDirEntry->cwcShortName = 0;
	4345	pDirEntry->wszShortName[0] = '\0';
	4346
	4347	/*
	4348	* To avoid duplicating code in rtFsIsoCore_InitUdf and
	4349	* rtFsIsoCore_QueryInfo, we create a dummy RTFSISOCORE on the stack.
	4350	*/
	4351	RTFSISOCORE TmpObj;
	4352	RT_ZERO(TmpObj);
[69048]	4353	int rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&TmpObj, &pFid->Icb, pFid, pThis->offDir - 1, pShared->Core.pVol);
[69035]	4354	if (RT_SUCCESS(rc))
	4355	{
	4356	rc = rtFsIsoCore_QueryInfo(&TmpObj, &pDirEntry->Info, enmAddAttr);
	4357	rtFsIsoCore_Destroy(&TmpObj);
	4358	}
	4359
	4360	/*
	4361	* Update.
	4362	*/
	4363	Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc));
	4364	pThis->offDir += cbFid;
	4365
	4366	return rc;
	4367	}
	4368
	4369	Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: VERR_NO_MORE_FILES\n", pThis->offDir));
	4370	return VERR_NO_MORE_FILES;
	4371	}
	4372
	4373
	4374	/**
	4375	* @interface_method_impl{RTVFSDIROPS,pfnReadDir}
	4376	*/
	4377	static DECLCALLBACK(int) rtFsIsoDir_ReadDir(void pvThis, PRTDIRENTRYEX pDirEntry, size_t pcbDirEntry,
	4378	RTFSOBJATTRADD enmAddAttr)
	4379	{
	4380	PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis;
	4381	PRTFSISODIRSHRD pShared = pThis->pShared;
[69050]	4382	int rc;
[69035]	4383	if (pShared->Core.pVol->enmType != RTFSISOVOLTYPE_UDF)
[69050]	4384	rc = rtFsIsoDir_ReadDir9660(pThis, pShared, pDirEntry, pcbDirEntry, enmAddAttr);
	4385	else
	4386	rc = rtFsIsoDir_ReadDirUdf(pThis, pShared, pDirEntry, pcbDirEntry, enmAddAttr);
	4387	return rc;
[69035]	4388	}
	4389
	4390
	4391	/**
[69924]	4392	* ISO file operations.
[66735]	4393	*/
[68694]	4394	static const RTVFSDIROPS g_rtFsIsoDirOps =
[66735]	4395	{
	4396	{ /* Obj */
	4397	RTVFSOBJOPS_VERSION,
	4398	RTVFSOBJTYPE_DIR,
	4399	"ISO 9660 Dir",
[68694]	4400	rtFsIsoDir_Close,
	4401	rtFsIsoDir_QueryInfo,
[94291]	4402	NULL,
[66735]	4403	RTVFSOBJOPS_VERSION
	4404	},
	4405	RTVFSDIROPS_VERSION,
	4406	0,
	4407	{ /* ObjSet */
	4408	RTVFSOBJSETOPS_VERSION,
[73097]	4409	RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj),
[69955]	4410	NULL /SetMode/,
	4411	NULL /SetTimes/,
	4412	NULL /SetOwner/,
[66735]	4413	RTVFSOBJSETOPS_VERSION
	4414	},
[69813]	4415	rtFsIsoDir_Open,
[69826]	4416	NULL /* pfnFollowAbsoluteSymlink */,
[69831]	4417	NULL /* pfnOpenFile */,
[69828]	4418	NULL /* pfnOpenDir */,
[68694]	4419	rtFsIsoDir_CreateDir,
	4420	rtFsIsoDir_OpenSymlink,
	4421	rtFsIsoDir_CreateSymlink,
[69828]	4422	NULL /* pfnQueryEntryInfo */,
[68694]	4423	rtFsIsoDir_UnlinkEntry,
	4424	rtFsIsoDir_RenameEntry,
	4425	rtFsIsoDir_RewindDir,
	4426	rtFsIsoDir_ReadDir,
[66735]	4427	RTVFSDIROPS_VERSION,
	4428	};
	4429
	4430
	4431	/**
[66765]	4432	* Adds an open child to the parent directory's shared structure.
[66735]	4433	*
	4434	* Maintains an additional reference to the parent dir to prevent it from going
	4435	* away. If @a pDir is the root directory, it also ensures the volume is
	4436	* referenced and sticks around until the last open object is gone.
	4437	*
	4438	* @param pDir The directory.
	4439	* @param pChild The child being opened.
[68694]	4440	* @sa rtFsIsoDirShrd_RemoveOpenChild
[66735]	4441	*/
[68694]	4442	static void rtFsIsoDirShrd_AddOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild)
[66735]	4443	{
[68694]	4444	rtFsIsoDirShrd_Retain(pDir);
[66735]	4445
	4446	RTListAppend(&pDir->OpenChildren, &pChild->Entry);
	4447	pChild->pParentDir = pDir;
	4448	}
	4449
	4450
	4451	/**
	4452	* Removes an open child to the parent directory.
	4453	*
	4454	* @param pDir The directory.
	4455	* @param pChild The child being removed.
	4456	*
	4457	* @remarks This is the very last thing you do as it may cause a few other
	4458	* objects to be released recursively (parent dir and the volume).
	4459	*
[68694]	4460	* @sa rtFsIsoDirShrd_AddOpenChild
[66735]	4461	*/
[68694]	4462	static void rtFsIsoDirShrd_RemoveOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild)
[66735]	4463	{
	4464	AssertReturnVoid(pChild->pParentDir == pDir);
	4465	RTListNodeRemove(&pChild->Entry);
	4466	pChild->pParentDir = NULL;
	4467
[68694]	4468	rtFsIsoDirShrd_Release(pDir);
[66735]	4469	}
	4470
	4471
	4472	#ifdef LOG_ENABLED
	4473	/**
	4474	* Logs the content of a directory.
	4475	*/
[68694]	4476	static void rtFsIsoDirShrd_Log9660Content(PRTFSISODIRSHRD pThis)
[66735]	4477	{
	4478	if (LogIs2Enabled())
	4479	{
	4480	uint32_t offRec = 0;
	4481	while (offRec < pThis->cbDir)
	4482	{
	4483	PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pThis->pbDir[offRec];
	4484	if (pDirRec->cbDirRec == 0)
	4485	break;
	4486
	4487	RTUTF16 wszName[128];
	4488	if (pThis->Core.pVol->fIsUtf16)
	4489	{
	4490	PRTUTF16 pwszDst = &wszName[pDirRec->bFileIdLength / sizeof(RTUTF16)];
	4491	PCRTUTF16 pwszSrc = (PCRTUTF16)&pDirRec->achFileId[pDirRec->bFileIdLength];
	4492	pwszSrc--;
	4493	*pwszDst-- = '\0';
	4494	while ((uintptr_t)pwszDst >= (uintptr_t)&wszName[0])
	4495	{
	4496	pwszDst = RT_BE2H_U16(pwszSrc);
	4497	pwszDst--;
	4498	pwszSrc--;
	4499	}
	4500	}
	4501	else
	4502	{
	4503	PRTUTF16 pwszDst = wszName;
	4504	for (uint32_t off = 0; off < pDirRec->bFileIdLength; off++)
	4505	*pwszDst++ = pDirRec->achFileId[off];
	4506	*pwszDst = '\0';
	4507	}
	4508
	4509	Log2(("ISO9660: %04x: rec=%#x ea=%#x cb=%#010RX32 off=%#010RX32 fl=%#04x %04u-%02u-%02u %02u:%02u:%02u%+03d unit=%#x igap=%#x idVol=%#x '%ls'\n",
	4510	offRec,
	4511	pDirRec->cbDirRec,
[67326]	4512	pDirRec->cExtAttrBlocks,
[66735]	4513	ISO9660_GET_ENDIAN(&pDirRec->cbData),
	4514	ISO9660_GET_ENDIAN(&pDirRec->offExtent),
	4515	pDirRec->fFileFlags,
	4516	pDirRec->RecTime.bYear + 1900,
	4517	pDirRec->RecTime.bMonth,
	4518	pDirRec->RecTime.bDay,
	4519	pDirRec->RecTime.bHour,
	4520	pDirRec->RecTime.bMinute,
	4521	pDirRec->RecTime.bSecond,
	4522	pDirRec->RecTime.offUtc*4/60,
	4523	pDirRec->bFileUnitSize,
	4524	pDirRec->bInterleaveGapSize,
	4525	ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo),
	4526	wszName));
	4527
[73097]	4528	uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pDirRec->bFileIdLength])
	4529	+ !(pDirRec->bFileIdLength & 1);
[66735]	4530	if (offSysUse < pDirRec->cbDirRec)
	4531	{
[69023]	4532	Log2(("ISO9660: system use (%#x bytes):\n%.*RhxD\n", pDirRec->cbDirRec - offSysUse,
[67774]	4533	pDirRec->cbDirRec - offSysUse, (uint8_t *)pDirRec + offSysUse));
[66735]	4534	}
	4535
	4536	/* advance */
	4537	offRec += pDirRec->cbDirRec;
	4538	}
	4539	}
	4540	}
	4541	#endif /* LOG_ENABLED */
	4542
	4543
	4544	/**
[68694]	4545	* Instantiates a new shared directory structure, given 9660 records.
[66735]	4546	*
	4547	* @returns IPRT status code.
[69924]	4548	* @param pThis The ISO volume instance.
[66735]	4549	* @param pParentDir The parent directory. This is NULL for the root
	4550	* directory.
[67568]	4551	* @param pDirRec The directory record. Will access @a cDirRecs
	4552	* records.
[66735]	4553	* @param cDirRecs Number of directory records if more than one.
	4554	* @param offDirRec The byte offset of the directory record.
[94280]	4555	* @param pRockInfo Optional pointer to rock ridge info for the entry.
[66765]	4556	* @param ppShared Where to return the shared directory structure.
[66735]	4557	*/
[68694]	4558	static int rtFsIsoDirShrd_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec,
[94280]	4559	uint32_t cDirRecs, uint64_t offDirRec, PCRTFSISOROCKINFO pRockInfo, PRTFSISODIRSHRD *ppShared)
[66735]	4560	{
[66765]	4561	/*
	4562	* Allocate a new structure and initialize it.
	4563	*/
	4564	int rc = VERR_NO_MEMORY;
[68694]	4565	PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)RTMemAllocZ(sizeof(*pShared));
[66765]	4566	if (pShared)
[66735]	4567	{
[94280]	4568	rc = rtFsIsoCore_InitFrom9660DirRec(&pShared->Core, pDirRec, cDirRecs, offDirRec, 0 /uVersion/, pRockInfo, pThis);
[67568]	4569	if (RT_SUCCESS(rc))
[66735]	4570	{
[67568]	4571	RTListInit(&pShared->OpenChildren);
	4572	pShared->cbDir = ISO9660_GET_ENDIAN(&pDirRec->cbData);
	4573	pShared->pbDir = (uint8_t *)RTMemAllocZ(pShared->cbDir + 256);
	4574	if (pShared->pbDir)
[66735]	4575	{
[69027]	4576	rc = RTVfsFileReadAt(pThis->hVfsBacking, pShared->Core.FirstExtent.off, pShared->pbDir, pShared->cbDir, NULL);
[67568]	4577	if (RT_SUCCESS(rc))
	4578	{
[66735]	4579	#ifdef LOG_ENABLED
[68694]	4580	rtFsIsoDirShrd_Log9660Content(pShared);
[66735]	4581	#endif
	4582
[67568]	4583	/*
[94280]	4584	* If this is the root directory, check if rock ridge info is present.
	4585	*/
	4586	if ( !pParentDir
	4587	&& !(pThis->fFlags & RTFSISO9660_F_NO_ROCK)
	4588	&& pShared->cbDir > RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]))
	4589	{
	4590	PCISO9660DIRREC pDirRec0 = (PCISO9660DIRREC)pShared->pbDir;
	4591	if ( pDirRec0->bFileIdLength == 1
	4592	&& pDirRec0->achFileId[0] == 0
	4593	&& pDirRec0->cbDirRec > RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]))
	4594	rtFsIsoDirShrd_ParseRockForRoot(pShared, pDirRec0);
	4595	}
	4596
	4597	/*
[67568]	4598	* Link into parent directory so we can use it to update
	4599	* our directory entry.
	4600	*/
	4601	if (pParentDir)
[68694]	4602	rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core);
[67568]	4603	*ppShared = pShared;
	4604	return VINF_SUCCESS;
	4605	}
[66735]	4606	}
[69027]	4607	else
	4608	rc = VERR_NO_MEMORY;
[66735]	4609	}
[67568]	4610	RTMemFree(pShared);
[66735]	4611	}
[66765]	4612	*ppShared = NULL;
	4613	return rc;
	4614	}
	4615
	4616
[69035]	4617	#ifdef LOG_ENABLED
[66765]	4618	/**
[69035]	4619	* Logs the content of a directory.
	4620	*/
	4621	static void rtFsIsoDirShrd_LogUdfContent(PRTFSISODIRSHRD pThis)
	4622	{
	4623	if (LogIs2Enabled())
	4624	{
	4625	uint32_t offDesc = 0;
[73097]	4626	while (offDesc + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) < pThis->cbDir)
[69035]	4627	{
	4628	PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pThis->pbDir[offDesc];
	4629	uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid);
	4630	if (offDesc + cbFid > pThis->cbDir)
	4631	break;
	4632
	4633	uint32_t cwcName = 0;
	4634	RTUTF16 wszName[260];
	4635	if (pFid->cbName > 0)
	4636	{
	4637	uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid);
	4638	uint32_t offSrc = 1;
	4639	if (*pbName == 8)
	4640	while (offSrc < pFid->cbName)
	4641	{
	4642	wszName[cwcName] = pbName[offSrc];
	4643	cwcName++;
	4644	offSrc++;
	4645	}
	4646	else if (*pbName == 16)
	4647	while (offSrc + 1 <= pFid->cbName)
	4648	{
	4649	wszName[cwcName] = RT_MAKE_U16(pbName[offSrc + 1], pbName[offSrc]);
	4650	cwcName++;
	4651	offSrc += 2;
	4652	}
	4653	else
	4654	{
	4655	RTUtf16CopyAscii(wszName, RT_ELEMENTS(wszName), "<bad type>");
	4656	cwcName = 10;
	4657	}
	4658	}
	4659	else if (pFid->fFlags & UDF_FILE_FLAGS_PARENT)
	4660	{
	4661	wszName[0] = '.';
	4662	wszName[1] = '.';
	4663	cwcName = 2;
	4664	}
	4665	else
	4666	{
	4667	RTUtf16CopyAscii(wszName, RT_ELEMENTS(wszName), "<empty>");
	4668	cwcName = 7;
	4669	}
	4670	wszName[cwcName] = '\0';
	4671
	4672	Log2(("ISO/UDF: %04x: fFlags=%#x uVer=%u Icb={%#04x:%#010RX32 LB %#06x t=%u} cbName=%#04x cbIU=%#x '%ls'\n",
	4673	offDesc,
	4674	pFid->fFlags,
	4675	pFid->uVersion,
	4676	pFid->Icb.Location.uPartitionNo,
	4677	pFid->Icb.Location.off,
	4678	pFid->Icb.cb,
	4679	pFid->Icb.uType,
	4680	pFid->cbName,
	4681	pFid->cbImplementationUse,
	4682	wszName));
	4683	int rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pFid->Tag, pThis->cbDir - offDesc,
	4684	UDF_TAG_ID_FILE_ID_DESC, pFid->Tag.offTag, NULL);
	4685	if (RT_FAILURE(rc))
	4686	Log2(("ISO/UDF: Bad Tag: %Rrc - idTag=%#x\n", rc, pFid->Tag.idTag));
	4687	if (pFid->cbImplementationUse > 32)
[69077]	4688	Log2(("ISO/UDF: impl use (%#x bytes):\n%.*RhxD\n",
	4689	pFid->cbImplementationUse, pFid->cbImplementationUse, pFid->abImplementationUse));
[69035]	4690	else if (pFid->cbImplementationUse > 0)
[69077]	4691	Log2(("ISO/UDF: impl use (%#x bytes): %.*Rhxs\n",
	4692	pFid->cbImplementationUse, pFid->cbImplementationUse, pFid->abImplementationUse));
[69035]	4693
	4694	/* advance */
	4695	offDesc += cbFid;
	4696	}
	4697
	4698	if (offDesc < pThis->cbDir)
	4699	Log2(("ISO/UDF: warning! %#x trailing bytes in directory:\n%.*RhxD\n",
	4700	pThis->cbDir - offDesc, pThis->cbDir - offDesc, &pThis->pbDir[offDesc]));
	4701	}
	4702	}
	4703	#endif /* LOG_ENABLED */
	4704
	4705
	4706	/**
[69023]	4707	* Instantiates a new shared directory structure, given UDF descriptors.
[69013]	4708	*
	4709	* @returns IPRT status code.
[69924]	4710	* @param pThis The ISO volume instance.
[69013]	4711	* @param pParentDir The parent directory. This is NULL for the root
	4712	* directory.
[69023]	4713	* @param pAllocDesc The allocation descriptor for the directory ICB.
	4714	* @param pFileIdDesc The file ID descriptor. This is NULL for the root.
[69048]	4715	* @param offInDir The offset of the file ID descriptor in the parent
	4716	* directory. This is used when looking up shared
	4717	* directory objects. (Pass 0 for root.)
[69013]	4718	* @param ppShared Where to return the shared directory structure.
	4719	*/
[69023]	4720	static int rtFsIsoDirShrd_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFLONGAD pAllocDesc,
[69048]	4721	PCUDFFILEIDDESC pFileIdDesc, uintptr_t offInDir, PRTFSISODIRSHRD *ppShared)
[69013]	4722	{
	4723	/*
	4724	* Allocate a new structure and initialize it.
	4725	*/
	4726	int rc = VERR_NO_MEMORY;
	4727	PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)RTMemAllocZ(sizeof(*pShared));
	4728	if (pShared)
	4729	{
[69048]	4730	rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&pShared->Core, pAllocDesc, pFileIdDesc, offInDir, pThis);
[69013]	4731	if (RT_SUCCESS(rc))
	4732	{
	4733	RTListInit(&pShared->OpenChildren);
[69023]	4734
	4735	if (pShared->Core.cbObject < RTFSISO_MAX_DIR_SIZE)
[69013]	4736	{
[69023]	4737	pShared->cbDir = (uint32_t)pShared->Core.cbObject;
[69050]	4738	pShared->pbDir = (uint8_t *)RTMemAllocZ(RT_MAX(RT_ALIGN_32(pShared->cbDir, 512), 512));
[69023]	4739	if (pShared->pbDir)
[69013]	4740	{
[69048]	4741	rc = rtFsIsoCore_ReadWorker(&pShared->Core, 0, pShared->pbDir, pShared->cbDir, NULL, NULL);
[69023]	4742	if (RT_SUCCESS(rc))
	4743	{
[69013]	4744	#ifdef LOG_ENABLED
[69035]	4745	rtFsIsoDirShrd_LogUdfContent(pShared);
[69013]	4746	#endif
	4747
[69023]	4748	/*
	4749	* Link into parent directory so we can use it to update
	4750	* our directory entry.
	4751	*/
	4752	if (pParentDir)
	4753	rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core);
	4754	*ppShared = pShared;
	4755	return VINF_SUCCESS;
	4756	}
[69013]	4757	}
[69027]	4758	else
	4759	rc = VERR_NO_MEMORY;
[69013]	4760	}
	4761	}
	4762	RTMemFree(pShared);
	4763	}
[69023]	4764
[69013]	4765	*ppShared = NULL;
	4766	return rc;
	4767	}
	4768
	4769
	4770	/**
[66765]	4771	* Instantiates a new directory with a shared structure presupplied.
	4772	*
	4773	* @returns IPRT status code.
[69924]	4774	* @param pThis The ISO volume instance.
[66765]	4775	* @param pShared Referenced pointer to the shared structure. The
	4776	* reference is always CONSUMED.
	4777	* @param phVfsDir Where to return the directory handle.
	4778	*/
[68694]	4779	static int rtFsIsoDir_NewWithShared(PRTFSISOVOL pThis, PRTFSISODIRSHRD pShared, PRTVFSDIR phVfsDir)
[66765]	4780	{
	4781	/*
	4782	* Create VFS object around the shared structure.
	4783	*/
[68694]	4784	PRTFSISODIROBJ pNewDir;
	4785	int rc = RTVfsNewDir(&g_rtFsIsoDirOps, sizeof(pNewDir), 0 /fFlags*/, pThis->hVfsSelf,
[66765]	4786	NIL_RTVFSLOCK /use volume lock/, phVfsDir, (void **)&pNewDir);
	4787	if (RT_SUCCESS(rc))
	4788	{
	4789	/*
	4790	* Look for existing shared object, create a new one if necessary.
	4791	* We CONSUME a reference to pShared here.
	4792	*/
	4793	pNewDir->offDir = 0;
	4794	pNewDir->pShared = pShared;
	4795	return VINF_SUCCESS;
	4796	}
	4797
[68694]	4798	rtFsIsoDirShrd_Release(pShared);
[66735]	4799	*phVfsDir = NIL_RTVFSDIR;
	4800	return rc;
	4801	}
	4802
	4803
	4804
[66765]	4805	/**
[68694]	4806	* Instantiates a new directory VFS instance for ISO 9660, creating the shared
	4807	* structure as necessary.
[66765]	4808	*
	4809	* @returns IPRT status code.
[69924]	4810	* @param pThis The ISO volume instance.
[66765]	4811	* @param pParentDir The parent directory. This is NULL for the root
	4812	* directory.
	4813	* @param pDirRec The directory record.
	4814	* @param cDirRecs Number of directory records if more than one.
	4815	* @param offDirRec The byte offset of the directory record.
[94280]	4816	* @param pRockInfo Optional pointer to rock ridge info for the entry.
[66765]	4817	* @param phVfsDir Where to return the directory handle.
	4818	*/
[68694]	4819	static int rtFsIsoDir_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec,
[94280]	4820	uint32_t cDirRecs, uint64_t offDirRec, PCRTFSISOROCKINFO pRockInfo, PRTVFSDIR phVfsDir)
[66765]	4821	{
	4822	/*
	4823	* Look for existing shared object, create a new one if necessary.
	4824	*/
[68694]	4825	PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)rtFsIsoDir_LookupShared(pParentDir, offDirRec);
[66765]	4826	if (!pShared)
	4827	{
[94280]	4828	int rc = rtFsIsoDirShrd_New9660(pThis, pParentDir, pDirRec, cDirRecs, offDirRec, pRockInfo, &pShared);
[66765]	4829	if (RT_FAILURE(rc))
	4830	{
	4831	*phVfsDir = NIL_RTVFSDIR;
	4832	return rc;
	4833	}
	4834	}
[68694]	4835	return rtFsIsoDir_NewWithShared(pThis, pShared, phVfsDir);
[66765]	4836	}
[66735]	4837
[66765]	4838
[69048]	4839	/**
	4840	* Instantiates a new directory VFS instance for UDF, creating the shared
	4841	* structure as necessary.
	4842	*
	4843	* @returns IPRT status code.
[69924]	4844	* @param pThis The ISO volume instance.
[69048]	4845	* @param pParentDir The parent directory.
	4846	* @param pFid The file ID descriptor for the directory.
	4847	* @param phVfsDir Where to return the directory handle.
	4848	*/
	4849	static int rtFsIsoDir_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid, PRTVFSDIR phVfsDir)
	4850	{
	4851	Assert(pFid);
	4852	Assert(pParentDir);
	4853	uintptr_t const offInDir = (uintptr_t)pFid - (uintptr_t)pParentDir->pbDir;
	4854	Assert(offInDir < pParentDir->cbDir);
[66765]	4855
[69048]	4856	/*
	4857	* Look for existing shared object, create a new one if necessary.
	4858	*/
	4859	PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)rtFsIsoDir_LookupShared(pParentDir, offInDir);
	4860	if (!pShared)
	4861	{
	4862	int rc = rtFsIsoDirShrd_NewUdf(pThis, pParentDir, &pFid->Icb, pFid, offInDir, &pShared);
	4863	if (RT_FAILURE(rc))
	4864	{
	4865	*phVfsDir = NIL_RTVFSDIR;
	4866	return rc;
	4867	}
	4868	}
	4869	return rtFsIsoDir_NewWithShared(pThis, pShared, phVfsDir);
	4870	}
	4871
	4872
[66735]	4873	/**
	4874	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose}
	4875	*/
[68694]	4876	static DECLCALLBACK(int) rtFsIsoVol_Close(void *pvThis)
[66735]	4877	{
[68694]	4878	PRTFSISOVOL pThis = (PRTFSISOVOL)pvThis;
	4879	Log(("rtFsIsoVol_Close(%p)\n", pThis));
[66735]	4880
[66765]	4881	if (pThis->pRootDir)
[66735]	4882	{
	4883	Assert(RTListIsEmpty(&pThis->pRootDir->OpenChildren));
[66765]	4884	Assert(pThis->pRootDir->Core.cRefs == 1);
[68694]	4885	rtFsIsoDirShrd_Release(pThis->pRootDir);
[66765]	4886	pThis->pRootDir = NULL;
[66735]	4887	}
	4888
	4889	RTVfsFileRelease(pThis->hVfsBacking);
	4890	pThis->hVfsBacking = NIL_RTVFSFILE;
	4891
[94280]	4892	if (RTCritSectIsInitialized(&pThis->RockBufLock))
	4893	RTCritSectDelete(&pThis->RockBufLock);
	4894
[66735]	4895	return VINF_SUCCESS;
	4896	}
	4897
	4898
	4899	/**
	4900	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo}
	4901	*/
[68694]	4902	static DECLCALLBACK(int) rtFsIsoVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
[66735]	4903	{
	4904	RT_NOREF(pvThis, pObjInfo, enmAddAttr);
	4905	return VERR_WRONG_TYPE;
	4906	}
	4907
	4908
[94291]	4909	static int rtFsIsoVol_ReturnUdfDString(const char pachSrc, size_t cchSrc, void pvDst, size_t cbDst, size_t *pcbRet)
	4910	{
	4911	char pszDst = (char )pvDst;
	4912
	4913	if (pachSrc[0] == 8)
	4914	{
[94292]	4915	size_t const cchText = RT_MIN((uint8_t)pachSrc[cchSrc - 1], cchSrc - 2);
[94291]	4916	size_t const cchActual = RTStrNLen(&pachSrc[1], cchText);
	4917	*pcbRet = cchActual + 1;
	4918	int rc = RTStrCopyEx(pszDst, cbDst, &pachSrc[1], cchActual);
	4919	if (cbDst > 0)
	4920	RTStrPurgeEncoding(pszDst);
	4921	return rc;
	4922	}
	4923
	4924	if (pachSrc[0] == 16)
	4925	{
	4926	PCRTUTF16 pwszSrc = (PCRTUTF16)&pachSrc[1];
	4927	if (cchSrc > 0)
	4928	return RTUtf16BigToUtf8Ex(pwszSrc, (cchSrc - 2) / sizeof(RTUTF16), &pszDst, cchSrc, pcbRet);
	4929	int rc = RTUtf16CalcUtf8LenEx(pwszSrc, (cchSrc - 2) / sizeof(RTUTF16), pcbRet);
	4930	if (RT_SUCCESS(rc))
	4931	{
	4932	*pcbRet += 1;
	4933	return VERR_BUFFER_OVERFLOW;
	4934	}
	4935	return rc;
	4936	}
	4937
	4938	if (ASMMemIsZero(pachSrc, cchSrc))
	4939	{
	4940	*pcbRet = 1;
	4941	if (cbDst >= 1)
	4942	{
	4943	*pszDst = '\0';
	4944	return VINF_SUCCESS;
	4945	}
	4946	return VERR_BUFFER_OVERFLOW;
	4947	}
	4948
	4949	*pcbRet = 0;
	4950	return VERR_INVALID_UTF8_ENCODING; /** @todo better status here */
	4951	}
	4952
	4953
[66735]	4954	/**
[94291]	4955	* For now this is a sanitized version of rtFsIsoVolGetMaybeUtf16Be, which is
	4956	* probably not correct or anything, but will have to do for now.
	4957	*/
	4958	static int rtFsIsoVol_ReturnIso9660D1String(const char pachSrc, size_t cchSrc, void pvDst, size_t cbDst, size_t *pcbRet)
	4959	{
	4960	char pszDst = (char )pvDst;
	4961
	4962	/*
	4963	* Check if it may be some UTF16 variant by scanning for zero bytes
	4964	* (ISO-9660 doesn't allow zeros).
	4965	*/
	4966	size_t cFirstZeros = 0;
	4967	size_t cSecondZeros = 0;
	4968	for (size_t off = 0; off + 1 < cchSrc; off += 2)
	4969	{
	4970	cFirstZeros += pachSrc[off] == '\0';
	4971	cSecondZeros += pachSrc[off + 1] == '\0';
	4972	}
	4973	if (cFirstZeros > cSecondZeros)
	4974	{
	4975	/*
	4976	* UTF-16BE / UTC-2BE:
	4977	*/
	4978	if (cchSrc & 1)
	4979	{
	4980	AssertReturn(pachSrc[cchSrc - 1] == '\0' \|\| pachSrc[cchSrc - 1] == ' ', VERR_INVALID_UTF16_ENCODING);
	4981	cchSrc--;
	4982	}
	4983	while ( cchSrc >= 2
	4984	&& pachSrc[cchSrc - 1] == ' '
	4985	&& pachSrc[cchSrc - 2] == '\0')
	4986	cchSrc -= 2;
	4987
	4988	if (cbDst > 0)
	4989	return RTUtf16BigToUtf8Ex((PCRTUTF16)pachSrc, cchSrc / sizeof(RTUTF16), &pszDst, cbDst, pcbRet);
	4990	int rc = RTUtf16BigCalcUtf8LenEx((PCRTUTF16)pachSrc, cchSrc / sizeof(RTUTF16), pcbRet);
	4991	if (RT_SUCCESS(rc))
	4992	{
	4993	*pcbRet += 1;
	4994	return VERR_BUFFER_OVERFLOW;
	4995	}
	4996	return rc;
	4997	}
	4998
	4999	if (cSecondZeros > 0)
	5000	{
	5001	/*
	5002	* Little endian UTF-16 / UCS-2.
	5003	*/
	5004	if (cchSrc & 1)
	5005	{
	5006	AssertReturn(pachSrc[cchSrc - 1] == '\0' \|\| pachSrc[cchSrc - 1] == ' ', VERR_INVALID_UTF16_ENCODING);
	5007	cchSrc--;
	5008	}
	5009	while ( cchSrc >= 2
	5010	&& pachSrc[cchSrc - 1] == '\0'
	5011	&& pachSrc[cchSrc - 2] == ' ')
	5012	cchSrc -= 2;
	5013
	5014	if (cbDst)
	5015	return RTUtf16LittleToUtf8Ex((PCRTUTF16)pachSrc, cchSrc / sizeof(RTUTF16), &pszDst, cbDst, pcbRet);
	5016	int rc = RTUtf16LittleCalcUtf8LenEx((PCRTUTF16)pachSrc, cchSrc / sizeof(RTUTF16), pcbRet);
	5017	if (RT_SUCCESS(rc))
	5018	{
	5019	*pcbRet += 1;
	5020	return VERR_BUFFER_OVERFLOW;
	5021	}
	5022	return rc;
	5023	}
	5024
	5025	/*
	5026	* ASSUME UTF-8/ASCII.
	5027	*/
	5028	while ( cchSrc > 0
	5029	&& pachSrc[cchSrc - 1] == ' ')
	5030	cchSrc--;
	5031
	5032	*pcbRet = cchSrc + 1;
	5033	int rc = RTStrCopyEx(pszDst, cbDst, pachSrc, cchSrc);
	5034	if (cbDst > 0)
	5035	RTStrPurgeEncoding(pszDst);
	5036	return rc;
	5037	}
	5038
	5039
	5040	static int rtFsIsoVol_ReturnIso9660DString(const char pachSrc, size_t cchSrc, void pvDst, size_t cbDst, size_t *pcbRet)
	5041	{
	5042	/* Lazy bird: */
	5043	return rtFsIsoVol_ReturnIso9660D1String(pachSrc, cchSrc, pvDst, cbDst, pcbRet);
	5044	}
	5045
	5046
	5047	/**
	5048	* @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfoEx}
	5049	*/
	5050	static DECLCALLBACK(int) rtFsIsoVol_QueryInfoEx(void pvThis, RTVFSQIEX enmInfo, void pvInfo, size_t cbInfo, size_t *pcbRet)
	5051	{
	5052	PRTFSISOVOL pThis = (PRTFSISOVOL)pvThis;
	5053	LogFlow(("rtFsIsoVol_QueryInfo(%p, %d,, %#zx,)\n", pThis, enmInfo, cbInfo));
	5054
	5055	union
	5056	{
	5057	uint8_t ab[RTFSISO_MAX_LOGICAL_BLOCK_SIZE];
	5058	ISO9660PRIMARYVOLDESC PriVolDesc;
	5059	ISO9660SUPVOLDESC SupVolDesc;
	5060	} uBuf;
	5061
	5062	switch (enmInfo)
	5063	{
	5064	case RTVFSQIEX_VOL_LABEL:
[96861]	5065	case RTVFSQIEX_VOL_LABEL_ALT:
[94291]	5066	{
[96861]	5067	if (pThis->enmType == RTFSISOVOLTYPE_UDF
	5068	&& ( enmInfo == RTVFSQIEX_VOL_LABEL
	5069	\|\| pThis->offPrimaryVolDesc == 0))
[94291]	5070	return rtFsIsoVol_ReturnUdfDString(pThis->Udf.VolInfo.achLogicalVolumeID,
	5071	sizeof(pThis->Udf.VolInfo.achLogicalVolumeID), pvInfo, cbInfo, pcbRet);
[96861]	5072
	5073	bool const fPrimary = enmInfo == RTVFSQIEX_VOL_LABEL_ALT
	5074	\|\| pThis->enmType == RTFSISOVOLTYPE_ISO9960;
	5075
[94291]	5076	int rc = RTVfsFileReadAt(pThis->hVfsBacking,
[96861]	5077	fPrimary ? pThis->offPrimaryVolDesc : pThis->offSecondaryVolDesc,
[94291]	5078	uBuf.ab, RT_MAX(RT_MIN(pThis->cbSector, sizeof(uBuf)), sizeof(uBuf.PriVolDesc)), NULL);
	5079	AssertRCReturn(rc, rc);
[96861]	5080
	5081	if (fPrimary)
	5082	return rtFsIsoVol_ReturnIso9660DString(uBuf.PriVolDesc.achVolumeId, sizeof(uBuf.PriVolDesc.achVolumeId),
	5083	pvInfo, cbInfo, pcbRet);
	5084	return rtFsIsoVol_ReturnIso9660D1String(uBuf.SupVolDesc.achVolumeId, sizeof(uBuf.SupVolDesc.achVolumeId),
	5085	pvInfo, cbInfo, pcbRet);
[94291]	5086	}
	5087
	5088	default:
	5089	return VERR_NOT_SUPPORTED;
	5090
	5091	}
	5092	}
	5093
	5094
	5095	/**
[69594]	5096	* @interface_method_impl{RTVFSOPS,pfnOpenRoot}
[66735]	5097	*/
[68694]	5098	static DECLCALLBACK(int) rtFsIsoVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir)
[66735]	5099	{
[68694]	5100	PRTFSISOVOL pThis = (PRTFSISOVOL)pvThis;
[66765]	5101
[68694]	5102	rtFsIsoDirShrd_Retain(pThis->pRootDir); /* consumed by the next call */
	5103	return rtFsIsoDir_NewWithShared(pThis, pThis->pRootDir, phVfsDir);
[66735]	5104	}
	5105
	5106
	5107	/**
[69844]	5108	* @interface_method_impl{RTVFSOPS,pfnQueryRangeState}
[66735]	5109	*/
[69844]	5110	static DECLCALLBACK(int) rtFsIsoVol_QueryRangeState(void pvThis, uint64_t off, size_t cb, bool pfUsed)
[66735]	5111	{
	5112	RT_NOREF(pvThis, off, cb, pfUsed);
	5113	return VERR_NOT_IMPLEMENTED;
	5114	}
	5115
	5116
[68694]	5117	DECL_HIDDEN_CONST(const RTVFSOPS) g_rtFsIsoVolOps =
[66735]	5118	{
	5119	{ /* Obj */
	5120	RTVFSOBJOPS_VERSION,
	5121	RTVFSOBJTYPE_VFS,
[68694]	5122	"ISO 9660/UDF",
	5123	rtFsIsoVol_Close,
	5124	rtFsIsoVol_QueryInfo,
[94291]	5125	rtFsIsoVol_QueryInfoEx,
[66735]	5126	RTVFSOBJOPS_VERSION
	5127	},
	5128	RTVFSOPS_VERSION,
	5129	0 /* fFeatures */,
[68694]	5130	rtFsIsoVol_OpenRoot,
[69844]	5131	rtFsIsoVol_QueryRangeState,
[66735]	5132	RTVFSOPS_VERSION
	5133	};
	5134
	5135
[68920]	5136	/**
	5137	* Checks the descriptor tag and CRC.
	5138	*
	5139	* @retval IPRT status code.
	5140	* @retval VERR_ISOFS_TAG_IS_ALL_ZEROS
	5141	* @retval VERR_MISMATCH
	5142	* @retval VERR_ISOFS_UNSUPPORTED_TAG_VERSION
	5143	* @retval VERR_ISOFS_TAG_SECTOR_MISMATCH
	5144	* @retval VERR_ISOFS_BAD_TAG_CHECKSUM
	5145	*
	5146	* @param pTag The tag to check.
	5147	* @param idTag The expected descriptor tag ID, UINT16_MAX matches any
	5148	* tag ID.
	5149	* @param offTag The sector offset of the tag.
	5150	* @param pErrInfo Where to return extended error info.
	5151	*/
[68694]	5152	static int rtFsIsoVolValidateUdfDescTag(PCUDFTAG pTag, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo)
	5153	{
	5154	/*
	5155	* Checksum the tag first.
	5156	*/
	5157	const uint8_t pbTag = (const uint8_t )pTag;
	5158	uint8_t const bChecksum = pbTag[0]
	5159	+ pbTag[1]
	5160	+ pbTag[2]
	5161	+ pbTag[3]
	5162	+ pbTag[5] /* skipping byte 4 as that's the checksum. */
	5163	+ pbTag[6]
	5164	+ pbTag[7]
	5165	+ pbTag[8]
	5166	+ pbTag[9]
	5167	+ pbTag[10]
	5168	+ pbTag[11]
	5169	+ pbTag[12]
	5170	+ pbTag[13]
	5171	+ pbTag[14]
	5172	+ pbTag[15];
	5173	if (pTag->uChecksum == bChecksum)
	5174	{
	5175	/*
	5176	* Do the matching.
	5177	*/
	5178	if ( pTag->uVersion == 3
	5179	\|\| pTag->uVersion == 2)
	5180	{
	5181	if ( pTag->idTag == idTag
	5182	\|\| idTag == UINT16_MAX)
	5183	{
	5184	if (pTag->offTag == offTag)
[68920]	5185	{
[69035]	5186	//Log3(("ISO/UDF: Valid descriptor %#06x at %#010RX32; cbDescriptorCrc=%#06RX32 uTagSerialNo=%#x\n",
	5187	// pTag->idTag, offTag, pTag->cbDescriptorCrc, pTag->uTagSerialNo));
[68694]	5188	return VINF_SUCCESS;
[68920]	5189	}
[66735]	5190
[68694]	5191	Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Sector mismatch: %#RX32 (%.*Rhxs)\n",
	5192	idTag, offTag, pTag->offTag, sizeof(*pTag), pTag));
[69013]	5193	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TAG_SECTOR_MISMATCH,
	5194	"Descriptor tag sector number mismatch: %#x, expected %#x (%.*Rhxs)",
	5195	pTag->offTag, offTag, sizeof(*pTag), pTag);
[68694]	5196	}
	5197	Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Tag ID mismatch: %#x (%.*Rhxs)\n",
	5198	idTag, offTag, pTag->idTag, sizeof(*pTag), pTag));
[69013]	5199	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_MISMATCH, "Descriptor tag ID mismatch: %#x, expected %#x (%.*Rhxs)",
	5200	pTag->idTag, idTag, sizeof(*pTag), pTag);
[68694]	5201	}
[68920]	5202	if (ASMMemIsZero(pTag, sizeof(*pTag)))
	5203	{
	5204	Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): All zeros\n", idTag, offTag));
[69013]	5205	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TAG_IS_ALL_ZEROS, "Descriptor is all zeros");
[68920]	5206	}
	5207
[68694]	5208	Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Unsupported version: %#x (%.*Rhxs)\n",
	5209	idTag, offTag, pTag->uVersion, sizeof(*pTag), pTag));
[69013]	5210	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNSUPPORTED_TAG_VERSION, "Unsupported descriptor tag version: %#x, expected 2 or 3 (%.*Rhxs)",
	5211	pTag->uVersion, sizeof(*pTag), pTag);
[68694]	5212	}
	5213	Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): checksum error: %#x, calc %#x (%.*Rhxs)\n",
	5214	idTag, offTag, pTag->uChecksum, bChecksum, sizeof(*pTag), pTag));
[69013]	5215	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_TAG_CHECKSUM,
	5216	"Descriptor tag checksum error: %#x, calculated %#x (%.*Rhxs)",
	5217	pTag->uChecksum, bChecksum, sizeof(*pTag), pTag);
[68694]	5218	}
	5219
[68920]	5220
	5221	/**
	5222	* Checks the descriptor CRC.
	5223	*
	5224	* @retval VINF_SUCCESS
	5225	* @retval VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC
	5226	* @retval VERR_ISOFS_DESC_CRC_MISMATCH
	5227	*
	5228	* @param pTag The descriptor buffer to checksum.
	5229	* @param cbDesc The size of the descriptor buffer.
	5230	* @param pErrInfo Where to return extended error info.
	5231	*/
	5232	static int rtFsIsoVolValidateUdfDescCrc(PCUDFTAG pTag, size_t cbDesc, PRTERRINFO pErrInfo)
	5233	{
	5234	if (pTag->cbDescriptorCrc + sizeof(*pTag) <= cbDesc)
	5235	{
	5236	uint16_t uCrc = RTCrc16Ccitt(pTag + 1, pTag->cbDescriptorCrc);
	5237	if (pTag->uDescriptorCrc == uCrc)
	5238	return VINF_SUCCESS;
	5239
	5240	Log(("rtFsIsoVolValidateUdfDescCrc(,%#x,%#010RX32,): Descriptor CRC mismatch: expected %#x, calculated %#x (cbDescriptorCrc=%#x)\n",
	5241	pTag->idTag, pTag->offTag, pTag->uDescriptorCrc, uCrc, pTag->cbDescriptorCrc));
[69013]	5242	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_DESC_CRC_MISMATCH,
	5243	"Descriptor CRC mismatch: exepcted %#x, calculated %#x (cbDescriptor=%#x, idTag=%#x, offTag=%#010RX32)",
	5244	pTag->uDescriptorCrc, uCrc, pTag->cbDescriptorCrc, pTag->idTag, pTag->offTag);
[68920]	5245	}
	5246
	5247	Log(("rtFsIsoVolValidateUdfDescCrc(,%#x,%#010RX32,): Insufficient data to CRC: cbDescriptorCrc=%#x cbDesc=%#zx\n",
	5248	pTag->idTag, pTag->offTag, pTag->cbDescriptorCrc, cbDesc));
[69013]	5249	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC,
	5250	"Insufficient data to CRC: cbDescriptorCrc=%#x cbDesc=%#zx (idTag=%#x, offTag=%#010RX32)",
	5251	pTag->cbDescriptorCrc, cbDesc, pTag->idTag, pTag->offTag);
[68920]	5252	}
	5253
	5254
	5255	/**
	5256	* Checks the descriptor tag and CRC.
	5257	*
	5258	* @retval VINF_SUCCESS
	5259	* @retval VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC
	5260	* @retval VERR_ISOFS_TAG_IS_ALL_ZEROS
	5261	* @retval VERR_MISMATCH
	5262	* @retval VERR_ISOFS_UNSUPPORTED_TAG_VERSION
	5263	* @retval VERR_ISOFS_TAG_SECTOR_MISMATCH
	5264	* @retval VERR_ISOFS_BAD_TAG_CHECKSUM
	5265	* @retval VERR_ISOFS_DESC_CRC_MISMATCH
	5266	*
	5267	* @param pTag The descriptor buffer to check the tag of and to
	5268	* checksum.
	5269	* @param cbDesc The size of the descriptor buffer.
	5270	* @param idTag The expected descriptor tag ID, UINT16_MAX
	5271	* matches any tag ID.
	5272	* @param offTag The sector offset of the tag.
	5273	* @param pErrInfo Where to return extended error info.
	5274	*/
	5275	static int rtFsIsoVolValidateUdfDescTagAndCrc(PCUDFTAG pTag, size_t cbDesc, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo)
	5276	{
	5277	int rc = rtFsIsoVolValidateUdfDescTag(pTag, idTag, offTag, pErrInfo);
	5278	if (RT_SUCCESS(rc))
	5279	rc = rtFsIsoVolValidateUdfDescCrc(pTag, cbDesc, pErrInfo);
	5280	return rc;
	5281	}
	5282
	5283
	5284
	5285
[69013]	5286	static int rtFsIsoVolProcessUdfFileSetDescs(PRTFSISOVOL pThis, uint8_t *pbBuf, size_t cbBuf, PRTERRINFO pErrInfo)
	5287	{
[68920]	5288
[69013]	5289	/*
	5290	* We assume there is a single file descriptor and don't bother checking what comes next.
	5291	*/
	5292	PUDFFILESETDESC pFsd = (PUDFFILESETDESC)pbBuf;
	5293	Assert(cbBuf > sizeof(*pFsd)); NOREF(cbBuf);
	5294	RT_ZERO(*pFsd);
	5295	size_t cbToRead = RT_MAX(pThis->Udf.VolInfo.FileSetDescriptor.cb, sizeof(*pFsd));
	5296	int rc = rtFsIsoVolUdfVpRead(pThis, pThis->Udf.VolInfo.FileSetDescriptor.Location.uPartitionNo,
	5297	pThis->Udf.VolInfo.FileSetDescriptor.Location.off, 0, pFsd, cbToRead);
	5298	if (RT_SUCCESS(rc))
	5299	{
	5300	rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pFsd->Tag, cbToRead, UDF_TAG_ID_FILE_SET_DESC,
	5301	pThis->Udf.VolInfo.FileSetDescriptor.Location.off, pErrInfo);
	5302	if (RT_SUCCESS(rc))
	5303	{
	5304	#ifdef LOG_ENABLED
	5305	Log(("ISO/UDF: File set descriptor at %#RX32 (%#RX32:%#RX32)\n", pFsd->Tag.offTag,
	5306	pThis->Udf.VolInfo.FileSetDescriptor.Location.uPartitionNo,
	5307	pThis->Udf.VolInfo.FileSetDescriptor.Location.off));
	5308	if (LogIs2Enabled())
	5309	{
	5310	UDF_LOG2_MEMBER_TIMESTAMP(pFsd, RecordingTimestamp);
	5311	UDF_LOG2_MEMBER(pFsd, "#06RX16", uInterchangeLevel);
	5312	UDF_LOG2_MEMBER(pFsd, "#06RX16", uMaxInterchangeLevel);
	5313	UDF_LOG2_MEMBER(pFsd, "#010RX32", fCharacterSets);
	5314	UDF_LOG2_MEMBER(pFsd, "#010RX32", fMaxCharacterSets);
	5315	UDF_LOG2_MEMBER(pFsd, "#010RX32", uFileSetNo);
	5316	UDF_LOG2_MEMBER(pFsd, "#010RX32", uFileSetDescNo);
	5317	UDF_LOG2_MEMBER_CHARSPEC(pFsd, LogicalVolumeIDCharSet);
	5318	UDF_LOG2_MEMBER_DSTRING(pFsd, achLogicalVolumeID);
	5319	UDF_LOG2_MEMBER_CHARSPEC(pFsd, FileSetCharSet);
	5320	UDF_LOG2_MEMBER_DSTRING(pFsd, achFileSetID);
	5321	UDF_LOG2_MEMBER_DSTRING(pFsd, achCopyrightFile);
	5322	UDF_LOG2_MEMBER_DSTRING(pFsd, achAbstractFile);
	5323	UDF_LOG2_MEMBER_LONGAD(pFsd, RootDirIcb);
	5324	UDF_LOG2_MEMBER_ENTITY_ID(pFsd, idDomain);
	5325	UDF_LOG2_MEMBER_LONGAD(pFsd, NextExtent);
	5326	UDF_LOG2_MEMBER_LONGAD(pFsd, SystemStreamDirIcb);
	5327	if (!ASMMemIsZero(&pFsd->abReserved[0], sizeof(pFsd->abReserved)))
[69077]	5328	UDF_LOG2_MEMBER(pFsd, ".32Rhxs", abReserved);
[69013]	5329	}
	5330	#endif
[68920]	5331
[69013]	5332	/*
	5333	* Do some basic sanity checking.
	5334	*/
	5335	if (!UDF_IS_CHAR_SET_OSTA(&pFsd->FileSetCharSet))
	5336	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_UNSUPPORTED_CHAR_SET,
	5337	"Invalid file set charset %.64Rhxs", &pFsd->FileSetCharSet);
	5338	if ( pFsd->RootDirIcb.cb == 0
	5339	\|\| pFsd->RootDirIcb.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED)
	5340	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_ZERO_ROOT_DIR,
	5341	"Root Dir ICB location is zero or malformed: uType=%#x cb=%#x loc=%#x:%#RX32",
	5342	pFsd->RootDirIcb.uType, pFsd->RootDirIcb.cb,
	5343	pFsd->RootDirIcb.Location.uPartitionNo, pFsd->RootDirIcb.Location.off);
	5344	if ( pFsd->NextExtent.cb != 0
	5345	&& pFsd->NextExtent.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED)
	5346	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_NEXT_EXTENT,
	5347	"NextExtent isn't zero: uType=%#x cb=%#x loc=%#x:%#RX32",
	5348	pFsd->NextExtent.uType, pFsd->NextExtent.cb,
	5349	pFsd->NextExtent.Location.uPartitionNo, pFsd->NextExtent.Location.off);
	5350
	5351	/*
	5352	* Copy the information we need.
	5353	*/
	5354	pThis->Udf.VolInfo.RootDirIcb = pFsd->RootDirIcb;
	5355	if ( pFsd->SystemStreamDirIcb.cb > 0
	5356	&& pFsd->SystemStreamDirIcb.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED)
	5357	pThis->Udf.VolInfo.SystemStreamDirIcb = pFsd->SystemStreamDirIcb;
	5358	else
	5359	RT_ZERO(pThis->Udf.VolInfo.SystemStreamDirIcb);
	5360	return VINF_SUCCESS;
	5361	}
	5362	return rc;
	5363	}
	5364	return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading file set descriptor");
	5365	}
	5366
	5367
[68920]	5368	/**
[69013]	5369	* Check validatity and extract information from the descriptors in the VDS seq.
	5370	*
	5371	* @returns IPRT status code
	5372	* @param pThis The instance.
	5373	* @param pInfo The VDS sequence info.
	5374	* @param pErrInfo Where to return extended error info.
	5375	*/
	5376	static int rtFsIsoVolProcessUdfVdsSeqInfo(PRTFSISOVOL pThis, PRTFSISOVDSINFO pInfo, PRTERRINFO pErrInfo)
	5377	{
	5378	/*
	5379	* Check the basic descriptor counts.
	5380	*/
	5381	PUDFPRIMARYVOLUMEDESC pPvd;
	5382	if (pInfo->cPrimaryVols == 1)
	5383	pPvd = pInfo->apPrimaryVols[0];
	5384	else
	5385	{
	5386	if (pInfo->cPrimaryVols == 0)
	5387	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_PVD, "No primary volume descriptor was found");
	5388	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MULTIPLE_PVDS,
	5389	"More than one primary volume descriptor was found: %u", pInfo->cPrimaryVols);
	5390	}
	5391
	5392	PUDFLOGICALVOLUMEDESC pLvd;
	5393	if (pInfo->cLogicalVols == 1)
	5394	pLvd = pInfo->apLogicalVols[0];
	5395	else
	5396	{
	5397	if (pInfo->cLogicalVols == 0)
	5398	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_LVD, "No logical volume descriptor was found");
	5399	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MULTIPLE_LVDS,
	5400	"More than one logical volume descriptor was found: %u", pInfo->cLogicalVols);
	5401	}
	5402
	5403	#if 0
	5404	if (pInfo->cPartitions == 0)
	5405	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_PD, "No partition descriptors was found");
	5406	#endif
	5407
	5408	/*
	5409	* Check out the partition map in the logical volume descriptor.
	5410	* Produce the mapping table while going about that.
	5411	*/
	5412	if (pLvd->cPartitionMaps > 64)
	5413	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TOO_MANY_PART_MAPS,
	5414	"Too many partition maps: %u (max 64)", pLvd->cPartitionMaps);
	5415
	5416	PRTFSISOVOLUDFPMAP paPartMaps = NULL;
	5417	if (pLvd->cPartitionMaps > 0)
	5418	{
	5419	pInfo->paPartMaps = paPartMaps = (PRTFSISOVOLUDFPMAP)RTMemAllocZ(sizeof(paPartMaps[0]) * pLvd->cPartitionMaps);
	5420	if (!paPartMaps)
	5421	return VERR_NO_MEMORY;
	5422	}
	5423	uint32_t cPartMaps = 0;
	5424
	5425	if (pLvd->cbMapTable)
	5426	{
	5427	uint32_t off = 0;
	5428	while (off + sizeof(UDFPARTMAPHDR) <= pLvd->cbMapTable)
	5429	{
	5430	PCUDFPARTMAPHDR pHdr = (PCUDFPARTMAPHDR)&pLvd->abPartitionMaps[off];
	5431
	5432	/*
	5433	* Bounds checking.
	5434	*/
	5435	if (off + pHdr->cb > pLvd->cbMapTable)
	5436	{
	5437	if (cPartMaps < pLvd->cbMapTable)
	5438	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MALFORMED_PART_MAP_TABLE,
	5439	"Incomplete partition map entry at offset %#x: cb=%#x -> offEnd=%#x cbMapTable=%#x (type=%#x)",
	5440	off, pHdr->cb, off + pHdr->cb, pLvd->cbMapTable, pHdr->bType);
	5441	LogRel(("ISO/UDF: Warning: Incomplete partition map entry at offset %#x: cb=%#x -> offEnd=%#x cbMapTable=%#x (type=%#x)\n",
	5442	off, pHdr->cb, off + pHdr->cb, pLvd->cbMapTable, pHdr->bType));
	5443	break;
	5444	}
	5445	if (cPartMaps >= pLvd->cPartitionMaps)
	5446	{
	5447	LogRel(("ISO/UDF: Warning: LVD::cPartitionMaps is %u but there are more bytes in the table. (off=%#x cb=%#x cbMapTable=%#x bType=%#x)\n",
[69023]	5448	cPartMaps - pLvd->cPartitionMaps, off, pHdr->cb, pLvd->cbMapTable, pHdr->bType));
[69013]	5449	break;
	5450	}
	5451
	5452	/*
	5453	* Extract relevant info out of the entry.
	5454	*/
	5455	paPartMaps[cPartMaps].offMapTable = (uint16_t)off;
	5456	uint16_t uPartitionNo;
	5457	if (pHdr->bType == 1)
	5458	{
	5459	PCUDFPARTMAPTYPE1 pType1 = (PCUDFPARTMAPTYPE1)pHdr;
	5460	paPartMaps[cPartMaps].uVolumeSeqNo = pType1->uVolumeSeqNo;
	5461	paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_PLAIN;
	5462	uPartitionNo = pType1->uPartitionNo;
	5463	}
	5464	else if (pHdr->bType == 2)
	5465	{
	5466	PCUDFPARTMAPTYPE2 pType2 = (PCUDFPARTMAPTYPE2)pHdr;
	5467	if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_VPM_PARTITION_TYPE))
	5468	{
	5469	paPartMaps[cPartMaps].bType = pType2->idPartitionType.Suffix.Udf.uUdfRevision >= 0x200
	5470	? RTFSISO_UDF_PMAP_T_VPM_20 : RTFSISO_UDF_PMAP_T_VPM_15;
	5471	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_VPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported",
	5472	pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision);
	5473	}
	5474	else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_SPM_PARTITION_TYPE))
	5475	{
	5476	paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_SPM;
	5477	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_SPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported",
	5478	pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision);
	5479	}
	5480	else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_MPM_PARTITION_TYPE))
	5481	{
	5482	paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_MPM;
	5483	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported",
	5484	pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision);
	5485	}
	5486	else
	5487	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNKNOWN_PART_MAP_TYPE_ID,
	5488	"Unknown partition map ID for #%u @ %#x: %.23s",
	5489	cPartMaps, off, pType2->idPartitionType.achIdentifier);
	5490	#if 0 /* unreachable code */
	5491	paPartMaps[cPartMaps].uVolumeSeqNo = pType2->uVolumeSeqNo;
	5492	uPartitionNo = pType2->uPartitionNo;
	5493	#endif
	5494	}
	5495	else
	5496	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNKNOWN_PART_MAP_ENTRY_TYPE,
	5497	"Unknown partition map entry type #%u @ %#x: %u", cPartMaps, off, pHdr->bType);
	5498	paPartMaps[cPartMaps].uPartitionNo = uPartitionNo;
	5499
	5500	/*
	5501	* Lookup the partition number and retrieve the relevant info from the partition descriptor.
	5502	*/
	5503	uint32_t i = pInfo->cPartitions;
	5504	while (i-- > 0)
	5505	{
	5506	PUDFPARTITIONDESC pPd = pInfo->apPartitions[i];
	5507	if (paPartMaps[cPartMaps].uPartitionNo == pPd->uPartitionNo)
	5508	{
	5509	paPartMaps[cPartMaps].idxPartDesc = (uint16_t)i;
	5510	paPartMaps[cPartMaps].cSectors = pPd->cSectors;
	5511	paPartMaps[cPartMaps].offLocation = pPd->offLocation;
	5512	paPartMaps[cPartMaps].offByteLocation = (uint64_t)pPd->offLocation * pThis->cbSector;
	5513	paPartMaps[cPartMaps].fFlags = pPd->fFlags;
	5514	paPartMaps[cPartMaps].uAccessType = pPd->uAccessType;
	5515	if (!UDF_ENTITY_ID_EQUALS(&pPd->PartitionContents, UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF))
	5516	paPartMaps[cPartMaps].fHaveHdr = false;
	5517	else
	5518	{
	5519	paPartMaps[cPartMaps].fHaveHdr = true;
	5520	paPartMaps[cPartMaps].Hdr = pPd->ContentsUse.Hdr;
	5521	}
	5522	break;
	5523	}
	5524	}
	5525	if (i > pInfo->cPartitions)
	5526	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_PARTITION_NOT_FOUND,
	5527	"Partition #%u (%#x) specified by mapping entry #%u (@ %#x) was not found! (int-type %u)",
	5528	uPartitionNo, uPartitionNo, cPartMaps, off, paPartMaps[cPartMaps].bType);
	5529
	5530	/*
	5531	* Advance.
	5532	*/
	5533	cPartMaps++;
	5534	off += pHdr->cb;
	5535	}
	5536
	5537	if (cPartMaps < pLvd->cPartitionMaps)
	5538	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_INCOMPLETE_PART_MAP_TABLE,
	5539	"Only found %u of the %u announced partition mapping table entries",
	5540	cPartMaps, pLvd->cPartitionMaps);
	5541	}
	5542
	5543	/* It might be theoretically possible to not use virtual partitions for
	5544	accessing data, so just warn if there aren't any. */
	5545	if (cPartMaps == 0)
	5546	LogRel(("ISO/UDF: Warning: No partition maps!\n"));
	5547
	5548	/*
	5549	* Check out the logical volume descriptor.
	5550	*/
	5551	if ( pLvd->cbLogicalBlock < pThis->cbSector
[69023]	5552	\|\| pLvd->cbLogicalBlock > RTFSISO_MAX_LOGICAL_BLOCK_SIZE
[69013]	5553	\|\| (pLvd->cbLogicalBlock % pThis->cbSector) != 0)
	5554	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNSUPPORTED_LOGICAL_BLOCK_SIZE,
	5555	"Logical block size of %#x is not supported with a sector size of %#x",
	5556	pLvd->cbLogicalBlock, pThis->cbSector);
	5557
	5558	if (!UDF_ENTITY_ID_EQUALS(&pLvd->idDomain, UDF_ENTITY_ID_LVD_DOMAIN))
	5559	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_DOMAIN_ID,
	5560	"Unsupported domain ID in logical volume descriptor: '%.23s'", pLvd->idDomain.achIdentifier);
	5561
	5562	if ( pLvd->ContentsUse.FileSetDescriptor.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED
	5563	\|\| pLvd->ContentsUse.FileSetDescriptor.cb == 0
	5564	\|\| pLvd->ContentsUse.FileSetDescriptor.Location.uPartitionNo >= cPartMaps)
	5565	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_FILE_SET_DESC_LOCATION,
	5566	"Malformed file set descriptor location (type=%u cb=%#x part=%#x)",
	5567	pLvd->ContentsUse.FileSetDescriptor.uType,
	5568	pLvd->ContentsUse.FileSetDescriptor.cb,
	5569	pLvd->ContentsUse.FileSetDescriptor.Location.uPartitionNo);
	5570
	5571	bool fLvdHaveVolId = !ASMMemIsZero(pLvd->achLogicalVolumeID, sizeof(pLvd->achLogicalVolumeID));
	5572	if ( fLvdHaveVolId
	5573	&& !UDF_IS_CHAR_SET_OSTA(&pLvd->DescCharSet))
	5574	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_DESC_CHAR_SET,
	5575	"Logical volume ID is not using OSTA compressed unicode");
	5576
	5577	/*
	5578	* We can ignore much, if not all of the primary volume descriptor.
	5579	*/
	5580
	5581	/*
	5582	* We're good. So copy over the data.
	5583	*/
	5584	pThis->Udf.VolInfo.FileSetDescriptor = pLvd->ContentsUse.FileSetDescriptor;
	5585	pThis->Udf.VolInfo.cbBlock = pLvd->cbLogicalBlock;
	5586	pThis->Udf.VolInfo.cShiftBlock = 9;
	5587	while (pThis->Udf.VolInfo.cbBlock != RT_BIT_32(pThis->Udf.VolInfo.cShiftBlock))
	5588	pThis->Udf.VolInfo.cShiftBlock++;
	5589	pThis->Udf.VolInfo.fFlags = pPvd->fFlags;
	5590	pThis->Udf.VolInfo.cPartitions = cPartMaps;
	5591	pThis->Udf.VolInfo.paPartitions = paPartMaps;
	5592	pInfo->paPartMaps = NULL;
	5593	if (fLvdHaveVolId)
	5594	memcpy(pThis->Udf.VolInfo.achLogicalVolumeID, pLvd->achLogicalVolumeID, sizeof(pThis->Udf.VolInfo.achLogicalVolumeID));
	5595	else
	5596	RT_ZERO(pThis->Udf.VolInfo.achLogicalVolumeID);
	5597
	5598	return VINF_SUCCESS;
	5599	}
	5600
	5601
	5602	/**
[68920]	5603	* Processes a primary volume descriptor in the VDS (UDF).
	5604	*
	5605	* @returns IPRT status code.
[69013]	5606	* @param pInfo Where we gather descriptor information.
[68920]	5607	* @param pDesc The descriptor.
	5608	* @param pErrInfo Where to return extended error information.
	5609	*/
	5610	//cmd: kmk VBoxRT && kmk_redirect -E VBOX_LOG_DEST="nofile stderr" -E VBOX_LOG="rt_fs=~0" -E VBOX_LOG_FLAGS="unbuffered enabled" -- e:\vbox\svn\trunk\out\win.amd64\debug\bin\tools\RTLs.exe :iprtvfs:file(open,d:\Downloads\en_windows_10_enterprise_version_1703_updated_march_2017_x64_dvd_10189290.iso,r):vfs(isofs):/ -la
[69013]	5611	static int rtFsIsoVolProcessUdfPrimaryVolDesc(PRTFSISOVDSINFO pInfo, PCUDFPRIMARYVOLUMEDESC pDesc, PRTERRINFO pErrInfo)
[68920]	5612	{
	5613	#ifdef LOG_ENABLED
	5614	Log(("ISO/UDF: Primary volume descriptor at sector %#RX32\n", pDesc->Tag.offTag));
	5615	if (LogIs2Enabled())
	5616	{
	5617	UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo);
	5618	UDF_LOG2_MEMBER(pDesc, "#010RX32", uPrimaryVolumeDescNo);
	5619	UDF_LOG2_MEMBER_DSTRING(pDesc, achVolumeID);
	5620	UDF_LOG2_MEMBER(pDesc, "#06RX16", uVolumeSeqNo);
	5621	UDF_LOG2_MEMBER(pDesc, "#06RX16", uVolumeSeqNo);
	5622	UDF_LOG2_MEMBER(pDesc, "#06RX16", uMaxVolumeSeqNo);
	5623	UDF_LOG2_MEMBER(pDesc, "#06RX16", uInterchangeLevel);
	5624	UDF_LOG2_MEMBER(pDesc, "#06RX16", uMaxInterchangeLevel);
	5625	UDF_LOG2_MEMBER(pDesc, "#010RX32", fCharacterSets);
	5626	UDF_LOG2_MEMBER(pDesc, "#010RX32", fMaxCharacterSets);
	5627	UDF_LOG2_MEMBER_DSTRING(pDesc, achVolumeSetID);
	5628	UDF_LOG2_MEMBER_CHARSPEC(pDesc, DescCharSet);
	5629	UDF_LOG2_MEMBER_CHARSPEC(pDesc, ExplanatoryCharSet);
	5630	UDF_LOG2_MEMBER_EXTENTAD(pDesc, VolumeAbstract);
	5631	UDF_LOG2_MEMBER_EXTENTAD(pDesc, VolumeCopyrightNotice);
	5632	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idApplication);
	5633	UDF_LOG2_MEMBER_TIMESTAMP(pDesc, RecordingTimestamp);
	5634	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation);
	5635	if (!ASMMemIsZero(&pDesc->abImplementationUse, sizeof(pDesc->abImplementationUse)))
	5636	Log2(("ISO/UDF: %-32s %.64Rhxs\n", "abReserved[64]:", &pDesc->abImplementationUse[0]));
	5637	UDF_LOG2_MEMBER(pDesc, "#010RX32", offPredecessorVolDescSeq);
	5638	UDF_LOG2_MEMBER(pDesc, "#06RX16", fFlags);
	5639	if (!ASMMemIsZero(&pDesc->abReserved, sizeof(pDesc->abReserved)))
	5640	Log2(("ISO/UDF: %-32s %.22Rhxs\n", "abReserved[22]:", &pDesc->abReserved[0]));
	5641	}
	5642	#endif
	5643
[69013]	5644	/*
	5645	* Check if this is a new revision of an existing primary volume descriptor.
	5646	*/
	5647	PUDFPRIMARYVOLUMEDESC pEndianConvert = NULL;
	5648	uint32_t i = pInfo->cPrimaryVols;
	5649	while (i--> 0)
	5650	{
	5651	if ( memcmp(pDesc->achVolumeID, pInfo->apPrimaryVols[i]->achVolumeID, sizeof(pDesc->achVolumeID)) == 0
	5652	&& memcmp(&pDesc->DescCharSet, &pInfo->apPrimaryVols[i]->DescCharSet, sizeof(pDesc->DescCharSet)) == 0)
	5653	{
	5654	if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apPrimaryVols[i]->uVolumeDescSeqNo)
	5655	{
	5656	Log(("ISO/UDF: Primary descriptor prevails over previous! (%u >= %u)\n",
	5657	RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo));
	5658	pEndianConvert = pInfo->apPrimaryVols[i];
	5659	memcpy(pEndianConvert, pDesc, sizeof(*pDesc));
	5660	}
	5661	else
	5662	Log(("ISO/UDF: Primary descriptor has lower sequence number than the previous! (%u < %u)\n",
	5663	RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo));
	5664	break;
	5665	}
	5666	}
	5667	if (i >= pInfo->cPrimaryVols)
	5668	{
	5669	/*
	5670	* It wasn't. Append it.
	5671	*/
	5672	i = pInfo->cPrimaryVols;
	5673	if (i < RT_ELEMENTS(pInfo->apPrimaryVols))
	5674	{
	5675	pInfo->apPrimaryVols[i] = pEndianConvert = (PUDFPRIMARYVOLUMEDESC)RTMemDup(pDesc, sizeof(*pDesc));
	5676	if (pEndianConvert)
	5677	pInfo->cPrimaryVols = i + 1;
	5678	else
	5679	return VERR_NO_MEMORY;
	5680	Log2(("ISO/UDF: ++New primary descriptor.\n"));
	5681	}
	5682	else
	5683	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_PVDS, "Encountered too many primary volume descriptors");
	5684	}
	5685
	5686	#ifdef RT_BIG_ENDIAN
	5687	/*
	5688	* Do endian conversion of the descriptor.
	5689	*/
	5690	if (pEndianConvert)
	5691	{
	5692	AssertFailed();
	5693	}
	5694	#else
	5695	RT_NOREF(pEndianConvert);
	5696	#endif
[68920]	5697	return VINF_SUCCESS;
	5698	}
	5699
	5700
	5701	/**
	5702	* Processes an logical volume descriptor in the VDS (UDF).
	5703	*
	5704	* @returns IPRT status code.
[69013]	5705	* @param pInfo Where we gather descriptor information.
[68920]	5706	* @param pDesc The descriptor.
[69013]	5707	* @param cbSector The sector size (UDF defines the logical and physical
	5708	* sector size to be the same).
[68920]	5709	* @param pErrInfo Where to return extended error information.
	5710	*/
[69013]	5711	static int rtFsIsoVolProcessUdfLogicalVolumeDesc(PRTFSISOVDSINFO pInfo, PCUDFLOGICALVOLUMEDESC pDesc,
	5712	uint32_t cbSector, PRTERRINFO pErrInfo)
[68920]	5713	{
	5714	#ifdef LOG_ENABLED
	5715	Log(("ISO/UDF: Logical volume descriptor at sector %#RX32\n", pDesc->Tag.offTag));
	5716	if (LogIs2Enabled())
	5717	{
	5718	UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo);
[69013]	5719	UDF_LOG2_MEMBER_CHARSPEC(pDesc, DescCharSet);
[68920]	5720	UDF_LOG2_MEMBER_DSTRING(pDesc, achLogicalVolumeID);
	5721	UDF_LOG2_MEMBER(pDesc, "#010RX32", cbLogicalBlock);
	5722	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idDomain);
[69013]	5723	if (UDF_ENTITY_ID_EQUALS(&pDesc->idDomain, UDF_ENTITY_ID_LVD_DOMAIN))
[68920]	5724	UDF_LOG2_MEMBER_LONGAD(pDesc, ContentsUse.FileSetDescriptor);
	5725	else if (!ASMMemIsZero(&pDesc->ContentsUse.ab[0], sizeof(pDesc->ContentsUse.ab)))
	5726	Log2(("ISO/UDF: %-32s %.16Rhxs\n", "ContentsUse.ab[16]:", &pDesc->ContentsUse.ab[0]));
	5727	UDF_LOG2_MEMBER(pDesc, "#010RX32", cbMapTable);
	5728	UDF_LOG2_MEMBER(pDesc, "#010RX32", cPartitionMaps);
	5729	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation);
	5730	if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab)))
[69023]	5731	Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ImplementationUse.ab[128]:", &pDesc->ImplementationUse.ab[0]));
[68920]	5732	UDF_LOG2_MEMBER_EXTENTAD(pDesc, IntegritySeqExtent);
	5733	if (pDesc->cbMapTable)
	5734	{
	5735	Log2(("ISO/UDF: %-32s\n", "abPartitionMaps"));
	5736	uint32_t iMap = 0;
	5737	uint32_t off = 0;
	5738	while (off + sizeof(UDFPARTMAPHDR) <= pDesc->cbMapTable)
	5739	{
	5740	PCUDFPARTMAPHDR pHdr = (PCUDFPARTMAPHDR)&pDesc->abPartitionMaps[off];
	5741	Log2(("ISO/UDF: %02u @ %#05x: type %u, length %u\n", iMap, off, pHdr->bType, pHdr->cb));
	5742	if (off + pHdr->cb > pDesc->cbMapTable)
	5743	{
	5744	Log2(("ISO/UDF: BAD! Entry is %d bytes too long!\n", off + pHdr->cb - pDesc->cbMapTable));
	5745	break;
	5746	}
	5747	if (pHdr->bType == 1)
	5748	{
	5749	PCUDFPARTMAPTYPE1 pType1 = (PCUDFPARTMAPTYPE1)pHdr;
	5750	UDF_LOG2_MEMBER_EX(pType1, "#06RX16", uVolumeSeqNo, 5);
	5751	UDF_LOG2_MEMBER_EX(pType1, "#06RX16", uPartitionNo, 5);
	5752	}
	5753	else if (pHdr->bType == 2)
	5754	{
	5755	PCUDFPARTMAPTYPE2 pType2 = (PCUDFPARTMAPTYPE2)pHdr;
	5756	UDF_LOG2_MEMBER_ENTITY_ID_EX(pType2, idPartitionType, 5);
	5757	UDF_LOG2_MEMBER_EX(pType2, "#06RX16", uVolumeSeqNo, 5);
	5758	UDF_LOG2_MEMBER_EX(pType2, "#06RX16", uPartitionNo, 5);
[69059]	5759	if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_SPM_PARTITION_TYPE))
	5760	{
	5761	UDF_LOG2_MEMBER_EX(&pType2->u, "#06RX16", Spm.cBlocksPerPacket, 5);
	5762	UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Spm.cSparingTables, 5);
	5763	if (pType2->u.Spm.bReserved2)
	5764	UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Spm.bReserved2, 5);
	5765	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.cbSparingTable, 5);
	5766	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[0], 5);
	5767	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[1], 5);
	5768	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[2], 5);
	5769	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[3], 5);
	5770	}
	5771	else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_MPM_PARTITION_TYPE))
	5772	{
	5773	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataFile, 5);
	5774	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataMirrorFile, 5);
	5775	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataBitmapFile, 5);
	5776	UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.cBlocksAllocationUnit, 5);
	5777	UDF_LOG2_MEMBER_EX(&pType2->u, "#06RX16", Mpm.cBlocksAlignmentUnit, 5);
	5778	UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Mpm.fFlags, 5);
	5779	if (!ASMMemIsZero(pType2->u.Mpm.abReserved2, sizeof(pType2->u.Mpm.abReserved2)))
	5780	UDF_LOG2_MEMBER_EX(&pType2->u, ".5Rhxs", Mpm.abReserved2, 5);
	5781	}
[68920]	5782	}
	5783	else
	5784	Log2(("ISO/UDF: BAD! Unknown type!\n"));
	5785
	5786	/* advance */
	5787	off += pHdr->cb;
	5788	iMap++;
	5789	}
	5790	}
	5791	}
	5792	#endif
	5793
[69013]	5794	/*
	5795	* Check if this is a newer revision of an existing primary volume descriptor.
	5796	*/
	5797	size_t cbDesc = (size_t)pDesc->cbMapTable + RT_UOFFSETOF(UDFLOGICALVOLUMEDESC, abPartitionMaps);
	5798	if ( pDesc->cbMapTable >= (UINT32_MAX >> 1)
	5799	\|\| cbDesc > cbSector)
	5800	{
	5801	Log(("ISO/UDF: Logical volume descriptor is too big: %#zx (cbSector=%#x)\n", cbDesc, cbSector));
	5802	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TOO_BIT_PARTMAP_IN_LVD,
	5803	"Logical volume descriptor is too big: %#zx (cbSector=%#x)\n", cbDesc, cbSector);
	5804	}
	5805
	5806	PUDFLOGICALVOLUMEDESC pEndianConvert = NULL;
	5807	uint32_t i = pInfo->cLogicalVols;
	5808	while (i--> 0)
	5809	if ( memcmp(pDesc->achLogicalVolumeID, pInfo->apLogicalVols[i]->achLogicalVolumeID,
	5810	sizeof(pDesc->achLogicalVolumeID)) == 0
	5811	&& memcmp(&pDesc->DescCharSet, &pInfo->apLogicalVols[i]->DescCharSet,
	5812	sizeof(pDesc->DescCharSet)) == 0)
	5813	{
	5814	if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apLogicalVols[i]->uVolumeDescSeqNo)
	5815	{
	5816	Log(("ISO/UDF: Logical descriptor prevails over previous! (%u >= %u)\n",
	5817	RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apLogicalVols[i]->uVolumeDescSeqNo));
	5818	pEndianConvert = (PUDFLOGICALVOLUMEDESC)RTMemDup(pDesc, cbDesc);
	5819	if (!pEndianConvert)
	5820	return VERR_NO_MEMORY;
	5821	RTMemFree(pInfo->apLogicalVols[i]);
	5822	pInfo->apLogicalVols[i] = pEndianConvert;
	5823	}
	5824	else
	5825	Log(("ISO/UDF: Logical descriptor has lower sequence number than the previous! (%u >= %u)\n",
	5826	RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apLogicalVols[i]->uVolumeDescSeqNo));
	5827	break;
	5828	}
	5829	if (i >= pInfo->cLogicalVols)
	5830	{
	5831	/*
	5832	* It wasn't. Append it.
	5833	*/
	5834	i = pInfo->cLogicalVols;
	5835	if (i < RT_ELEMENTS(pInfo->apLogicalVols))
	5836	{
	5837	pInfo->apLogicalVols[i] = pEndianConvert = (PUDFLOGICALVOLUMEDESC)RTMemDup(pDesc, cbDesc);
	5838	if (pEndianConvert)
	5839	pInfo->cLogicalVols = i + 1;
	5840	else
	5841	return VERR_NO_MEMORY;
	5842	Log2(("ISO/UDF: ++New logical volume descriptor.\n"));
	5843	}
	5844	else
	5845	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_LVDS, "Too many logical volume descriptors");
	5846	}
	5847
	5848	#ifdef RT_BIG_ENDIAN
	5849	/*
	5850	* Do endian conversion of the descriptor.
	5851	*/
	5852	if (pEndianConvert)
	5853	{
	5854	AssertFailed();
	5855	}
	5856	#else
	5857	RT_NOREF(pEndianConvert);
	5858	#endif
[68920]	5859	return VINF_SUCCESS;
	5860	}
	5861
	5862
	5863	/**
	5864	* Processes an partition descriptor in the VDS (UDF).
	5865	*
	5866	* @returns IPRT status code.
[69013]	5867	* @param pInfo Where we gather descriptor information.
[68920]	5868	* @param pDesc The descriptor.
	5869	* @param pErrInfo Where to return extended error information.
	5870	*/
[69013]	5871	static int rtFsIsoVolProcessUdfPartitionDesc(PRTFSISOVDSINFO pInfo, PCUDFPARTITIONDESC pDesc, PRTERRINFO pErrInfo)
[68920]	5872	{
	5873	#ifdef LOG_ENABLED
	5874	Log(("ISO/UDF: Partition descriptor at sector %#RX32\n", pDesc->Tag.offTag));
	5875	if (LogIs2Enabled())
	5876	{
	5877	UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo);
	5878	UDF_LOG2_MEMBER(pDesc, "#06RX16", fFlags);
	5879	UDF_LOG2_MEMBER(pDesc, "#06RX16", uPartitionNo);
	5880	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, PartitionContents);
[69013]	5881	if (UDF_ENTITY_ID_EQUALS(&pDesc->PartitionContents, UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF))
[68920]	5882	{
	5883	UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.UnallocatedSpaceTable);
	5884	UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.UnallocatedSpaceBitmap);
	5885	UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.PartitionIntegrityTable);
	5886	UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.FreedSpaceTable);
	5887	UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.FreedSpaceBitmap);
	5888	if (!ASMMemIsZero(&pDesc->ContentsUse.Hdr.abReserved[0], sizeof(pDesc->ContentsUse.Hdr.abReserved)))
[69023]	5889	Log2(("ISO/UDF: %-32s\n%.88RhxD\n", "Hdr.abReserved[88]:", &pDesc->ContentsUse.Hdr.abReserved[0]));
[68920]	5890	}
	5891	else if (!ASMMemIsZero(&pDesc->ContentsUse.ab[0], sizeof(pDesc->ContentsUse.ab)))
[69023]	5892	Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ContentsUse.ab[128]:", &pDesc->ContentsUse.ab[0]));
[68920]	5893	UDF_LOG2_MEMBER(pDesc, "#010RX32", uAccessType);
	5894	UDF_LOG2_MEMBER(pDesc, "#010RX32", offLocation);
	5895	UDF_LOG2_MEMBER(pDesc, "#010RX32", cSectors);
	5896	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation);
	5897	if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab)))
[69023]	5898	Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ImplementationUse.ab[128]:", &pDesc->ImplementationUse.ab[0]));
[68920]	5899
	5900	if (!ASMMemIsZero(&pDesc->abReserved[0], sizeof(pDesc->abReserved)))
[69023]	5901	Log2(("ISO/UDF: %-32s\n%.156RhxD\n", "ImplementationUse.ab[156]:", &pDesc->abReserved[0]));
[68920]	5902	}
	5903	#endif
	5904
[69013]	5905	/*
	5906	* Check if this is a newer revision of an existing primary volume descriptor.
	5907	*/
	5908	PUDFPARTITIONDESC pEndianConvert = NULL;
	5909	uint32_t i = pInfo->cPartitions;
	5910	while (i--> 0)
	5911	if (pDesc->uPartitionNo == pInfo->apPartitions[i]->uPartitionNo)
	5912	{
	5913	if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apPartitions[i]->uVolumeDescSeqNo)
	5914	{
	5915	Log(("ISO/UDF: Partition descriptor for part %#u prevails over previous! (%u >= %u)\n",
	5916	pDesc->uPartitionNo, RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo));
	5917	pEndianConvert = pInfo->apPartitions[i];
	5918	memcpy(pEndianConvert, pDesc, sizeof(*pDesc));
	5919	}
	5920	else
	5921	Log(("ISO/UDF: Partition descriptor for part %#u has a lower sequence number than the previous! (%u < %u)\n",
	5922	pDesc->uPartitionNo, RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo));
	5923	break;
	5924	}
	5925	if (i >= pInfo->cPartitions)
	5926	{
	5927	/*
	5928	* It wasn't. Append it.
	5929	*/
	5930	i = pInfo->cPartitions;
	5931	if (i < RT_ELEMENTS(pInfo->apPartitions))
	5932	{
	5933	pInfo->apPartitions[i] = pEndianConvert = (PUDFPARTITIONDESC)RTMemDup(pDesc, sizeof(*pDesc));
	5934	if (pEndianConvert)
	5935	pInfo->cPartitions = i + 1;
	5936	else
	5937	return VERR_NO_MEMORY;
	5938	Log2(("ISO/UDF: ++New partition descriptor.\n"));
	5939	}
	5940	else
	5941	return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_PDS, "Too many physical volume descriptors");
	5942	}
	5943
	5944	#ifdef RT_BIG_ENDIAN
	5945	/*
	5946	* Do endian conversion of the descriptor.
	5947	*/
	5948	if (pEndianConvert)
	5949	{
	5950	AssertFailed();
	5951	}
	5952	#else
	5953	RT_NOREF(pEndianConvert);
	5954	#endif
[68920]	5955	return VINF_SUCCESS;
	5956	}
	5957
	5958
	5959	/**
	5960	* Processes an implementation use descriptor in the VDS (UDF).
	5961	*
	5962	* @returns IPRT status code.
[69013]	5963	* @param pInfo Where we gather descriptor information.
[68920]	5964	* @param pDesc The descriptor.
	5965	* @param pErrInfo Where to return extended error information.
	5966	*/
[69013]	5967	static int rtFsIsoVolProcessUdfImplUseVolDesc(PRTFSISOVDSINFO pInfo, PCUDFIMPLEMENTATIONUSEVOLUMEDESC pDesc, PRTERRINFO pErrInfo)
[68920]	5968	{
	5969	#ifdef LOG_ENABLED
	5970	Log(("ISO/UDF: Implementation use volume descriptor at sector %#RX32\n", pDesc->Tag.offTag));
	5971	if (LogIs2Enabled())
	5972	{
	5973	UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo);
	5974	UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation);
[69013]	5975	if (UDF_ENTITY_ID_EQUALS(&pDesc->idImplementation, UDF_ENTITY_ID_IUVD_IMPLEMENTATION))
[68920]	5976	{
	5977	UDF_LOG2_MEMBER_CHARSPEC(&pDesc->ImplementationUse, Lvi.Charset);
	5978	UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achVolumeID);
	5979	UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo1);
	5980	UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo2);
	5981	UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo3);
	5982	UDF_LOG2_MEMBER_ENTITY_ID(&pDesc->ImplementationUse, Lvi.idImplementation);
	5983	if (!ASMMemIsZero(&pDesc->ImplementationUse.Lvi.abUse[0], sizeof(pDesc->ImplementationUse.Lvi.abUse)))
[69023]	5984	Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "Lvi.abUse[128]:", &pDesc->ImplementationUse.Lvi.abUse[0]));
[68920]	5985	}
	5986	else if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab)))
[69023]	5987	Log2(("ISO/UDF: %-32s\n%.460RhxD\n", "ImplementationUse.ab[460]:", &pDesc->ImplementationUse.ab[0]));
[68920]	5988	}
	5989	#endif
	5990
[69013]	5991	RT_NOREF(pInfo, pDesc, pErrInfo);
[68920]	5992	return VINF_SUCCESS;
	5993	}
	5994
	5995
	5996
[68694]	5997	typedef struct RTFSISOSEENSEQENCES
	5998	{
	5999	/** Number of sequences we've seen thus far. */
	6000	uint32_t cSequences;
	6001	/** The per sequence data. */
	6002	struct
	6003	{
	6004	uint64_t off; /*< Byte offset of the sequence. /
	6005	uint32_t cb; /*< Size of the sequence. /
	6006	} aSequences[8];
	6007	} RTFSISOSEENSEQENCES;
	6008	typedef RTFSISOSEENSEQENCES *PRTFSISOSEENSEQENCES;
	6009
	6010
[69013]	6011
[68694]	6012	/**
	6013	* Process a VDS sequence, recursively dealing with volume descriptor pointers.
	6014	*
[69013]	6015	* This function only gathers information from the sequence, handling the
	6016	* prevailing descriptor fun.
	6017	*
[68920]	6018	* @returns IPRT status code.
	6019	* @param pThis The instance.
[69013]	6020	* @param pInfo Where to store info from the VDS sequence.
[68920]	6021	* @param offSeq The byte offset of the sequence.
	6022	* @param cbSeq The length of the sequence.
	6023	* @param pbBuf Read buffer.
	6024	* @param cbBuf Size of the read buffer. This is at least one
	6025	* sector big.
[68694]	6026	* @param cNestings The VDS nesting depth.
[68920]	6027	* @param pErrInfo Where to return extended error info.
[68694]	6028	*/
[69013]	6029	static int rtFsIsoVolReadAndProcessUdfVdsSeq(PRTFSISOVOL pThis, PRTFSISOVDSINFO pInfo, uint64_t offSeq, uint32_t cbSeq,
	6030	uint8_t *pbBuf, size_t cbBuf, uint32_t cNestings, PRTERRINFO pErrInfo)
[68694]	6031	{
[68697]	6032	AssertReturn(cbBuf >= pThis->cbSector, VERR_INTERNAL_ERROR);
[68694]	6033
	6034	/*
	6035	* Check nesting depth.
	6036	*/
	6037	if (cNestings > 5)
[69013]	6038	return RTERRINFO_LOG_SET(pErrInfo, VERR_TOO_MUCH_DATA, "The volume descriptor sequence (VDS) is nested too deeply.");
[68694]	6039
	6040
	6041	/*
	6042	* Do the processing sector by sector to keep things simple.
	6043	*/
	6044	uint32_t offInSeq = 0;
	6045	while (offInSeq < cbSeq)
	6046	{
	6047	int rc;
	6048
	6049	/*
	6050	* Read the next sector. Zero pad if less that a sector.
	6051	*/
	6052	Assert((offInSeq & (pThis->cbSector - 1)) == 0);
	6053	rc = RTVfsFileReadAt(pThis->hVfsBacking, offSeq + offInSeq, pbBuf, pThis->cbSector, NULL);
	6054	if (RT_FAILURE(rc))
[69013]	6055	return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Error reading VDS content at %RX64 (LB %#x): %Rrc",
	6056	offSeq + offInSeq, pThis->cbSector, rc);
[68694]	6057	if (cbSeq - offInSeq < pThis->cbSector)
	6058	memset(&pbBuf[cbSeq - offInSeq], 0, pThis->cbSector - (cbSeq - offInSeq));
	6059
	6060	/*
	6061	* Check tag.
	6062	*/
	6063	PCUDFTAG pTag = (PCUDFTAG)pbBuf;
[68920]	6064	rc = rtFsIsoVolValidateUdfDescTagAndCrc(pTag, pThis->cbSector, UINT16_MAX, (offSeq + offInSeq) / pThis->cbSector, pErrInfo);
	6065	if ( RT_SUCCESS(rc)
	6066	\|\| ( rc == VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC
	6067	&& ( pTag->idTag == UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC
	6068	\|\| pTag->idTag == UDF_TAG_ID_LOGICAL_VOLUME_DESC
	6069	\|\| pTag->idTag == UDF_TAG_ID_UNALLOCATED_SPACE_DESC
	6070	)
	6071	)
	6072	)
[68694]	6073	{
[68920]	6074	switch (pTag->idTag)
	6075	{
	6076	case UDF_TAG_ID_PRIMARY_VOL_DESC:
[69013]	6077	rc = rtFsIsoVolProcessUdfPrimaryVolDesc(pInfo, (PCUDFPRIMARYVOLUMEDESC)pTag, pErrInfo);
[68920]	6078	break;
[68694]	6079
[68991]	6080	case UDF_TAG_ID_IMPLEMENTATION_USE_VOLUME_DESC:
[69013]	6081	rc = rtFsIsoVolProcessUdfImplUseVolDesc(pInfo, (PCUDFIMPLEMENTATIONUSEVOLUMEDESC)pTag, pErrInfo);
[68920]	6082	break;
	6083
	6084	case UDF_TAG_ID_PARTITION_DESC:
[69013]	6085	rc = rtFsIsoVolProcessUdfPartitionDesc(pInfo, (PCUDFPARTITIONDESC)pTag, pErrInfo);
[68920]	6086	break;
	6087
	6088	case UDF_TAG_ID_LOGICAL_VOLUME_DESC:
[69013]	6089	if (rc != VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC)
	6090	rc = rtFsIsoVolProcessUdfLogicalVolumeDesc(pInfo, (PCUDFLOGICALVOLUMEDESC)pTag,
	6091	pThis->cbSector, pErrInfo);
	6092	else
	6093	rc = VERR_ISOFS_TOO_BIT_PARTMAP_IN_LVD;
[68920]	6094	break;
	6095
	6096	case UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC:
	6097	Log(("ISO/UDF: Ignoring logical volume integrity descriptor at offset %#RX64.\n", offSeq + offInSeq));
	6098	rc = VINF_SUCCESS;
	6099	break;
	6100
	6101	case UDF_TAG_ID_UNALLOCATED_SPACE_DESC:
	6102	Log(("ISO/UDF: Ignoring unallocated space descriptor at offset %#RX64.\n", offSeq + offInSeq));
	6103	rc = VINF_SUCCESS;
	6104	break;
	6105
	6106	case UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR:
	6107	Log(("ISO/UDF: Ignoring AVDP in VDS (at offset %#RX64).\n", offSeq + offInSeq));
	6108	rc = VINF_SUCCESS;
	6109	break;
	6110
	6111	case UDF_TAG_ID_VOLUME_DESC_PTR:
	6112	{
	6113	PCUDFVOLUMEDESCPTR pVdp = (PCUDFVOLUMEDESCPTR)pTag;
	6114	Log(("ISO/UDF: Processing volume descriptor pointer at offset %#RX64: %#x LB %#x (seq %#x); cNestings=%d\n",
	6115	offSeq + offInSeq, pVdp->NextVolumeDescSeq.off, pVdp->NextVolumeDescSeq.cb,
	6116	pVdp->uVolumeDescSeqNo, cNestings));
[69013]	6117	rc = rtFsIsoVolReadAndProcessUdfVdsSeq(pThis, pInfo, (uint64_t)pVdp->NextVolumeDescSeq.off * pThis->cbSector,
[68920]	6118	pVdp->NextVolumeDescSeq.cb, pbBuf, cbBuf, cNestings + 1, pErrInfo);
	6119	break;
	6120	}
	6121
	6122	case UDF_TAG_ID_TERMINATING_DESC:
	6123	Log(("ISO/UDF: Terminating descriptor at offset %#RX64\n", offSeq + offInSeq));
	6124	return VINF_SUCCESS;
	6125
	6126	default:
[69013]	6127	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNEXPECTED_VDS_DESC,
	6128	"Unexpected/unknown VDS descriptor %#x at byte offset %#RX64",
	6129	pThis->cbSector, offSeq + offInSeq);
[68920]	6130	}
[69013]	6131	if (RT_FAILURE(rc))
	6132	return rc;
[68694]	6133	}
[68920]	6134	/* The descriptor sequence is usually zero padded to 16 sectors. Just
	6135	ignore zero descriptors. */
	6136	else if (rc != VERR_ISOFS_TAG_IS_ALL_ZEROS)
	6137	return rc;
[68694]	6138
	6139	/*
	6140	* Advance.
	6141	*/
	6142	offInSeq += pThis->cbSector;
	6143	}
	6144
	6145	return VINF_SUCCESS;
	6146	}
	6147
	6148
	6149
	6150	/**
	6151	* Processes a volume descriptor sequence (VDS).
	6152	*
	6153	* @returns IPRT status code.
	6154	* @param pThis The instance.
	6155	* @param offSeq The byte offset of the sequence.
	6156	* @param cbSeq The length of the sequence.
	6157	* @param pSeenSequences Structure where to keep track of VDSes we've already
	6158	* processed, to avoid redoing one that we don't
	6159	* understand.
	6160	* @param pbBuf Read buffer.
	6161	* @param cbBuf Size of the read buffer. This is at least one
	6162	* sector big.
	6163	* @param pErrInfo Where to report extended error information.
	6164	*/
	6165	static int rtFsIsoVolReadAndProcessUdfVds(PRTFSISOVOL pThis, uint64_t offSeq, uint32_t cbSeq,
	6166	PRTFSISOSEENSEQENCES pSeenSequences, uint8_t *pbBuf, size_t cbBuf,
	6167	PRTERRINFO pErrInfo)
	6168	{
	6169	/*
	6170	* Skip if already seen.
	6171	*/
	6172	uint32_t i = pSeenSequences->cSequences;
	6173	while (i-- > 0)
	6174	if ( pSeenSequences->aSequences[i].off == offSeq
	6175	&& pSeenSequences->aSequences[i].cb == cbSeq)
	6176	return VERR_NOT_FOUND;
	6177
	6178	/* Not seen, so add it. */
	6179	Assert(pSeenSequences->cSequences + 1 <= RT_ELEMENTS(pSeenSequences->aSequences));
	6180	pSeenSequences->aSequences[pSeenSequences->cSequences].cb = cbSeq;
	6181	pSeenSequences->aSequences[pSeenSequences->cSequences].off = offSeq;
	6182	pSeenSequences->cSequences++;
	6183
[68920]	6184	LogFlow(("ISO/UDF: Processing anchor volume descriptor sequence at offset %#RX64 LB %#RX32\n", offSeq, cbSeq));
[68694]	6185
	6186	/*
[69013]	6187	* Gather relevant descriptor info from the VDS then process it and on
	6188	* success copy it into the instance.
[68695]	6189	*
	6190	* The processing has to be done in a different function because there may
	6191	* be links to sub-sequences that needs to be processed. We do this by
	6192	* recursing and check that we don't go to deep.
[68694]	6193	*/
[69013]	6194	RTFSISOVDSINFO Info;
	6195	RT_ZERO(Info);
	6196	int rc = rtFsIsoVolReadAndProcessUdfVdsSeq(pThis, &Info, offSeq, cbSeq, pbBuf, cbBuf, 0, pErrInfo);
	6197	if (RT_SUCCESS(rc))
	6198	{
	6199	rc = rtFsIsoVolProcessUdfVdsSeqInfo(pThis, &Info, pErrInfo);
	6200	if (RT_SUCCESS(rc))
	6201	rc = rtFsIsoVolProcessUdfFileSetDescs(pThis, pbBuf, cbBuf, pErrInfo);
	6202	}
[68694]	6203
[69013]	6204	/*
	6205	* Clean up info.
	6206	*/
	6207	i = Info.cPrimaryVols;
	6208	while (i-- > 0)
	6209	RTMemFree(Info.apPrimaryVols[i]);
[68695]	6210
[69013]	6211	i = Info.cLogicalVols;
	6212	while (i-- > 0)
	6213	RTMemFree(Info.apLogicalVols[i]);
	6214
	6215	i = Info.cPartitions;
	6216	while (i-- > 0)
	6217	RTMemFree(Info.apPartitions[i]);
	6218
	6219	RTMemFree(Info.paPartMaps);
	6220
	6221	return rc;
[68694]	6222	}
	6223
	6224
	6225	static int rtFsIsoVolReadAndHandleUdfAvdp(PRTFSISOVOL pThis, uint64_t offAvdp, uint8_t *pbBuf, size_t cbBuf,
	6226	PRTFSISOSEENSEQENCES pSeenSequences, PRTERRINFO pErrInfo)
	6227	{
	6228	/*
	6229	* Try read the descriptor and validate its tag.
	6230	*/
	6231	PUDFANCHORVOLUMEDESCPTR pAvdp = (PUDFANCHORVOLUMEDESCPTR)pbBuf;
	6232	size_t cbAvdpRead = RT_MIN(pThis->cbSector, cbBuf);
	6233	int rc = RTVfsFileReadAt(pThis->hVfsBacking, offAvdp, pAvdp, cbAvdpRead, NULL);
	6234	if (RT_SUCCESS(rc))
	6235	{
	6236	rc = rtFsIsoVolValidateUdfDescTag(&pAvdp->Tag, UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR, offAvdp / pThis->cbSector, pErrInfo);
	6237	if (RT_SUCCESS(rc))
	6238	{
	6239	Log2(("ISO/UDF: AVDP: MainVolumeDescSeq=%#RX32 LB %#RX32, ReserveVolumeDescSeq=%#RX32 LB %#RX32\n",
	6240	pAvdp->MainVolumeDescSeq.off, pAvdp->MainVolumeDescSeq.cb,
	6241	pAvdp->ReserveVolumeDescSeq.off, pAvdp->ReserveVolumeDescSeq.cb));
	6242
	6243	/*
	6244	* Try the main sequence if it looks sane.
	6245	*/
	6246	UDFEXTENTAD const ReserveVolumeDescSeq = pAvdp->ReserveVolumeDescSeq;
	6247	if ( pAvdp->MainVolumeDescSeq.off < pThis->cBackingSectors
	6248	&& (uint64_t)pAvdp->MainVolumeDescSeq.off
	6249	+ (pAvdp->MainVolumeDescSeq.cb + pThis->cbSector - 1) / pThis->cbSector
	6250	<= pThis->cBackingSectors)
	6251	{
	6252	rc = rtFsIsoVolReadAndProcessUdfVds(pThis, (uint64_t)pAvdp->MainVolumeDescSeq.off * pThis->cbSector,
	6253	pAvdp->MainVolumeDescSeq.cb, pSeenSequences, pbBuf, cbBuf, pErrInfo);
	6254	if (RT_SUCCESS(rc))
	6255	return rc;
	6256	}
	6257	else
[69013]	6258	rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_FOUND,
	6259	"MainVolumeDescSeq is out of bounds: sector %#RX32 LB %#RX32 bytes, image is %#RX64 sectors",
	6260	pAvdp->MainVolumeDescSeq.off, pAvdp->MainVolumeDescSeq.cb, pThis->cBackingSectors);
[68694]	6261	if (ReserveVolumeDescSeq.cb > 0)
	6262	{
	6263	if ( ReserveVolumeDescSeq.off < pThis->cBackingSectors
	6264	&& (uint64_t)ReserveVolumeDescSeq.off
	6265	+ (ReserveVolumeDescSeq.cb + pThis->cbSector - 1) / pThis->cbSector
	6266	<= pThis->cBackingSectors)
	6267	{
	6268	rc = rtFsIsoVolReadAndProcessUdfVds(pThis, (uint64_t)ReserveVolumeDescSeq.off * pThis->cbSector,
	6269	ReserveVolumeDescSeq.cb, pSeenSequences, pbBuf, cbBuf, pErrInfo);
	6270	if (RT_SUCCESS(rc))
	6271	return rc;
	6272	}
	6273	else if (RT_SUCCESS(rc))
[69013]	6274	rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_FOUND,
	6275	"ReserveVolumeDescSeq is out of bounds: sector %#RX32 LB %#RX32 bytes, image is %#RX64 sectors",
	6276	ReserveVolumeDescSeq.off, ReserveVolumeDescSeq.cb, pThis->cBackingSectors);
[68694]	6277	}
	6278	}
	6279	}
	6280	else
[69013]	6281	rc = RTERRINFO_LOG_SET_F(pErrInfo, rc,
	6282	"Error reading sector at offset %#RX64 (anchor volume descriptor pointer): %Rrc", offAvdp, rc);
[68694]	6283
	6284	return rc;
	6285	}
	6286
	6287
	6288	/**
	6289	* Goes looking for UDF when we've seens a volume recognition sequence.
	6290	*
	6291	* @returns IPRT status code.
	6292	* @param pThis The volume instance data.
	6293	* @param puUdfLevel The UDF level indicated by the VRS.
	6294	* @param offUdfBootVolDesc The offset of the BOOT2 descriptor, UINT64_MAX
	6295	* if not encountered.
	6296	* @param pbBuf Buffer for reading into.
	6297	* @param cbBuf The size of the buffer. At least one sector.
	6298	* @param pErrInfo Where to return extended error info.
	6299	*/
	6300	static int rtFsIsoVolHandleUdfDetection(PRTFSISOVOL pThis, uint8_t *puUdfLevel, uint64_t offUdfBootVolDesc,
	6301	uint8_t *pbBuf, size_t cbBuf, PRTERRINFO pErrInfo)
	6302	{
	6303	NOREF(offUdfBootVolDesc);
	6304
	6305	/*
	6306	* There are up to three anchor volume descriptor pointers that can give us
	6307	* two different descriptor sequences each. Usually, the different AVDP
	6308	* structures points to the same two sequences. The idea here is that
	6309	* sectors may deteriorate and become unreadable, and we're supposed to try
	6310	* out alternative sectors to get the job done. If we really took this
	6311	* seriously, we could try read all sequences in parallel and use the
	6312	* sectors that are good. However, we'll try keep things reasonably simple
	6313	* since we'll most likely be reading from hard disks rather than optical
	6314	* media.
	6315	*
	6316	* We keep track of which sequences we've processed so we don't try to do it
	6317	* again when alternative AVDP sectors points to the same sequences.
	6318	*/
[69013]	6319	pThis->Udf.uLevel = *puUdfLevel;
[84155]	6320	RTFSISOSEENSEQENCES SeenSequences;
	6321	RT_ZERO(SeenSequences);
[69013]	6322	int rc1 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, 256 * pThis->cbSector, pbBuf, cbBuf,
	6323	&SeenSequences, pErrInfo);
	6324	if (RT_SUCCESS(rc1))
	6325	return rc1;
	6326
	6327	int rc2 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, pThis->cbBacking - 256 * pThis->cbSector,
	6328	pbBuf, cbBuf, &SeenSequences, pErrInfo);
	6329	if (RT_SUCCESS(rc2))
	6330	return rc2;
	6331
	6332	int rc3 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, pThis->cbBacking - pThis->cbSector,
	6333	pbBuf, cbBuf, &SeenSequences, pErrInfo);
	6334	if (RT_SUCCESS(rc3))
	6335	return rc3;
	6336
	6337	/*
	6338	* Return failure if the alternatives have been excluded.
	6339	*
	6340	* Note! The error info won't be correct here.
	6341	*/
	6342	pThis->Udf.uLevel = *puUdfLevel = 0;
	6343
	6344	if (RTFSISO9660_F_IS_ONLY_TYPE(pThis->fFlags, RTFSISO9660_F_NO_UDF))
	6345	return rc1 != VERR_NOT_FOUND ? rc1 : rc2 != VERR_NOT_FOUND ? rc2 : rc3;
[68694]	6346	return VINF_SUCCESS;
	6347	}
	6348
	6349
	6350
[66735]	6351	#ifdef LOG_ENABLED
	6352
	6353	/** Logging helper. */
[68694]	6354	static size_t rtFsIsoVolGetStrippedLength(const char *pachField, size_t cchField)
[66735]	6355	{
	6356	while (cchField > 0 && pachField[cchField - 1] == ' ')
	6357	cchField--;
	6358	return cchField;
	6359	}
	6360
[67391]	6361	/** Logging helper. */
[68694]	6362	static char rtFsIsoVolGetMaybeUtf16Be(const char pachField, size_t cchField, char *pszDst, size_t cbDst)
[67391]	6363	{
	6364	/* Check the format by looking for zero bytes. ISO-9660 doesn't allow zeros.
	6365	This doesn't have to be a UTF-16BE string. */
	6366	size_t cFirstZeros = 0;
	6367	size_t cSecondZeros = 0;
[67612]	6368	for (size_t off = 0; off + 1 < cchField; off += 2)
[67391]	6369	{
	6370	cFirstZeros += pachField[off] == '\0';
	6371	cSecondZeros += pachField[off + 1] == '\0';
	6372	}
[66735]	6373
[67391]	6374	int rc = VINF_SUCCESS;
	6375	char *pszTmp = &pszDst[10];
	6376	size_t cchRet = 0;
	6377	if (cFirstZeros > cSecondZeros)
	6378	{
	6379	/* UTF-16BE / UTC-2BE: */
	6380	if (cchField & 1)
	6381	{
	6382	if (pachField[cchField - 1] == '\0' \|\| pachField[cchField - 1] == ' ')
	6383	cchField--;
	6384	else
	6385	rc = VERR_INVALID_UTF16_ENCODING;
	6386	}
	6387	if (RT_SUCCESS(rc))
	6388	{
	6389	while ( cchField >= 2
	6390	&& pachField[cchField - 1] == ' '
	6391	&& pachField[cchField - 2] == '\0')
	6392	cchField -= 2;
	6393
	6394	rc = RTUtf16BigToUtf8Ex((PCRTUTF16)pachField, cchField / sizeof(RTUTF16), &pszTmp, cbDst - 10 - 1, &cchRet);
	6395	}
	6396	if (RT_SUCCESS(rc))
	6397	{
	6398	pszDst[0] = 'U';
	6399	pszDst[1] = 'T';
	6400	pszDst[2] = 'F';
	6401	pszDst[3] = '-';
	6402	pszDst[4] = '1';
	6403	pszDst[5] = '6';
	6404	pszDst[6] = 'B';
	6405	pszDst[7] = 'E';
	6406	pszDst[8] = ':';
	6407	pszDst[9] = '\'';
	6408	pszDst[10 + cchRet] = '\'';
	6409	pszDst[10 + cchRet + 1] = '\0';
	6410	}
	6411	else
	6412	RTStrPrintf(pszDst, cbDst, "UTF-16BE: %.*Rhxs", cchField, pachField);
	6413	}
	6414	else if (cSecondZeros > 0)
	6415	{
	6416	/* Little endian UTF-16 / UCS-2 (ASSUMES host is little endian, sorry) */
	6417	if (cchField & 1)
	6418	{
	6419	if (pachField[cchField - 1] == '\0' \|\| pachField[cchField - 1] == ' ')
	6420	cchField--;
	6421	else
	6422	rc = VERR_INVALID_UTF16_ENCODING;
	6423	}
	6424	if (RT_SUCCESS(rc))
	6425	{
	6426	while ( cchField >= 2
	6427	&& pachField[cchField - 1] == '\0'
	6428	&& pachField[cchField - 2] == ' ')
	6429	cchField -= 2;
	6430
	6431	rc = RTUtf16ToUtf8Ex((PCRTUTF16)pachField, cchField / sizeof(RTUTF16), &pszTmp, cbDst - 10 - 1, &cchRet);
	6432	}
	6433	if (RT_SUCCESS(rc))
	6434	{
	6435	pszDst[0] = 'U';
	6436	pszDst[1] = 'T';
	6437	pszDst[2] = 'F';
	6438	pszDst[3] = '-';
	6439	pszDst[4] = '1';
	6440	pszDst[5] = '6';
	6441	pszDst[6] = 'L';
	6442	pszDst[7] = 'E';
	6443	pszDst[8] = ':';
	6444	pszDst[9] = '\'';
	6445	pszDst[10 + cchRet] = '\'';
	6446	pszDst[10 + cchRet + 1] = '\0';
	6447	}
	6448	else
	6449	RTStrPrintf(pszDst, cbDst, "UTF-16LE: %.*Rhxs", cchField, pachField);
	6450	}
	6451	else
	6452	{
	6453	/* ASSUME UTF-8/ASCII. */
	6454	while ( cchField > 0
	6455	&& pachField[cchField - 1] == ' ')
	6456	cchField--;
[67394]	6457	rc = RTStrValidateEncodingEx(pachField, cchField, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH);
[67391]	6458	if (RT_SUCCESS(rc))
	6459	RTStrPrintf(pszDst, cbDst, "UTF-8: '%.*s'", cchField, pachField);
	6460	else
	6461	RTStrPrintf(pszDst, cbDst, "UNK-8: %.*Rhxs", cchField, pachField);
	6462	}
	6463	return pszDst;
	6464	}
	6465
	6466
[66735]	6467	/**
	6468	* Logs the primary or supplementary volume descriptor
	6469	*
	6470	* @param pVolDesc The descriptor.
	6471	*/
[68694]	6472	static void rtFsIsoVolLogPrimarySupplementaryVolDesc(PCISO9660SUPVOLDESC pVolDesc)
[66735]	6473	{
	6474	if (LogIs2Enabled())
	6475	{
[67391]	6476	char szTmp[384];
[66735]	6477	Log2(("ISO9660: fVolumeFlags: %#RX8\n", pVolDesc->fVolumeFlags));
[68694]	6478	Log2(("ISO9660: achSystemId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achSystemId, sizeof(pVolDesc->achSystemId), szTmp, sizeof(szTmp)) ));
	6479	Log2(("ISO9660: achVolumeId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achVolumeId, sizeof(pVolDesc->achVolumeId), szTmp, sizeof(szTmp)) ));
[66735]	6480	Log2(("ISO9660: Unused73: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->Unused73.be), RT_LE2H_U32(pVolDesc->Unused73.le)));
	6481	Log2(("ISO9660: VolumeSpaceSize: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le)));
[68694]	6482	Log2(("ISO9660: abEscapeSequences: '%.s'\n", rtFsIsoVolGetStrippedLength((char )pVolDesc->abEscapeSequences, sizeof(pVolDesc->abEscapeSequences)), pVolDesc->abEscapeSequences));
[66735]	6483	Log2(("ISO9660: cVolumesInSet: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le)));
	6484	Log2(("ISO9660: VolumeSeqNo: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le)));
	6485	Log2(("ISO9660: cbLogicalBlock: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le)));
	6486	Log2(("ISO9660: cbPathTable: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->cbPathTable.be), RT_LE2H_U32(pVolDesc->cbPathTable.le)));
	6487	Log2(("ISO9660: offTypeLPathTable: %#RX32\n", RT_LE2H_U32(pVolDesc->offTypeLPathTable)));
	6488	Log2(("ISO9660: offOptionalTypeLPathTable: %#RX32\n", RT_LE2H_U32(pVolDesc->offOptionalTypeLPathTable)));
	6489	Log2(("ISO9660: offTypeMPathTable: %#RX32\n", RT_BE2H_U32(pVolDesc->offTypeMPathTable)));
	6490	Log2(("ISO9660: offOptionalTypeMPathTable: %#RX32\n", RT_BE2H_U32(pVolDesc->offOptionalTypeMPathTable)));
[68694]	6491	Log2(("ISO9660: achVolumeSetId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achVolumeSetId, sizeof(pVolDesc->achVolumeSetId), szTmp, sizeof(szTmp)) ));
	6492	Log2(("ISO9660: achPublisherId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achPublisherId, sizeof(pVolDesc->achPublisherId), szTmp, sizeof(szTmp)) ));
	6493	Log2(("ISO9660: achDataPreparerId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achDataPreparerId, sizeof(pVolDesc->achDataPreparerId), szTmp, sizeof(szTmp)) ));
	6494	Log2(("ISO9660: achApplicationId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achApplicationId, sizeof(pVolDesc->achApplicationId), szTmp, sizeof(szTmp)) ));
	6495	Log2(("ISO9660: achCopyrightFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achCopyrightFileId, sizeof(pVolDesc->achCopyrightFileId), szTmp, sizeof(szTmp)) ));
	6496	Log2(("ISO9660: achAbstractFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achAbstractFileId, sizeof(pVolDesc->achAbstractFileId), szTmp, sizeof(szTmp)) ));
	6497	Log2(("ISO9660: achBibliographicFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achBibliographicFileId, sizeof(pVolDesc->achBibliographicFileId), szTmp, sizeof(szTmp)) ));
[66735]	6498	Log2(("ISO9660: BirthTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n",
	6499	pVolDesc->BirthTime.achYear,
	6500	pVolDesc->BirthTime.achMonth,
	6501	pVolDesc->BirthTime.achDay,
	6502	pVolDesc->BirthTime.achHour,
	6503	pVolDesc->BirthTime.achMinute,
	6504	pVolDesc->BirthTime.achSecond,
	6505	pVolDesc->BirthTime.achCentisecond,
	6506	pVolDesc->BirthTime.offUtc*4/60));
	6507	Log2(("ISO9660: ModifyTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n",
	6508	pVolDesc->ModifyTime.achYear,
	6509	pVolDesc->ModifyTime.achMonth,
	6510	pVolDesc->ModifyTime.achDay,
	6511	pVolDesc->ModifyTime.achHour,
	6512	pVolDesc->ModifyTime.achMinute,
	6513	pVolDesc->ModifyTime.achSecond,
	6514	pVolDesc->ModifyTime.achCentisecond,
	6515	pVolDesc->ModifyTime.offUtc*4/60));
	6516	Log2(("ISO9660: ExpireTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n",
	6517	pVolDesc->ExpireTime.achYear,
	6518	pVolDesc->ExpireTime.achMonth,
	6519	pVolDesc->ExpireTime.achDay,
	6520	pVolDesc->ExpireTime.achHour,
	6521	pVolDesc->ExpireTime.achMinute,
	6522	pVolDesc->ExpireTime.achSecond,
	6523	pVolDesc->ExpireTime.achCentisecond,
	6524	pVolDesc->ExpireTime.offUtc*4/60));
	6525	Log2(("ISO9660: EffectiveTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n",
	6526	pVolDesc->EffectiveTime.achYear,
	6527	pVolDesc->EffectiveTime.achMonth,
	6528	pVolDesc->EffectiveTime.achDay,
	6529	pVolDesc->EffectiveTime.achHour,
	6530	pVolDesc->EffectiveTime.achMinute,
	6531	pVolDesc->EffectiveTime.achSecond,
	6532	pVolDesc->EffectiveTime.achCentisecond,
	6533	pVolDesc->EffectiveTime.offUtc*4/60));
	6534	Log2(("ISO9660: bFileStructureVersion: %#RX8\n", pVolDesc->bFileStructureVersion));
	6535	Log2(("ISO9660: bReserved883: %#RX8\n", pVolDesc->bReserved883));
	6536
	6537	Log2(("ISO9660: RootDir.cbDirRec: %#RX8\n", pVolDesc->RootDir.DirRec.cbDirRec));
[67326]	6538	Log2(("ISO9660: RootDir.cExtAttrBlocks: %#RX8\n", pVolDesc->RootDir.DirRec.cExtAttrBlocks));
[66735]	6539	Log2(("ISO9660: RootDir.offExtent: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->RootDir.DirRec.offExtent.be), RT_LE2H_U32(pVolDesc->RootDir.DirRec.offExtent.le)));
	6540	Log2(("ISO9660: RootDir.cbData: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->RootDir.DirRec.cbData.be), RT_LE2H_U32(pVolDesc->RootDir.DirRec.cbData.le)));
	6541	Log2(("ISO9660: RootDir.RecTime: %04u-%02u-%02u %02u:%02u:%02u%+03d\n",
	6542	pVolDesc->RootDir.DirRec.RecTime.bYear + 1900,
	6543	pVolDesc->RootDir.DirRec.RecTime.bMonth,
	6544	pVolDesc->RootDir.DirRec.RecTime.bDay,
	6545	pVolDesc->RootDir.DirRec.RecTime.bHour,
	6546	pVolDesc->RootDir.DirRec.RecTime.bMinute,
	6547	pVolDesc->RootDir.DirRec.RecTime.bSecond,
	6548	pVolDesc->RootDir.DirRec.RecTime.offUtc*4/60));
	6549	Log2(("ISO9660: RootDir.RecTime.fFileFlags: %RX8\n", pVolDesc->RootDir.DirRec.fFileFlags));
	6550	Log2(("ISO9660: RootDir.RecTime.bFileUnitSize: %RX8\n", pVolDesc->RootDir.DirRec.bFileUnitSize));
	6551	Log2(("ISO9660: RootDir.RecTime.bInterleaveGapSize: %RX8\n", pVolDesc->RootDir.DirRec.bInterleaveGapSize));
	6552	Log2(("ISO9660: RootDir.RecTime.VolumeSeqNo: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->RootDir.DirRec.VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->RootDir.DirRec.VolumeSeqNo.le)));
	6553	Log2(("ISO9660: RootDir.RecTime.bFileIdLength: %RX8\n", pVolDesc->RootDir.DirRec.bFileIdLength));
	6554	Log2(("ISO9660: RootDir.RecTime.achFileId: '%.*s'\n", pVolDesc->RootDir.DirRec.bFileIdLength, pVolDesc->RootDir.DirRec.achFileId));
[73097]	6555	uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pVolDesc->RootDir.DirRec.bFileIdLength])
[66735]	6556	+ !(pVolDesc->RootDir.DirRec.bFileIdLength & 1);
	6557	if (offSysUse < pVolDesc->RootDir.DirRec.cbDirRec)
	6558	{
[69023]	6559	Log2(("ISO9660: RootDir System Use:\n%.*RhxD\n",
[66735]	6560	pVolDesc->RootDir.DirRec.cbDirRec - offSysUse, &pVolDesc->RootDir.ab[offSysUse]));
	6561	}
	6562	}
	6563	}
	6564
	6565	#endif /* LOG_ENABLED */
	6566
	6567	/**
	6568	* Deal with a root directory from a primary or supplemental descriptor.
	6569	*
	6570	* @returns IPRT status code.
	6571	* @param pThis The ISO 9660 instance being initialized.
	6572	* @param pRootDir The root directory record to check out.
	6573	* @param pDstRootDir Where to store a copy of the root dir record.
	6574	* @param pErrInfo Where to return additional error info. Can be NULL.
	6575	*/
[68694]	6576	static int rtFsIsoVolHandleRootDir(PRTFSISOVOL pThis, PCISO9660DIRREC pRootDir,
	6577	PISO9660DIRREC pDstRootDir, PRTERRINFO pErrInfo)
[66735]	6578	{
[73097]	6579	if (pRootDir->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId))
[69013]	6580	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Root dir record size is too small: %#x (min %#x)",
[73097]	6581	pRootDir->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId));
[66735]	6582
	6583	if (!(pRootDir->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY))
[69013]	6584	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT,
	6585	"Root dir is not flagged as directory: %#x", pRootDir->fFileFlags);
[66735]	6586	if (pRootDir->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)
[69013]	6587	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT,
	6588	"Root dir is cannot be multi-extent: %#x", pRootDir->fFileFlags);
[66735]	6589
	6590	if (RT_LE2H_U32(pRootDir->cbData.le) != RT_BE2H_U32(pRootDir->cbData.be))
[69013]	6591	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir size: {%#RX32,%#RX32}",
	6592	RT_BE2H_U32(pRootDir->cbData.be), RT_LE2H_U32(pRootDir->cbData.le));
[66735]	6593	if (RT_LE2H_U32(pRootDir->cbData.le) == 0)
[69013]	6594	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Zero sized root dir");
[66735]	6595
	6596	if (RT_LE2H_U32(pRootDir->offExtent.le) != RT_BE2H_U32(pRootDir->offExtent.be))
[69013]	6597	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir extent: {%#RX32,%#RX32}",
	6598	RT_BE2H_U32(pRootDir->offExtent.be), RT_LE2H_U32(pRootDir->offExtent.le));
[66735]	6599
	6600	if (RT_LE2H_U16(pRootDir->VolumeSeqNo.le) != RT_BE2H_U16(pRootDir->VolumeSeqNo.be))
[69013]	6601	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir volume sequence ID: {%#RX16,%#RX16}",
	6602	RT_BE2H_U16(pRootDir->VolumeSeqNo.be), RT_LE2H_U16(pRootDir->VolumeSeqNo.le));
[66735]	6603	if (RT_LE2H_U16(pRootDir->VolumeSeqNo.le) != pThis->idPrimaryVol)
[69013]	6604	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6605	"Expected root dir to have same volume sequence number as primary volume: %#x, expected %#x",
	6606	RT_LE2H_U16(pRootDir->VolumeSeqNo.le), pThis->idPrimaryVol);
[66735]	6607
	6608	/*
	6609	* Seems okay, copy it.
	6610	*/
	6611	pDstRootDir = pRootDir;
	6612	return VINF_SUCCESS;
	6613	}
	6614
	6615
	6616	/**
	6617	* Deal with a primary volume descriptor.
	6618	*
	6619	* @returns IPRT status code.
	6620	* @param pThis The ISO 9660 instance being initialized.
	6621	* @param pVolDesc The volume descriptor to handle.
	6622	* @param offVolDesc The disk offset of the volume descriptor.
	6623	* @param pRootDir Where to return a copy of the root directory record.
	6624	* @param poffRootDirRec Where to return the disk offset of the root dir.
	6625	* @param pErrInfo Where to return additional error info. Can be NULL.
	6626	*/
[68694]	6627	static int rtFsIsoVolHandlePrimaryVolDesc(PRTFSISOVOL pThis, PCISO9660PRIMARYVOLDESC pVolDesc, uint32_t offVolDesc,
	6628	PISO9660DIRREC pRootDir, uint64_t *poffRootDirRec, PRTERRINFO pErrInfo)
[66735]	6629	{
	6630	if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION)
[69013]	6631	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6632	"Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion);
[66735]	6633
	6634	/*
[94291]	6635	* Take down the location of the primary volume descriptor so we can get
	6636	* the volume lable and other info from it later.
	6637	*/
	6638	pThis->offPrimaryVolDesc = offVolDesc;
	6639
	6640	/*
[66735]	6641	* We need the block size ...
	6642	*/
	6643	pThis->cbBlock = RT_LE2H_U16(pVolDesc->cbLogicalBlock.le);
	6644	if ( pThis->cbBlock != RT_BE2H_U16(pVolDesc->cbLogicalBlock.be)
	6645	\|\| !RT_IS_POWER_OF_TWO(pThis->cbBlock)
	6646	\|\| pThis->cbBlock / pThis->cbSector < 1)
[69013]	6647	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid logical block size: {%#RX16,%#RX16}",
	6648	RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le));
[66735]	6649	if (pThis->cbBlock / pThis->cbSector > 128)
[69013]	6650	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unsupported block size: %#x\n", pThis->cbBlock);
[66735]	6651
	6652	/*
	6653	* ... volume space size ...
	6654	*/
	6655	pThis->cBlocksInPrimaryVolumeSpace = RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le);
	6656	if (pThis->cBlocksInPrimaryVolumeSpace != RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be))
[69013]	6657	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume space size: {%#RX32,%#RX32}",
	6658	RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le));
[66735]	6659	pThis->cbPrimaryVolumeSpace = pThis->cBlocksInPrimaryVolumeSpace * (uint64_t)pThis->cbBlock;
	6660
	6661	/*
	6662	* ... number of volumes in the set ...
	6663	*/
	6664	pThis->cVolumesInSet = RT_LE2H_U16(pVolDesc->cVolumesInSet.le);
	6665	if ( pThis->cVolumesInSet != RT_BE2H_U16(pVolDesc->cVolumesInSet.be)
	6666	\|\| pThis->cVolumesInSet == 0)
[69013]	6667	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume set size: {%#RX16,%#RX16}",
	6668	RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le));
[66735]	6669	if (pThis->cVolumesInSet > 32)
[69013]	6670	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Too large volume set size: %#x\n", pThis->cVolumesInSet);
[66735]	6671
	6672	/*
	6673	* ... primary volume sequence ID ...
	6674	*/
	6675	pThis->idPrimaryVol = RT_LE2H_U16(pVolDesc->VolumeSeqNo.le);
	6676	if (pThis->idPrimaryVol != RT_BE2H_U16(pVolDesc->VolumeSeqNo.be))
[69013]	6677	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume sequence ID: {%#RX16,%#RX16}",
	6678	RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le));
[66735]	6679	if ( pThis->idPrimaryVol > pThis->cVolumesInSet
	6680	\|\| pThis->idPrimaryVol < 1)
[69013]	6681	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6682	"Volume sequence ID out of of bound: %#x (1..%#x)\n", pThis->idPrimaryVol, pThis->cVolumesInSet);
[66735]	6683
	6684	/*
	6685	* ... and the root directory record.
	6686	*/
[73097]	6687	*poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660PRIMARYVOLDESC, RootDir.DirRec);
[68694]	6688	return rtFsIsoVolHandleRootDir(pThis, &pVolDesc->RootDir.DirRec, pRootDir, pErrInfo);
[66735]	6689	}
	6690
	6691
	6692	/**
	6693	* Deal with a supplementary volume descriptor.
	6694	*
	6695	* @returns IPRT status code.
	6696	* @param pThis The ISO 9660 instance being initialized.
	6697	* @param pVolDesc The volume descriptor to handle.
	6698	* @param offVolDesc The disk offset of the volume descriptor.
	6699	* @param pbUcs2Level Where to return the joliet level, if found. Caller
	6700	* initializes this to zero, we'll return 1, 2 or 3 if
	6701	* joliet was detected.
	6702	* @param pRootDir Where to return the root directory, if found.
	6703	* @param poffRootDirRec Where to return the disk offset of the root dir.
	6704	* @param pErrInfo Where to return additional error info. Can be NULL.
	6705	*/
[68694]	6706	static int rtFsIsoVolHandleSupplementaryVolDesc(PRTFSISOVOL pThis, PCISO9660SUPVOLDESC pVolDesc, uint32_t offVolDesc,
	6707	uint8_t pbUcs2Level, PISO9660DIRREC pRootDir, uint64_t poffRootDirRec,
	6708	PRTERRINFO pErrInfo)
[66735]	6709	{
	6710	if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION)
[69013]	6711	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6712	"Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion);
[66735]	6713
	6714	/*
	6715	* Is this a joliet volume descriptor? If not, we probably don't need to
	6716	* care about it.
	6717	*/
	6718	if ( pVolDesc->abEscapeSequences[0] != ISO9660_JOLIET_ESC_SEQ_0
	6719	\|\| pVolDesc->abEscapeSequences[1] != ISO9660_JOLIET_ESC_SEQ_1
	6720	\|\| ( pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1
	6721	&& pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2
	6722	&& pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_3))
	6723	return VINF_SUCCESS;
	6724
	6725	/*
	6726	* Skip if joliet is unwanted.
	6727	*/
	6728	if (pThis->fFlags & RTFSISO9660_F_NO_JOLIET)
	6729	return VINF_SUCCESS;
	6730
	6731	/*
	6732	* Check that the joliet descriptor matches the primary one.
	6733	* Note! These are our assumptions and may be wrong.
	6734	*/
	6735	if (pThis->cbBlock == 0)
[69013]	6736	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6737	"Supplementary joliet volume descriptor is not supported when appearing before the primary volume descriptor");
[66735]	6738	if (ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock) != pThis->cbBlock)
[69013]	6739	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6740	"Logical block size for joliet volume descriptor differs from primary: %#RX16 vs %#RX16\n",
	6741	ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock), pThis->cbBlock);
[90216]	6742	#if 0 /* Not necessary. */
[90215]	6743	/* Used to be !=, changed to > for ubuntu 20.10 and later. Wonder if they exclude a few files
	6744	and thus end up with a different total. Obviously, this test is a big bogus, as we don't
	6745	really seem to care about the value at all... */
	6746	if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize) > pThis->cBlocksInPrimaryVolumeSpace)
[69013]	6747	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6748	"Volume space size for joliet volume descriptor differs from primary: %#RX32 vs %#RX32\n",
	6749	ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize), pThis->cBlocksInPrimaryVolumeSpace);
[90216]	6750	#endif
[66735]	6751	if (ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet) != pThis->cVolumesInSet)
[69013]	6752	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6753	"Volume set size for joliet volume descriptor differs from primary: %#RX16 vs %#RX32\n",
	6754	ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet), pThis->cVolumesInSet);
[66735]	6755	if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo) != pThis->idPrimaryVol)
[69013]	6756	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6757	"Volume sequence ID for joliet volume descriptor differs from primary: %#RX16 vs %#RX32\n",
	6758	ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo), pThis->idPrimaryVol);
[66735]	6759
	6760	if (*pbUcs2Level != 0)
[69013]	6761	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "More than one supplementary joliet volume descriptor");
[66735]	6762
	6763	/*
	6764	* Switch to the joliet root dir as it has UTF-16 stuff in it.
	6765	*/
[68694]	6766	int rc = rtFsIsoVolHandleRootDir(pThis, &pVolDesc->RootDir.DirRec, pRootDir, pErrInfo);
[66735]	6767	if (RT_SUCCESS(rc))
	6768	{
[73097]	6769	*poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660SUPVOLDESC, RootDir.DirRec);
[66735]	6770	*pbUcs2Level = pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1 ? 1
	6771	: pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2 ? 2 : 3;
	6772	Log(("ISO9660: Joliet with UCS-2 level %u\n", *pbUcs2Level));
[94291]	6773
	6774	/*
	6775	* Take down the location of the secondary volume descriptor so we can get
	6776	* the volume lable and other info from it later.
	6777	*/
	6778	pThis->offSecondaryVolDesc = offVolDesc;
[66735]	6779	}
	6780	return rc;
	6781	}
	6782
	6783
	6784
	6785	/**
	6786	* Worker for RTFsIso9660VolOpen.
	6787	*
	6788	* @returns IPRT status code.
[68694]	6789	* @param pThis The ISO VFS instance to initialize.
	6790	* @param hVfsSelf The ISO VFS handle (no reference consumed).
[69924]	6791	* @param hVfsBacking The file backing the alleged ISO file system.
[68694]	6792	* Reference is consumed (via rtFsIsoVol_Close).
	6793	* @param fFlags Flags, RTFSISO9660_F_XXX.
[66735]	6794	* @param pErrInfo Where to return additional error info. Can be NULL.
	6795	*/
[68694]	6796	static int rtFsIsoVolTryInit(PRTFSISOVOL pThis, RTVFS hVfsSelf, RTVFSFILE hVfsBacking, uint32_t fFlags, PRTERRINFO pErrInfo)
[66735]	6797	{
	6798	uint32_t const cbSector = 2048;
	6799
	6800	/*
[94280]	6801	* First initialize the state so that rtFsIsoVol_Close won't trip up.
[66735]	6802	*/
	6803	pThis->hVfsSelf = hVfsSelf;
[94280]	6804	pThis->hVfsBacking = hVfsBacking; /* Caller referenced it for us, we consume it; rtFsIsoVol_Close releases it. */
[66735]	6805	pThis->cbBacking = 0;
[68694]	6806	pThis->cBackingSectors = 0;
[66735]	6807	pThis->fFlags = fFlags;
	6808	pThis->cbSector = cbSector;
	6809	pThis->cbBlock = 0;
	6810	pThis->cBlocksInPrimaryVolumeSpace = 0;
	6811	pThis->cbPrimaryVolumeSpace = 0;
	6812	pThis->cVolumesInSet = 0;
	6813	pThis->idPrimaryVol = UINT32_MAX;
	6814	pThis->fIsUtf16 = false;
	6815	pThis->pRootDir = NULL;
[94280]	6816	pThis->fHaveRock = false;
	6817	pThis->offSuspSkip = 0;
	6818	pThis->offRockBuf = UINT64_MAX;
[66735]	6819
	6820	/*
[94280]	6821	* Do init stuff that may fail.
[66735]	6822	*/
[94280]	6823	int rc = RTCritSectInit(&pThis->RockBufLock);
	6824	AssertRCReturn(rc, rc);
	6825
	6826	rc = RTVfsFileQuerySize(hVfsBacking, &pThis->cbBacking);
[68694]	6827	if (RT_SUCCESS(rc))
	6828	pThis->cBackingSectors = pThis->cbBacking / pThis->cbSector;
	6829	else
[66735]	6830	return rc;
	6831
	6832	/*
	6833	* Read the volume descriptors starting at logical sector 16.
	6834	*/
	6835	union
	6836	{
[69023]	6837	uint8_t ab[RTFSISO_MAX_LOGICAL_BLOCK_SIZE];
	6838	uint16_t au16[RTFSISO_MAX_LOGICAL_BLOCK_SIZE / 2];
	6839	uint32_t au32[RTFSISO_MAX_LOGICAL_BLOCK_SIZE / 4];
[66735]	6840	ISO9660VOLDESCHDR VolDescHdr;
	6841	ISO9660BOOTRECORD BootRecord;
	6842	ISO9660PRIMARYVOLDESC PrimaryVolDesc;
	6843	ISO9660SUPVOLDESC SupVolDesc;
	6844	ISO9660VOLPARTDESC VolPartDesc;
	6845	} Buf;
	6846	RT_ZERO(Buf);
	6847
	6848	uint64_t offRootDirRec = UINT64_MAX;
	6849	ISO9660DIRREC RootDir;
	6850	RT_ZERO(RootDir);
	6851
	6852	uint64_t offJolietRootDirRec = UINT64_MAX;
	6853	uint8_t bJolietUcs2Level = 0;
	6854	ISO9660DIRREC JolietRootDir;
	6855	RT_ZERO(JolietRootDir);
	6856
[68509]	6857	uint8_t uUdfLevel = 0;
	6858	uint64_t offUdfBootVolDesc = UINT64_MAX;
	6859
[66735]	6860	uint32_t cPrimaryVolDescs = 0;
	6861	uint32_t cSupplementaryVolDescs = 0;
	6862	uint32_t cBootRecordVolDescs = 0;
	6863	uint32_t offVolDesc = 16 * cbSector;
[68509]	6864	enum
	6865	{
	6866	kStateStart = 0,
	6867	kStateNoSeq,
	6868	kStateCdSeq,
[68510]	6869	kStateUdfSeq
[68509]	6870	} enmState = kStateStart;
[66735]	6871	for (uint32_t iVolDesc = 0; ; iVolDesc++, offVolDesc += cbSector)
	6872	{
	6873	if (iVolDesc > 32)
[69013]	6874	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "More than 32 volume descriptors, doesn't seem right...");
[66735]	6875
	6876	/* Read the next one and check the signature. */
	6877	rc = RTVfsFileReadAt(hVfsBacking, offVolDesc, &Buf, cbSector, NULL);
	6878	if (RT_FAILURE(rc))
[69013]	6879	return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Unable to read volume descriptor #%u", iVolDesc);
[66735]	6880
[68509]	6881	#define MATCH_STD_ID(a_achStdId1, a_szStdId2) \
	6882	( (a_achStdId1)[0] == (a_szStdId2)[0] \
	6883	&& (a_achStdId1)[1] == (a_szStdId2)[1] \
	6884	&& (a_achStdId1)[2] == (a_szStdId2)[2] \
	6885	&& (a_achStdId1)[3] == (a_szStdId2)[3] \
	6886	&& (a_achStdId1)[4] == (a_szStdId2)[4] )
	6887	#define MATCH_HDR(a_pStd, a_bType2, a_szStdId2, a_bVer2) \
	6888	( MATCH_STD_ID((a_pStd)->achStdId, a_szStdId2) \
	6889	&& (a_pStd)->bDescType == (a_bType2) \
	6890	&& (a_pStd)->bDescVersion == (a_bVer2) )
	6891
	6892	/*
	6893	* ISO 9660 ("CD001").
	6894	*/
	6895	if ( ( enmState == kStateStart
	6896	\|\| enmState == kStateCdSeq
	6897	\|\| enmState == kStateNoSeq)
	6898	&& MATCH_STD_ID(Buf.VolDescHdr.achStdId, ISO9660VOLDESC_STD_ID) )
[66735]	6899	{
[68509]	6900	enmState = kStateCdSeq;
[66735]	6901
[68509]	6902	/* Do type specific handling. */
	6903	Log(("ISO9660: volume desc #%u: type=%#x\n", iVolDesc, Buf.VolDescHdr.bDescType));
	6904	if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_PRIMARY)
	6905	{
	6906	cPrimaryVolDescs++;
	6907	if (Buf.VolDescHdr.bDescVersion != ISO9660PRIMARYVOLDESC_VERSION)
[69013]	6908	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6909	"Unsupported primary volume descriptor version: %#x", Buf.VolDescHdr.bDescVersion);
[66735]	6910	#ifdef LOG_ENABLED
[68694]	6911	rtFsIsoVolLogPrimarySupplementaryVolDesc(&Buf.SupVolDesc);
[66735]	6912	#endif
[78356]	6913	if (cPrimaryVolDescs == 1)
	6914	rc = rtFsIsoVolHandlePrimaryVolDesc(pThis, &Buf.PrimaryVolDesc, offVolDesc, &RootDir, &offRootDirRec, pErrInfo);
	6915	else if (cPrimaryVolDescs == 2)
	6916	Log(("ISO9660: ignoring 2nd primary descriptor\n")); /* so we can read the w2k3 ifs kit */
	6917	else
[69013]	6918	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "More than one primary volume descriptor");
[68509]	6919	}
	6920	else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_SUPPLEMENTARY)
	6921	{
	6922	cSupplementaryVolDescs++;
	6923	if (Buf.VolDescHdr.bDescVersion != ISO9660SUPVOLDESC_VERSION)
[69013]	6924	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6925	"Unsupported supplemental volume descriptor version: %#x", Buf.VolDescHdr.bDescVersion);
[66735]	6926	#ifdef LOG_ENABLED
[68694]	6927	rtFsIsoVolLogPrimarySupplementaryVolDesc(&Buf.SupVolDesc);
[66735]	6928	#endif
[68694]	6929	rc = rtFsIsoVolHandleSupplementaryVolDesc(pThis, &Buf.SupVolDesc, offVolDesc, &bJolietUcs2Level, &JolietRootDir,
	6930	&offJolietRootDirRec, pErrInfo);
[68509]	6931	}
	6932	else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_BOOT_RECORD)
	6933	{
	6934	cBootRecordVolDescs++;
	6935	}
	6936	else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_TERMINATOR)
	6937	{
	6938	if (!cPrimaryVolDescs)
[69013]	6939	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "No primary volume descriptor");
[68509]	6940	enmState = kStateNoSeq;
	6941	}
	6942	else
[69013]	6943	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT,
	6944	"Unknown volume descriptor: %#x", Buf.VolDescHdr.bDescType);
[66735]	6945	}
[68509]	6946	/*
	6947	* UDF volume recognition sequence (VRS).
	6948	*/
	6949	else if ( ( enmState == kStateNoSeq
	6950	\|\| enmState == kStateStart)
	6951	&& MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_BEGIN, UDF_EXT_VOL_DESC_VERSION) )
[66735]	6952	{
[68509]	6953	if (uUdfLevel == 0)
	6954	enmState = kStateUdfSeq;
	6955	else
[69013]	6956	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Only one BEA01 sequence is supported");
[66735]	6957	}
[68509]	6958	else if ( enmState == kStateUdfSeq
	6959	&& MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_NSR_02, UDF_EXT_VOL_DESC_VERSION) )
	6960	uUdfLevel = 2;
	6961	else if ( enmState == kStateUdfSeq
	6962	&& MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_NSR_03, UDF_EXT_VOL_DESC_VERSION) )
	6963	uUdfLevel = 3;
	6964	else if ( enmState == kStateUdfSeq
	6965	&& MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_BOOT, UDF_EXT_VOL_DESC_VERSION) )
[66735]	6966	{
[68509]	6967	if (offUdfBootVolDesc == UINT64_MAX)
	6968	offUdfBootVolDesc = iVolDesc * cbSector;
	6969	else
[69013]	6970	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Only one BOOT2 descriptor is supported");
[68509]	6971	}
	6972	else if ( enmState == kStateUdfSeq
	6973	&& MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_TERM, UDF_EXT_VOL_DESC_VERSION) )
	6974	{
	6975	if (uUdfLevel != 0)
	6976	enmState = kStateNoSeq;
	6977	else
[69013]	6978	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Found BEA01 & TEA01, but no NSR02 or NSR03 descriptors");
[68509]	6979	}
	6980	/*
	6981	* Unknown, probably the end.
	6982	*/
	6983	else if (enmState == kStateNoSeq)
[66735]	6984	break;
[68509]	6985	else if (enmState == kStateStart)
[69013]	6986	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT,
	6987	"Not ISO? Unable to recognize volume descriptor signature: %.5Rhxs", Buf.VolDescHdr.achStdId);
[68509]	6988	else if (enmState == kStateCdSeq)
[93081]	6989	{
	6990	#if 1
[94280]	6991	/* The warp server for ebusiness update ISOs known as ACP2 & MCP2 ends up here,
[93081]	6992	as they do in deed miss a terminator volume descriptor and we're now at the
	6993	root directory already. Just detect this, ignore it and get on with things. */
	6994	Log(("rtFsIsoVolTryInit: Ignoring missing ISO 9660 terminator volume descriptor (found %.5Rhxs).\n",
	6995	Buf.VolDescHdr.achStdId));
	6996	break;
	6997	#else
[69013]	6998	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT,
	6999	"Missing ISO 9660 terminator volume descriptor? (Found %.5Rhxs)", Buf.VolDescHdr.achStdId);
[93081]	7000	#endif
	7001	}
[68509]	7002	else if (enmState == kStateUdfSeq)
[69013]	7003	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT,
	7004	"Missing UDF terminator volume descriptor? (Found %.5Rhxs)", Buf.VolDescHdr.achStdId);
[66735]	7005	else
[69013]	7006	return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT,
	7007	"Unknown volume descriptor signature found at sector %u: %.5Rhxs",
	7008	16 + iVolDesc, Buf.VolDescHdr.achStdId);
[66735]	7009	if (RT_FAILURE(rc))
	7010	return rc;
	7011	}
	7012
	7013	/*
[68509]	7014	* If we found a UDF VRS and are interested in UDF, we have more work to do here.
	7015	*/
[94291]	7016	if (uUdfLevel > 0 && !(fFlags & RTFSISO9660_F_NO_UDF))
[68509]	7017	{
[68694]	7018	Log(("rtFsIsoVolTryInit: uUdfLevel=%d\n", uUdfLevel));
	7019	rc = rtFsIsoVolHandleUdfDetection(pThis, &uUdfLevel, offUdfBootVolDesc, Buf.ab, sizeof(Buf), pErrInfo);
	7020	if (RT_FAILURE(rc))
	7021	return rc;
[68509]	7022	}
[69013]	7023
	7024	/*
	7025	* Decide which to prefer.
	7026	*
	7027	* By default we pick UDF over any of the two ISO 9960, there is currently
	7028	* no way to override this without using the RTFSISO9660_F_NO_XXX options.
	7029	*
[94280]	7030	* If there isn't UDF, we may be faced with choosing between joliet and
	7031	* rock ridge. The joliet option is generally favorable as we don't have
	7032	* to guess wrt to the file name encoding. So, we'll pick that for now.
[69013]	7033	*
	7034	* Note! Should we change this preference for joliet, there fun wrt making sure
	7035	* there really is rock ridge stuff in the primary volume as well as
	7036	* making sure there really is anything of value in the primary volume.
	7037	*/
	7038	if (uUdfLevel > 0)
	7039	{
	7040	pThis->enmType = RTFSISOVOLTYPE_UDF;
[69023]	7041	rc = rtFsIsoDirShrd_NewUdf(pThis, NULL /pParent/, &pThis->Udf.VolInfo.RootDirIcb,
[69048]	7042	NULL /pFileIdDesc/, 0 /offInDir/, &pThis->pRootDir);
[69023]	7043	/** @todo fall back on failure? */
	7044	return rc;
[69013]	7045	}
[66735]	7046	if (bJolietUcs2Level != 0)
	7047	{
[69013]	7048	pThis->enmType = RTFSISOVOLTYPE_JOLIET;
[66735]	7049	pThis->fIsUtf16 = true;
[94280]	7050	return rtFsIsoDirShrd_New9660(pThis, NULL, &JolietRootDir, 1, offJolietRootDirRec, NULL, &pThis->pRootDir);
[66735]	7051	}
[69013]	7052	pThis->enmType = RTFSISOVOLTYPE_ISO9960;
[94280]	7053	return rtFsIsoDirShrd_New9660(pThis, NULL, &RootDir, 1, offRootDirRec, NULL, &pThis->pRootDir);
[66735]	7054	}
	7055
	7056
	7057	/**
	7058	* Opens an ISO 9660 file system volume.
	7059	*
	7060	* @returns IPRT status code.
	7061	* @param hVfsFileIn The file or device backing the volume.
	7062	* @param fFlags RTFSISO9660_F_XXX.
	7063	* @param phVfs Where to return the virtual file system handle.
	7064	* @param pErrInfo Where to return additional error information.
	7065	*/
	7066	RTDECL(int) RTFsIso9660VolOpen(RTVFSFILE hVfsFileIn, uint32_t fFlags, PRTVFS phVfs, PRTERRINFO pErrInfo)
	7067	{
	7068	/*
	7069	* Quick input validation.
	7070	*/
	7071	AssertPtrReturn(phVfs, VERR_INVALID_POINTER);
	7072	*phVfs = NIL_RTVFS;
	7073	AssertReturn(!(fFlags & ~RTFSISO9660_F_VALID_MASK), VERR_INVALID_FLAGS);
	7074
	7075	uint32_t cRefs = RTVfsFileRetain(hVfsFileIn);
	7076	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
	7077
	7078	/*
[69924]	7079	* Create a new ISO VFS instance and try initialize it using the given input file.
[66735]	7080	*/
[94280]	7081	RTVFS hVfs = NIL_RTVFS;
	7082	PRTFSISOVOL pThis = NULL;
	7083	int rc = RTVfsNew(&g_rtFsIsoVolOps, sizeof(RTFSISOVOL), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis);
[66735]	7084	if (RT_SUCCESS(rc))
	7085	{
[94280]	7086	rc = rtFsIsoVolTryInit(pThis, hVfs, hVfsFileIn, fFlags, pErrInfo);
[66735]	7087	if (RT_SUCCESS(rc))
	7088	*phVfs = hVfs;
	7089	else
	7090	RTVfsRelease(hVfs);
	7091	}
	7092	else
	7093	RTVfsFileRelease(hVfsFileIn);
	7094	return rc;
	7095	}
	7096
	7097
	7098	/**
	7099	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate}
	7100	*/
[69048]	7101	static DECLCALLBACK(int) rtVfsChainIsoFsVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec,
	7102	PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo)
[66735]	7103	{
	7104	RT_NOREF(pProviderReg, pSpec);
	7105
	7106	/*
	7107	* Basic checks.
	7108	*/
	7109	if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE)
	7110	return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE;
	7111	if ( pElement->enmType != RTVFSOBJTYPE_VFS
	7112	&& pElement->enmType != RTVFSOBJTYPE_DIR)
	7113	return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS;
	7114	if (pElement->cArgs > 1)
	7115	return VERR_VFS_CHAIN_AT_MOST_ONE_ARG;
	7116
	7117	/*
	7118	* Parse the flag if present, save in pElement->uProvider.
	7119	*/
	7120	uint32_t fFlags = 0;
	7121	if (pElement->cArgs > 0)
	7122	{
	7123	for (uint32_t iArg = 0; iArg < pElement->cArgs; iArg++)
	7124	{
	7125	const char *psz = pElement->paArgs[iArg].psz;
	7126	if (*psz)
	7127	{
	7128	if (!strcmp(psz, "nojoliet"))
	7129	fFlags \|= RTFSISO9660_F_NO_JOLIET;
	7130	else if (!strcmp(psz, "norock"))
	7131	fFlags \|= RTFSISO9660_F_NO_ROCK;
[68509]	7132	else if (!strcmp(psz, "noudf"))
	7133	fFlags \|= RTFSISO9660_F_NO_UDF;
[66735]	7134	else
	7135	{
	7136	*poffError = pElement->paArgs[iArg].offSpec;
[69013]	7137	return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Only knows: 'nojoliet' and 'norock'");
[66735]	7138	}
	7139	}
	7140	}
	7141	}
	7142
	7143	pElement->uProvider = fFlags;
	7144	return VINF_SUCCESS;
	7145	}
	7146
	7147
	7148	/**
	7149	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate}
	7150	*/
[69048]	7151	static DECLCALLBACK(int) rtVfsChainIsoFsVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec,
	7152	PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj,
	7153	PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo)
[66735]	7154	{
	7155	RT_NOREF(pProviderReg, pSpec, poffError);
	7156
	7157	int rc;
	7158	RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj);
	7159	if (hVfsFileIn != NIL_RTVFSFILE)
	7160	{
	7161	RTVFS hVfs;
	7162	rc = RTFsIso9660VolOpen(hVfsFileIn, pElement->uProvider, &hVfs, pErrInfo);
	7163	RTVfsFileRelease(hVfsFileIn);
	7164	if (RT_SUCCESS(rc))
	7165	{
	7166	*phVfsObj = RTVfsObjFromVfs(hVfs);
	7167	RTVfsRelease(hVfs);
	7168	if (*phVfsObj != NIL_RTVFSOBJ)
	7169	return VINF_SUCCESS;
	7170	rc = VERR_VFS_CHAIN_CAST_FAILED;
	7171	}
	7172	}
	7173	else
	7174	rc = VERR_VFS_CHAIN_CAST_FAILED;
	7175	return rc;
	7176	}
	7177
	7178
	7179	/**
	7180	* @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement}
	7181	*/
[69048]	7182	static DECLCALLBACK(bool) rtVfsChainIsoFsVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg,
	7183	PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement,
	7184	PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement)
[66735]	7185	{
	7186	RT_NOREF(pProviderReg, pSpec, pReuseSpec);
	7187	if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider
	7188	\|\| !pReuseElement->paArgs[0].uProvider)
	7189	return true;
	7190	return false;
	7191	}
	7192
	7193
	7194	/** VFS chain element 'file'. */
[69048]	7195	static RTVFSCHAINELEMENTREG g_rtVfsChainIsoFsVolReg =
[66735]	7196	{
	7197	/* uVersion = */ RTVFSCHAINELEMENTREG_VERSION,
	7198	/* fReserved = */ 0,
	7199	/* pszName = */ "isofs",
	7200	/* ListEntry = */ { NULL, NULL },
[69048]	7201	/* pszHelp = */ "Open a ISO 9660 or UDF file system, requires a file object on the left side.\n"
[68509]	7202	"The 'noudf' option make it ignore any UDF.\n"
[66735]	7203	"The 'nojoliet' option make it ignore any joliet supplemental volume.\n"
	7204	"The 'norock' option make it ignore any rock ridge info.\n",
[69048]	7205	/* pfnValidate = */ rtVfsChainIsoFsVol_Validate,
	7206	/* pfnInstantiate = */ rtVfsChainIsoFsVol_Instantiate,
	7207	/* pfnCanReuseElement = */ rtVfsChainIsoFsVol_CanReuseElement,
[66735]	7208	/* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION
	7209	};
	7210
[69048]	7211	RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainIsoFsVolReg, rtVfsChainIsoFsVolReg);
[66735]	7212

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: vbox/trunk/src/VBox/Runtime/common/fs/isovfs.cpp

Download in other formats: