DMG.cpp@ 82837

Last change on this file since 82837 was 80585, checked in by vboxsync, 5 years ago

Runtime: Some renaming to stay consistent (*Get* always returns what is asked for while *Query* returns a status code and where to store the value on success is given as a pointer)

RTVfsFileGetSize -> RTVfsFileQuerySize
RTFileQuerySize -> RTFileQuerySizeByPath
RTFileGetSize -> RTFileQuerySize
RTFileGetSizeMaxEx -> RTFileQuerySizeMaxEx

Property svn:eol-style set to native
Property svn:keywords set to Author Date Id Revision

File size: 78.7 KB

Line
1	/* $Id: DMG.cpp 80585 2019-09-04 14:05:50Z vboxsync $ */
2	/** @file
3	* VBoxDMG - Interpreter for Apple Disk Images (DMG).
4	*/
5
6	/*
7	* Copyright (C) 2010-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_VD_DMG
23	#include <VBox/vd-plugin.h>
24	#include <VBox/vd-ifs.h>
25	#include <VBox/log.h>
26	#include <VBox/err.h>
27
28	#include <iprt/asm.h>
29	#include <iprt/alloca.h>
30	#include <iprt/assert.h>
31	#include <iprt/base64.h>
32	#include <iprt/ctype.h>
33	#include <iprt/mem.h>
34	#include <iprt/string.h>
35	#include <iprt/zip.h>
36	#include <iprt/formats/xar.h>
37
38	#include "VDBackends.h"
39	#include "VDBackendsInline.h"
40
41
42	/*********************************************************************************************************************************
43	* Structures and Typedefs *
44	*********************************************************************************************************************************/
45	#if 0
46	/** @def VBOX_WITH_DIRECT_XAR_ACCESS
47	* When defined, we will use RTVfs to access the XAR file instead of going
48	* the slightly longer way thru the VFS -> VD wrapper. */
49	# define VBOX_WITH_DIRECT_XAR_ACCESS
50	#endif
51
52	/** Sector size, multiply with all sector counts to get number of bytes. */
53	#define DMG_SECTOR_SIZE 512
54
55	/** Convert block number/size to byte offset/size. */
56	#define DMG_BLOCK2BYTE(u) ((uint64_t)(u) << 9)
57
58	/** Convert byte offset/size to block number/size. */
59	#define DMG_BYTE2BLOCK(u) ((u) >> 9)
60
61	/**
62	* UDIF checksum structure.
63	*/
64	typedef struct DMGUDIFCKSUM
65	{
66	uint32_t u32Kind; /*< The kind of checksum. /
67	uint32_t cBits; /*< The size of the checksum. /
68	union
69	{
70	uint8_t au8[128]; /*< 8-bit view. /
71	uint32_t au32[32]; /*< 32-bit view. /
72	} uSum; /*< The checksum. /
73	} DMGUDIFCKSUM;
74	AssertCompileSize(DMGUDIFCKSUM, 8 + 128);
75	typedef DMGUDIFCKSUM *PDMGUDIFCKSUM;
76	typedef const DMGUDIFCKSUM *PCDMGUDIFCKSUM;
77
78	/** @name Checksum Kind (DMGUDIFCKSUM::u32Kind)
79	* @{ */
80	/** No checksum. */
81	#define DMGUDIFCKSUM_NONE UINT32_C(0)
82	/** CRC-32. */
83	#define DMGUDIFCKSUM_CRC32 UINT32_C(2)
84	/** @} */
85
86	/**
87	* UDIF ID.
88	* This is kind of like a UUID only it isn't, but we'll use the UUID
89	* representation of it for simplicity.
90	*/
91	typedef RTUUID DMGUDIFID;
92	AssertCompileSize(DMGUDIFID, 16);
93	typedef DMGUDIFID *PDMGUDIFID;
94	typedef const DMGUDIFID *PCDMGUDIFID;
95
96	/**
97	* UDIF footer used by Apple Disk Images (DMG).
98	*
99	* This is a footer placed 512 bytes from the end of the file. Typically a DMG
100	* file starts with the data, which is followed by the block table and then ends
101	* with this structure.
102	*
103	* All fields are stored in big endian format.
104	*/
105	#pragma pack(1)
106	typedef struct DMGUDIF
107	{
108	uint32_t u32Magic; /*< 0x000 - Magic, 'koly' (DMGUDIF_MAGIC). (fUDIFSignature) /
109	uint32_t u32Version; /*< 0x004 - The UDIF version (DMGUDIF_VER_CURRENT). (fUDIFVersion) /
110	uint32_t cbFooter; /*< 0x008 - The size of the this structure (512). (fUDIFHeaderSize) /
111	uint32_t fFlags; /*< 0x00c - Flags. (fUDIFFlags) /
112	uint64_t offRunData; /*< 0x010 - Where the running data fork starts (usually 0). (fUDIFRunningDataForkOffset) /
113	uint64_t offData; /*< 0x018 - Where the data fork starts (usually 0). (fUDIFDataForkOffset) /
114	uint64_t cbData; /*< 0x020 - Size of the data fork (in bytes). (fUDIFDataForkLength) /
115	uint64_t offRsrc; /*< 0x028 - Where the resource fork starts (usually cbData or 0). (fUDIFRsrcForkOffset) /
116	uint64_t cbRsrc; /*< 0x030 - The size of the resource fork. (fUDIFRsrcForkLength)/
117	uint32_t iSegment; /*< 0x038 - The segment number of this file. (fUDIFSegmentNumber) /
118	uint32_t cSegments; /*< 0x03c - The number of segments. (fUDIFSegmentCount) /
119	DMGUDIFID SegmentId; /*< 0x040 - The segment ID. (fUDIFSegmentID) /
120	DMGUDIFCKSUM DataCkSum; /*< 0x050 - The data checksum. (fUDIFDataForkChecksum) /
121	uint64_t offXml; /*< 0x0d8 - The XML offset (.plist kind of data). (fUDIFXMLOffset) /
122	uint64_t cbXml; /*< 0x0e0 - The size of the XML. (fUDIFXMLSize) /
123	uint8_t abUnknown[120]; /*< 0x0e8 - Unknown stuff, hdiutil doesn't dump it... /
124	DMGUDIFCKSUM MasterCkSum; /*< 0x160 - The master checksum. (fUDIFMasterChecksum) /
125	uint32_t u32Type; /*< 0x1e8 - The image type. (fUDIFImageVariant) /
126	uint64_t cSectors; /*< 0x1ec - The sector count. Warning! Unaligned! (fUDISectorCount) /
127	uint32_t au32Unknown[3]; /*< 0x1f4 - Unknown stuff, hdiutil doesn't dump it... /
128	} DMGUDIF;
129	#pragma pack()
130	AssertCompileSize(DMGUDIF, 512);
131	AssertCompileMemberOffset(DMGUDIF, cbRsrc, 0x030);
132	AssertCompileMemberOffset(DMGUDIF, cbXml, 0x0e0);
133	AssertCompileMemberOffset(DMGUDIF, cSectors, 0x1ec);
134
135	typedef DMGUDIF *PDMGUDIF;
136	typedef const DMGUDIF *PCDMGUDIF;
137
138	/** The UDIF magic 'koly' (DMGUDIF::u32Magic). */
139	#define DMGUDIF_MAGIC UINT32_C(0x6b6f6c79)
140
141	/** The current UDIF version (DMGUDIF::u32Version).
142	* This is currently the only we recognizes and will create. */
143	#define DMGUDIF_VER_CURRENT 4
144
145	/** @name UDIF flags (DMGUDIF::fFlags).
146	* @{ */
147	/** Flatten image whatever that means.
148	* (hdiutil -debug calls it kUDIFFlagsFlattened.) */
149	#define DMGUDIF_FLAGS_FLATTENED RT_BIT_32(0)
150	/** Internet enabled image.
151	* (hdiutil -debug calls it kUDIFFlagsInternetEnabled) */
152	#define DMGUDIF_FLAGS_INET_ENABLED RT_BIT_32(2)
153	/** Mask of known bits. */
154	#define DMGUDIF_FLAGS_KNOWN_MASK (RT_BIT_32(0) \| RT_BIT_32(2))
155	/** @} */
156
157	/** @name UDIF Image Types (DMGUDIF::u32Type).
158	* @{ */
159	/** Device image type. (kUDIFDeviceImageType) */
160	#define DMGUDIF_TYPE_DEVICE 1
161	/** Device image type. (kUDIFPartitionImageType) */
162	#define DMGUDIF_TYPE_PARTITION 2
163	/** @} */
164
165	/**
166	* BLKX data.
167	*
168	* This contains the start offset and size of raw data stored in the image.
169	*
170	* All fields are stored in big endian format.
171	*/
172	#pragma pack(1)
173	typedef struct DMGBLKX
174	{
175	uint32_t u32Magic; /*< 0x000 - Magic, 'mish' (DMGBLKX_MAGIC). /
176	uint32_t u32Version; /*< 0x004 - The BLKX version (DMGBLKX_VER_CURRENT). /
177	uint64_t cSectornumberFirst; /*< 0x008 - The first sector number the block represents in the virtual device. /
178	uint64_t cSectors; /*< 0x010 - Number of sectors this block represents. /
179	uint64_t offDataStart; /*< 0x018 - Start offset for raw data. /
180	uint32_t cSectorsDecompress; /*< 0x020 - Size of the buffer in sectors needed to decompress. /
181	uint32_t u32BlocksDescriptor; /*< 0x024 - Blocks descriptor. /
182	uint8_t abReserved[24];
183	DMGUDIFCKSUM BlkxCkSum; /*< 0x03c - Checksum for the BLKX table. /
184	uint32_t cBlocksRunCount; /*< 0x - Number of entries in the blkx run table afterwards. /
185	} DMGBLKX;
186	#pragma pack()
187	AssertCompileSize(DMGBLKX, 204);
188
189	typedef DMGBLKX *PDMGBLKX;
190	typedef const DMGBLKX *PCDMGBLKX;
191
192	/** The BLKX magic 'mish' (DMGBLKX::u32Magic). */
193	#define DMGBLKX_MAGIC UINT32_C(0x6d697368)
194	/** BLKX version (DMGBLKX::u32Version). */
195	#define DMGBLKX_VERSION UINT32_C(0x00000001)
196
197	/** Blocks descriptor type: entire device. */
198	#define DMGBLKX_DESC_ENTIRE_DEVICE UINT32_C(0xfffffffe)
199
200	/**
201	* BLKX table descriptor.
202	*
203	* All fields are stored in big endian format.
204	*/
205	#pragma pack(1)
206	typedef struct DMGBLKXDESC
207	{
208	uint32_t u32Type; /*< 0x000 - Type of the descriptor. /
209	uint32_t u32Reserved; /*< 0x004 - Reserved, but contains +beg or +end in case thisi is a comment descriptor. /
210	uint64_t u64SectorStart; /*< 0x008 - First sector number in the block this entry describes. /
211	uint64_t u64SectorCount; /*< 0x010 - Number of sectors this entry describes. /
212	uint64_t offData; /*< 0x018 - Offset in the image where the data starts. /
213	uint64_t cbData; /*< 0x020 - Number of bytes in the image. /
214	} DMGBLKXDESC;
215	#pragma pack()
216	AssertCompileSize(DMGBLKXDESC, 40);
217
218	typedef DMGBLKXDESC *PDMGBLKXDESC;
219	typedef const DMGBLKXDESC *PCDMGBLKXDESC;
220
221	/** Raw image data type. */
222	#define DMGBLKXDESC_TYPE_RAW 1
223	/** Ignore type. */
224	#define DMGBLKXDESC_TYPE_IGNORE 2
225	/** Compressed with zlib type. */
226	#define DMGBLKXDESC_TYPE_ZLIB UINT32_C(0x80000005)
227	/** Comment type. */
228	#define DMGBLKXDESC_TYPE_COMMENT UINT32_C(0x7ffffffe)
229	/** Terminator type. */
230	#define DMGBLKXDESC_TYPE_TERMINATOR UINT32_C(0xffffffff)
231
232	/**
233	* UDIF Resource Entry.
234	*/
235	typedef struct DMGUDIFRSRCENTRY
236	{
237	/** The ID. */
238	int32_t iId;
239	/** Attributes. */
240	uint32_t fAttributes;
241	/** The name. */
242	char *pszName;
243	/** The CoreFoundation name. Can be NULL. */
244	char *pszCFName;
245	/** The size of the data. */
246	size_t cbData;
247	/** The raw data. */
248	uint8_t *pbData;
249	} DMGUDIFRSRCENTRY;
250	/** Pointer to an UDIF resource entry. */
251	typedef DMGUDIFRSRCENTRY *PDMGUDIFRSRCENTRY;
252	/** Pointer to a const UDIF resource entry. */
253	typedef DMGUDIFRSRCENTRY const *PCDMGUDIFRSRCENTRY;
254
255	/**
256	* UDIF Resource Array.
257	*/
258	typedef struct DMGUDIFRSRCARRAY
259	{
260	/** The array name. */
261	char szName[12];
262	/** The number of occupied entries. */
263	uint32_t cEntries;
264	/** The array entries.
265	* A lazy bird ASSUME there are no more than 4 entries in any DMG. Increase the
266	* size if DMGs with more are found.
267	* r=aeichner: Saw one with 6 here (image of a whole DVD) */
268	DMGUDIFRSRCENTRY aEntries[10];
269	} DMGUDIFRSRCARRAY;
270	/** Pointer to a UDIF resource array. */
271	typedef DMGUDIFRSRCARRAY *PDMGUDIFRSRCARRAY;
272	/** Pointer to a const UDIF resource array. */
273	typedef DMGUDIFRSRCARRAY const *PCDMGUDIFRSRCARRAY;
274
275	/**
276	* DMG extent types.
277	*/
278	typedef enum DMGEXTENTTYPE
279	{
280	/** Null, never used. */
281	DMGEXTENTTYPE_NULL = 0,
282	/** Raw image data. */
283	DMGEXTENTTYPE_RAW,
284	/** Zero extent, reads return 0 and writes have no effect. */
285	DMGEXTENTTYPE_ZERO,
286	/** Compressed extent - compression method ZLIB. */
287	DMGEXTENTTYPE_COMP_ZLIB,
288	/** 32bit hack. */
289	DMGEXTENTTYPE_32BIT_HACK = 0x7fffffff
290	} DMGEXTENTTYPE, *PDMGEXTENTTYPE;
291
292	/**
293	* DMG extent mapping a virtual image block to real file offsets.
294	*/
295	typedef struct DMGEXTENT
296	{
297	/** Extent type. */
298	DMGEXTENTTYPE enmType;
299	/** First sector this extent describes. */
300	uint64_t uSectorExtent;
301	/** Number of sectors this extent describes. */
302	uint64_t cSectorsExtent;
303	/** Start offset in the real file. */
304	uint64_t offFileStart;
305	/** Number of bytes for the extent data in the file. */
306	uint64_t cbFile;
307	} DMGEXTENT;
308	/** Pointer to an DMG extent. */
309	typedef DMGEXTENT *PDMGEXTENT;
310
311	/**
312	* VirtualBox Apple Disk Image (DMG) interpreter instance data.
313	*/
314	typedef struct DMGIMAGE
315	{
316	/** Image name.
317	* Kept around for logging and delete-on-close purposes. */
318	const char *pszFilename;
319	/** Storage handle. */
320	PVDIOSTORAGE pStorage;
321
322	/** Pointer to the per-disk VD interface list. */
323	PVDINTERFACE pVDIfsDisk;
324	/** Pointer to the per-image VD interface list. */
325	PVDINTERFACE pVDIfsImage;
326	/** Error interface. */
327	PVDINTERFACEERROR pIfError;
328	/** I/O interface - careful accessing this because of hDmgFileInXar. */
329	PVDINTERFACEIOINT pIfIoXxx;
330
331
332	/** The VFS file handle for a DMG within a XAR archive. */
333	RTVFSFILE hDmgFileInXar;
334	/** XAR file system stream handle.
335	* Sitting on this isn't really necessary, but insurance against the XAR code
336	* changes making back references from child objects to the stream itself. */
337	RTVFSFSSTREAM hXarFss;
338
339	/** Flags the image was opened with. */
340	uint32_t uOpenFlags;
341	/** Image flags. */
342	unsigned uImageFlags;
343	/** Total size of the virtual image. */
344	uint64_t cbSize;
345	/** Size of the image. */
346	uint64_t cbFile;
347	/** Physical geometry of this image. */
348	VDGEOMETRY PCHSGeometry;
349	/** Logical geometry of this image. */
350	VDGEOMETRY LCHSGeometry;
351
352	/** The resources.
353	* A lazy bird ASSUME there are only two arrays in the resource-fork section in
354	* the XML, namely 'blkx' and 'plst'. These have been assigned fixed indexes. */
355	DMGUDIFRSRCARRAY aRsrcs[2];
356	/** The UDIF footer. */
357	DMGUDIF Ftr;
358
359	/** Number of valid extents in the array. */
360	unsigned cExtents;
361	/** Number of entries the array can hold. */
362	unsigned cExtentsMax;
363	/** Pointer to the extent array. */
364	PDMGEXTENT paExtents;
365	/** Index of the last accessed extent. */
366	unsigned idxExtentLast;
367
368	/** Extent which owns the data in the buffer. */
369	PDMGEXTENT pExtentDecomp;
370	/** Buffer holding the decompressed data for a extent. */
371	void *pvDecompExtent;
372	/** Size of the buffer. */
373	size_t cbDecompExtent;
374	/** The static region list. */
375	VDREGIONLIST RegionList;
376	} DMGIMAGE;
377	/** Pointer to an instance of the DMG Image Interpreter. */
378	typedef DMGIMAGE *PDMGIMAGE;
379
380	/** @name Resources indexes (into DMG::aRsrcs).
381	* @{ */
382	#define DMG_RSRC_IDX_BLKX 0
383	#define DMG_RSRC_IDX_PLST 1
384	/** @} */
385
386	/** State for the input callout of the inflate reader. */
387	typedef struct DMGINFLATESTATE
388	{
389	/* Image this operation relates to. */
390	PDMGIMAGE pImage;
391	/* Total size of the data to read. */
392	size_t cbSize;
393	/* Offset in the file to read. */
394	uint64_t uFileOffset;
395	/* Current read position. */
396	ssize_t iOffset;
397	} DMGINFLATESTATE;
398
399
400	/*********************************************************************************************************************************
401	* Defined Constants And Macros *
402	*********************************************************************************************************************************/
403	/** @def DMG_PRINTF
404	* Wrapper for LogRel.
405	*/
406	#define DMG_PRINTF(a) LogRel(a)
407
408	/** @def DMG_VALIDATE
409	* For validating a struct thing and log/print what's wrong.
410	*/
411	# define DMG_VALIDATE(expr, logstuff) \
412	do { \
413	if (!(expr)) \
414	{ \
415	LogRel(("DMG: validation failed: %s\nDMG: ", #expr)); \
416	LogRel(logstuff); \
417	fRc = false; \
418	} \
419	} while (0)
420
421
422	/*********************************************************************************************************************************
423	* Static Variables *
424	*********************************************************************************************************************************/
425
426	/** NULL-terminated array of supported file extensions. */
427	static const VDFILEEXTENSION s_aDmgFileExtensions[] =
428	{
429	{"dmg", VDTYPE_OPTICAL_DISC},
430	{NULL, VDTYPE_INVALID}
431	};
432
433
434	/*********************************************************************************************************************************
435	* Internal Functions *
436	*********************************************************************************************************************************/
437	#if 0 /* unused */
438	static void dmgUdifFtrHost2FileEndian(PDMGUDIF pUdif);
439	#endif
440	static void dmgUdifFtrFile2HostEndian(PDMGUDIF pUdif);
441
442	static void dmgUdifIdHost2FileEndian(PDMGUDIFID pId);
443	static void dmgUdifIdFile2HostEndian(PDMGUDIFID pId);
444
445	#if 0 /* unused */
446	static void dmgUdifCkSumHost2FileEndian(PDMGUDIFCKSUM pCkSum);
447	#endif
448	static void dmgUdifCkSumFile2HostEndian(PDMGUDIFCKSUM pCkSum);
449	static bool dmgUdifCkSumIsValid(PCDMGUDIFCKSUM pCkSum, const char *pszPrefix);
450
451
452
453	/**
454	* vdIfIoIntFileReadSync / RTVfsFileReadAt wrapper.
455	*/
456	static int dmgWrapFileReadSync(PDMGIMAGE pThis, RTFOFF off, void *pvBuf, size_t cbToRead)
457	{
458	int rc;
459	if (pThis->hDmgFileInXar == NIL_RTVFSFILE)
460	rc = vdIfIoIntFileReadSync(pThis->pIfIoXxx, pThis->pStorage, off, pvBuf, cbToRead);
461	else
462	rc = RTVfsFileReadAt(pThis->hDmgFileInXar, off, pvBuf, cbToRead, NULL);
463	return rc;
464	}
465
466	/**
467	* vdIfIoIntFileReadUser / RTVfsFileReadAt wrapper.
468	*/
469	static int dmgWrapFileReadUser(PDMGIMAGE pThis, RTFOFF off, PVDIOCTX pIoCtx, size_t cbToRead)
470	{
471	int rc;
472	if (pThis->hDmgFileInXar == NIL_RTVFSFILE)
473	rc = vdIfIoIntFileReadUser(pThis->pIfIoXxx, pThis->pStorage, off, pIoCtx, cbToRead);
474	else
475	{
476	/*
477	* Alloate a temporary buffer on the stack or heap and use
478	* vdIfIoIntIoCtxCopyTo to work the context.
479	*
480	* The I/O context stuff seems too complicated and undocument that I'm
481	* not going to bother trying to implement this efficiently right now.
482	*/
483	void *pvFree = NULL;
484	void *pvBuf;
485	if (cbToRead < _32K)
486	pvBuf = alloca(cbToRead);
487	else
488	pvFree = pvBuf = RTMemTmpAlloc(cbToRead);
489	if (pvBuf)
490	{
491	rc = RTVfsFileReadAt(pThis->hDmgFileInXar, off, pvBuf, cbToRead, NULL);
492	if (RT_SUCCESS(rc))
493	vdIfIoIntIoCtxCopyTo(pThis->pIfIoXxx, pIoCtx, pvBuf, cbToRead);
494	if (pvFree)
495	RTMemTmpFree(pvFree);
496	}
497	else
498	rc = VERR_NO_TMP_MEMORY;
499	}
500	return rc;
501	}
502
503	/**
504	* vdIfIoIntFileGetSize / RTVfsFileQuerySize wrapper.
505	*/
506	static int dmgWrapFileGetSize(PDMGIMAGE pThis, uint64_t *pcbFile)
507	{
508	int rc;
509	if (pThis->hDmgFileInXar == NIL_RTVFSFILE)
510	rc = vdIfIoIntFileGetSize(pThis->pIfIoXxx, pThis->pStorage, pcbFile);
511	else
512	rc = RTVfsFileQuerySize(pThis->hDmgFileInXar, pcbFile);
513	return rc;
514	}
515
516
517
518	static DECLCALLBACK(int) dmgFileInflateHelper(void pvUser, void pvBuf, size_t cbBuf, size_t *pcbBuf)
519	{
520	DMGINFLATESTATE pInflateState = (DMGINFLATESTATE )pvUser;
521
522	Assert(cbBuf);
523	if (pInflateState->iOffset < 0)
524	{
525	(uint8_t )pvBuf = RTZIPTYPE_ZLIB;
526	if (pcbBuf)
527	*pcbBuf = 1;
528	pInflateState->iOffset = 0;
529	return VINF_SUCCESS;
530	}
531	cbBuf = RT_MIN(cbBuf, pInflateState->cbSize);
532	int rc = dmgWrapFileReadSync(pInflateState->pImage, pInflateState->uFileOffset, pvBuf, cbBuf);
533	if (RT_FAILURE(rc))
534	return rc;
535	pInflateState->uFileOffset += cbBuf;
536	pInflateState->iOffset += cbBuf;
537	pInflateState->cbSize -= cbBuf;
538	Assert(pcbBuf);
539	*pcbBuf = cbBuf;
540	return VINF_SUCCESS;
541	}
542
543	/**
544	* Internal: read from a file and inflate the compressed data,
545	* distinguishing between async and normal operation
546	*/
547	DECLINLINE(int) dmgFileInflateSync(PDMGIMAGE pImage, uint64_t uOffset, size_t cbToRead,
548	void *pvBuf, size_t cbBuf)
549	{
550	int rc;
551	PRTZIPDECOMP pZip = NULL;
552	DMGINFLATESTATE InflateState;
553	size_t cbActuallyRead;
554
555	InflateState.pImage = pImage;
556	InflateState.cbSize = cbToRead;
557	InflateState.uFileOffset = uOffset;
558	InflateState.iOffset = -1;
559
560	rc = RTZipDecompCreate(&pZip, &InflateState, dmgFileInflateHelper);
561	if (RT_FAILURE(rc))
562	return rc;
563	rc = RTZipDecompress(pZip, pvBuf, cbBuf, &cbActuallyRead);
564	RTZipDecompDestroy(pZip);
565	if (RT_FAILURE(rc))
566	return rc;
567	if (cbActuallyRead != cbBuf)
568	rc = VERR_VD_VMDK_INVALID_FORMAT;
569	return rc;
570	}
571
572	/**
573	* Swaps endian.
574	* @param pUdif The structure.
575	*/
576	static void dmgSwapEndianUdif(PDMGUDIF pUdif)
577	{
578	#ifndef RT_BIG_ENDIAN
579	pUdif->u32Magic = RT_BSWAP_U32(pUdif->u32Magic);
580	pUdif->u32Version = RT_BSWAP_U32(pUdif->u32Version);
581	pUdif->cbFooter = RT_BSWAP_U32(pUdif->cbFooter);
582	pUdif->fFlags = RT_BSWAP_U32(pUdif->fFlags);
583	pUdif->offRunData = RT_BSWAP_U64(pUdif->offRunData);
584	pUdif->offData = RT_BSWAP_U64(pUdif->offData);
585	pUdif->cbData = RT_BSWAP_U64(pUdif->cbData);
586	pUdif->offRsrc = RT_BSWAP_U64(pUdif->offRsrc);
587	pUdif->cbRsrc = RT_BSWAP_U64(pUdif->cbRsrc);
588	pUdif->iSegment = RT_BSWAP_U32(pUdif->iSegment);
589	pUdif->cSegments = RT_BSWAP_U32(pUdif->cSegments);
590	pUdif->offXml = RT_BSWAP_U64(pUdif->offXml);
591	pUdif->cbXml = RT_BSWAP_U64(pUdif->cbXml);
592	pUdif->u32Type = RT_BSWAP_U32(pUdif->u32Type);
593	pUdif->cSectors = RT_BSWAP_U64(pUdif->cSectors);
594	#endif
595	}
596
597
598	#if 0 /* unused */
599	/**
600	* Swaps endian from host cpu to file.
601	* @param pUdif The structure.
602	*/
603	static void dmgUdifFtrHost2FileEndian(PDMGUDIF pUdif)
604	{
605	dmgSwapEndianUdif(pUdif);
606	dmgUdifIdHost2FileEndian(&pUdif->SegmentId);
607	dmgUdifCkSumHost2FileEndian(&pUdif->DataCkSum);
608	dmgUdifCkSumHost2FileEndian(&pUdif->MasterCkSum);
609	}
610	#endif
611
612
613	/**
614	* Swaps endian from file to host cpu.
615	* @param pUdif The structure.
616	*/
617	static void dmgUdifFtrFile2HostEndian(PDMGUDIF pUdif)
618	{
619	dmgSwapEndianUdif(pUdif);
620	dmgUdifIdFile2HostEndian(&pUdif->SegmentId);
621	dmgUdifCkSumFile2HostEndian(&pUdif->DataCkSum);
622	dmgUdifCkSumFile2HostEndian(&pUdif->MasterCkSum);
623	}
624
625	/**
626	* Swaps endian from file to host cpu.
627	* @param pBlkx The blkx structure.
628	*/
629	static void dmgBlkxFile2HostEndian(PDMGBLKX pBlkx)
630	{
631	pBlkx->u32Magic = RT_BE2H_U32(pBlkx->u32Magic);
632	pBlkx->u32Version = RT_BE2H_U32(pBlkx->u32Version);
633	pBlkx->cSectornumberFirst = RT_BE2H_U64(pBlkx->cSectornumberFirst);
634	pBlkx->cSectors = RT_BE2H_U64(pBlkx->cSectors);
635	pBlkx->offDataStart = RT_BE2H_U64(pBlkx->offDataStart);
636	pBlkx->cSectorsDecompress = RT_BE2H_U32(pBlkx->cSectorsDecompress);
637	pBlkx->u32BlocksDescriptor = RT_BE2H_U32(pBlkx->u32BlocksDescriptor);
638	pBlkx->cBlocksRunCount = RT_BE2H_U32(pBlkx->cBlocksRunCount);
639	dmgUdifCkSumFile2HostEndian(&pBlkx->BlkxCkSum);
640	}
641
642	/**
643	* Swaps endian from file to host cpu.
644	* @param pBlkxDesc The blkx descriptor structure.
645	*/
646	static void dmgBlkxDescFile2HostEndian(PDMGBLKXDESC pBlkxDesc)
647	{
648	pBlkxDesc->u32Type = RT_BE2H_U32(pBlkxDesc->u32Type);
649	pBlkxDesc->u32Reserved = RT_BE2H_U32(pBlkxDesc->u32Reserved);
650	pBlkxDesc->u64SectorStart = RT_BE2H_U64(pBlkxDesc->u64SectorStart);
651	pBlkxDesc->u64SectorCount = RT_BE2H_U64(pBlkxDesc->u64SectorCount);
652	pBlkxDesc->offData = RT_BE2H_U64(pBlkxDesc->offData);
653	pBlkxDesc->cbData = RT_BE2H_U64(pBlkxDesc->cbData);
654	}
655
656	/**
657	* Validates an UDIF footer structure.
658	*
659	* @returns true if valid, false and LogRel()s on failure.
660	* @param pFtr The UDIF footer to validate.
661	* @param offFtr The offset of the structure.
662	*/
663	static bool dmgUdifFtrIsValid(PCDMGUDIF pFtr, uint64_t offFtr)
664	{
665	bool fRc = true;
666
667	DMG_VALIDATE(!(pFtr->fFlags & ~DMGUDIF_FLAGS_KNOWN_MASK), ("fFlags=%#RX32 fKnown=%RX32\n", pFtr->fFlags, DMGUDIF_FLAGS_KNOWN_MASK));
668	DMG_VALIDATE(pFtr->offRunData < offFtr, ("offRunData=%#RX64\n", pFtr->offRunData));
669	DMG_VALIDATE(pFtr->cbData <= offFtr && pFtr->offData + pFtr->cbData <= offFtr, ("cbData=%#RX64 offData=%#RX64 offFtr=%#RX64\n", pFtr->cbData, pFtr->offData, offFtr));
670	DMG_VALIDATE(pFtr->offData < offFtr, ("offData=%#RX64\n", pFtr->offData));
671	DMG_VALIDATE(pFtr->cbRsrc <= offFtr && pFtr->offRsrc + pFtr->cbRsrc <= offFtr, ("cbRsrc=%#RX64 offRsrc=%#RX64 offFtr=%#RX64\n", pFtr->cbRsrc, pFtr->offRsrc, offFtr));
672	DMG_VALIDATE(pFtr->offRsrc < offFtr, ("offRsrc=%#RX64\n", pFtr->offRsrc));
673	DMG_VALIDATE(pFtr->cSegments <= 1, ("cSegments=%RU32\n", pFtr->cSegments));
674	DMG_VALIDATE(pFtr->iSegment == 0 \|\| pFtr->iSegment == 1, ("iSegment=%RU32 cSegments=%RU32\n", pFtr->iSegment, pFtr->cSegments));
675	DMG_VALIDATE(pFtr->cbXml <= offFtr && pFtr->offXml + pFtr->cbXml <= offFtr, ("cbXml=%#RX64 offXml=%#RX64 offFtr=%#RX64\n", pFtr->cbXml, pFtr->offXml, offFtr));
676	DMG_VALIDATE(pFtr->offXml < offFtr, ("offXml=%#RX64\n", pFtr->offXml));
677	DMG_VALIDATE(pFtr->cbXml > 128, ("cbXml=%#RX64\n", pFtr->cbXml));
678	DMG_VALIDATE(pFtr->cbXml < 10 * _1M, ("cbXml=%#RX64\n", pFtr->cbXml));
679	DMG_VALIDATE(pFtr->u32Type == DMGUDIF_TYPE_DEVICE \|\| pFtr->u32Type == DMGUDIF_TYPE_PARTITION, ("u32Type=%RU32\n", pFtr->u32Type));
680	DMG_VALIDATE(pFtr->cSectors != 0, ("cSectors=%#RX64\n", pFtr->cSectors));
681	fRc &= dmgUdifCkSumIsValid(&pFtr->DataCkSum, "DataCkSum");
682	fRc &= dmgUdifCkSumIsValid(&pFtr->MasterCkSum, "MasterCkSum");
683
684	return fRc;
685	}
686
687
688	static bool dmgBlkxIsValid(PCDMGBLKX pBlkx)
689	{
690	bool fRc = true;
691
692	fRc &= dmgUdifCkSumIsValid(&pBlkx->BlkxCkSum, "BlkxCkSum");
693	DMG_VALIDATE(pBlkx->u32Magic == DMGBLKX_MAGIC, ("u32Magic=%#RX32 u32MagicExpected=%#RX32\n", pBlkx->u32Magic, DMGBLKX_MAGIC));
694	DMG_VALIDATE(pBlkx->u32Version == DMGBLKX_VERSION, ("u32Version=%#RX32 u32VersionExpected=%#RX32\n", pBlkx->u32Magic, DMGBLKX_VERSION));
695
696	return fRc;
697	}
698
699	/**
700	* Swaps endian from host cpu to file.
701	* @param pId The structure.
702	*/
703	static void dmgUdifIdHost2FileEndian(PDMGUDIFID pId)
704	{
705	NOREF(pId);
706	}
707
708
709	/**
710	* Swaps endian from file to host cpu.
711	* @param pId The structure.
712	*/
713	static void dmgUdifIdFile2HostEndian(PDMGUDIFID pId)
714	{
715	dmgUdifIdHost2FileEndian(pId);
716	}
717
718
719	/**
720	* Swaps endian.
721	* @param pCkSum The structure.
722	* @param u32Kind Kind of the checksum (CRC32, none)
723	* @param cBits Size of the checksum in bits.
724	*/
725	static void dmgSwapEndianUdifCkSum(PDMGUDIFCKSUM pCkSum, uint32_t u32Kind, uint32_t cBits)
726	{
727	#ifdef RT_BIG_ENDIAN
728	NOREF(pCkSum);
729	NOREF(u32Kind);
730	NOREF(cBits);
731	#else
732	switch (u32Kind)
733	{
734	case DMGUDIFCKSUM_NONE:
735	/* nothing to do here */
736	break;
737
738	case DMGUDIFCKSUM_CRC32:
739	Assert(cBits == 32);
740	pCkSum->u32Kind = RT_BSWAP_U32(pCkSum->u32Kind);
741	pCkSum->cBits = RT_BSWAP_U32(pCkSum->cBits);
742	pCkSum->uSum.au32[0] = RT_BSWAP_U32(pCkSum->uSum.au32[0]);
743	break;
744
745	default:
746	AssertMsgFailed(("%x\n", u32Kind));
747	break;
748	}
749	NOREF(cBits);
750	#endif
751	}
752
753
754	#if 0 /* unused */
755	/**
756	* Swaps endian from host cpu to file.
757	* @param pCkSum The structure.
758	*/
759	static void dmgUdifCkSumHost2FileEndian(PDMGUDIFCKSUM pCkSum)
760	{
761	dmgSwapEndianUdifCkSum(pCkSum, pCkSum->u32Kind, pCkSum->cBits);
762	}
763	#endif
764
765
766	/**
767	* Swaps endian from file to host cpu.
768	* @param pCkSum The structure.
769	*/
770	static void dmgUdifCkSumFile2HostEndian(PDMGUDIFCKSUM pCkSum)
771	{
772	dmgSwapEndianUdifCkSum(pCkSum, RT_BE2H_U32(pCkSum->u32Kind), RT_BE2H_U32(pCkSum->cBits));
773	}
774
775
776	/**
777	* Validates an UDIF checksum structure.
778	*
779	* @returns true if valid, false and LogRel()s on failure.
780	* @param pCkSum The checksum structure.
781	* @param pszPrefix The message prefix.
782	* @remarks This does not check the checksummed data.
783	*/
784	static bool dmgUdifCkSumIsValid(PCDMGUDIFCKSUM pCkSum, const char *pszPrefix)
785	{
786	bool fRc = true;
787
788	switch (pCkSum->u32Kind)
789	{
790	case DMGUDIFCKSUM_NONE:
791	DMG_VALIDATE(pCkSum->cBits == 0, ("%s/NONE: cBits=%d\n", pszPrefix, pCkSum->cBits));
792	break;
793
794	case DMGUDIFCKSUM_CRC32:
795	DMG_VALIDATE(pCkSum->cBits == 32, ("%s/NONE: cBits=%d\n", pszPrefix, pCkSum->cBits));
796	break;
797
798	default:
799	DMG_VALIDATE(0, ("%s: u32Kind=%#RX32\n", pszPrefix, pCkSum->u32Kind));
800	break;
801	}
802	return fRc;
803	}
804
805
806	/**
807	* Internal. Flush image data to disk.
808	*/
809	static int dmgFlushImage(PDMGIMAGE pThis)
810	{
811	int rc = VINF_SUCCESS;
812
813	if ( pThis
814	&& (pThis->pStorage \|\| pThis->hDmgFileInXar != NIL_RTVFSFILE)
815	&& !(pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY))
816	{
817	/** @todo handle writable files, update checksums etc. */
818	}
819
820	return rc;
821	}
822
823
824	/**
825	* Internal. Free all allocated space for representing an image except pThis,
826	* and optionally delete the image from disk.
827	*/
828	static int dmgFreeImage(PDMGIMAGE pThis, bool fDelete)
829	{
830	int rc = VINF_SUCCESS;
831
832	/* Freeing a never allocated image (e.g. because the open failed) is
833	* not signalled as an error. After all nothing bad happens. */
834	if (pThis)
835	{
836	RTVfsFileRelease(pThis->hDmgFileInXar);
837	pThis->hDmgFileInXar = NIL_RTVFSFILE;
838
839	RTVfsFsStrmRelease(pThis->hXarFss);
840	pThis->hXarFss = NIL_RTVFSFSSTREAM;
841
842	if (pThis->pStorage)
843	{
844	/* No point updating the file that is deleted anyway. */
845	if (!fDelete)
846	dmgFlushImage(pThis);
847
848	rc = vdIfIoIntFileClose(pThis->pIfIoXxx, pThis->pStorage);
849	pThis->pStorage = NULL;
850	}
851
852	for (unsigned iRsrc = 0; iRsrc < RT_ELEMENTS(pThis->aRsrcs); iRsrc++)
853	for (unsigned i = 0; i < pThis->aRsrcs[iRsrc].cEntries; i++)
854	{
855	if (pThis->aRsrcs[iRsrc].aEntries[i].pbData)
856	{
857	RTMemFree(pThis->aRsrcs[iRsrc].aEntries[i].pbData);
858	pThis->aRsrcs[iRsrc].aEntries[i].pbData = NULL;
859	}
860	if (pThis->aRsrcs[iRsrc].aEntries[i].pszName)
861	{
862	RTMemFree(pThis->aRsrcs[iRsrc].aEntries[i].pszName);
863	pThis->aRsrcs[iRsrc].aEntries[i].pszName = NULL;
864	}
865	if (pThis->aRsrcs[iRsrc].aEntries[i].pszCFName)
866	{
867	RTMemFree(pThis->aRsrcs[iRsrc].aEntries[i].pszCFName);
868	pThis->aRsrcs[iRsrc].aEntries[i].pszCFName = NULL;
869	}
870	}
871
872	if (fDelete && pThis->pszFilename)
873	vdIfIoIntFileDelete(pThis->pIfIoXxx, pThis->pszFilename);
874
875	if (pThis->pvDecompExtent)
876	{
877	RTMemFree(pThis->pvDecompExtent);
878	pThis->pvDecompExtent = NULL;
879	pThis->cbDecompExtent = 0;
880	}
881
882	if (pThis->paExtents)
883	{
884	RTMemFree(pThis->paExtents);
885	pThis->paExtents = NULL;
886	}
887	}
888
889	LogFlowFunc(("returns %Rrc\n", rc));
890	return rc;
891	}
892
893
894	#define STARTS_WITH(pszString, szStart) \
895	( strncmp(pszString, szStart, sizeof(szStart) - 1) == 0 )
896
897	#define STARTS_WITH_WORD(pszString, szWord) \
898	( STARTS_WITH(pszString, szWord) \
899	&& !RT_C_IS_ALNUM((pszString)[sizeof(szWord) - 1]) )
900
901	#define SKIP_AHEAD(psz, szWord) \
902	do { \
903	(psz) = RTStrStripL((psz) + sizeof(szWord) - 1); \
904	} while (0)
905
906	#define REQUIRE_WORD(psz, szWord) \
907	do { \
908	if (!STARTS_WITH_WORD(psz, szWord)) \
909	return psz; \
910	(psz) = RTStrStripL((psz) + sizeof(szWord) - 1); \
911	} while (0)
912
913	#define REQUIRE_TAG(psz, szTag) \
914	do { \
915	if (!STARTS_WITH(psz, "<" szTag ">")) \
916	return psz; \
917	(psz) = RTStrStripL((psz) + sizeof("<" szTag ">") - 1); \
918	} while (0)
919
920	#define REQUIRE_TAG_NO_STRIP(psz, szTag) \
921	do { \
922	if (!STARTS_WITH(psz, "<" szTag ">")) \
923	return psz; \
924	(psz) += sizeof("<" szTag ">") - 1; \
925	} while (0)
926
927	#define REQUIRE_END_TAG(psz, szTag) \
928	do { \
929	if (!STARTS_WITH(psz, "</" szTag ">")) \
930	return psz; \
931	(psz) = RTStrStripL((psz) + sizeof("</" szTag ">") - 1); \
932	} while (0)
933
934
935	/**
936	* Finds the next tag end.
937	*
938	* @returns Pointer to a '>' or '\0'.
939	* @param pszCur The current position.
940	*/
941	static const char dmgXmlFindTagEnd(const char pszCur)
942	{
943	/* Might want to take quoted '>' into account? */
944	char ch;
945	while ((ch = *pszCur) != '\0' && ch != '>')
946	pszCur++;
947	return pszCur;
948	}
949
950
951	/**
952	* Finds the end tag.
953	*
954	* Does not deal with @verbatim<tag attr="1"/>@endverbatim style tags.
955	*
956	* @returns Pointer to the first char in the end tag. NULL if another tag
957	* was encountered first or if we hit the end of the file.
958	* @param ppszCur The current position (IN/OUT).
959	* @param pszTag The tag name.
960	*/
961	static const char dmgXmlFindEndTag(const char ppszCur, const char pszTag)
962	{
963	const char psz = ppszCur;
964	char ch;
965	while ((ch = *psz))
966	{
967	if (ch == '<')
968	{
969	size_t const cchTag = strlen(pszTag);
970	if ( psz[1] == '/'
971	&& !memcmp(&psz[2], pszTag, cchTag)
972	&& psz[2 + cchTag] == '>')
973	{
974	*ppszCur = psz + 2 + cchTag + 1;
975	return psz;
976	}
977	break;
978	}
979	psz++;
980	}
981	return NULL;
982	}
983
984
985	/**
986	* Reads a signed 32-bit value.
987	*
988	* @returns NULL on success, pointer to the offending text on failure.
989	* @param ppszCur The text position (IN/OUT).
990	* @param pi32 Where to store the value.
991	*/
992	static const char dmgXmlParseS32(const char ppszCur, int32_t pi32)
993	{
994	const char psz = ppszCur;
995
996	/*
997	* <string>-1</string>
998	*/
999	REQUIRE_TAG_NO_STRIP(psz, "string");
1000
1001	char *pszNext;
1002	int rc = RTStrToInt32Ex(psz, &pszNext, 0, pi32);
1003	if (rc != VWRN_TRAILING_CHARS)
1004	return *ppszCur;
1005	psz = pszNext;
1006
1007	REQUIRE_END_TAG(psz, "string");
1008	*ppszCur = psz;
1009	return NULL;
1010	}
1011
1012
1013	/**
1014	* Reads an unsigned 32-bit value.
1015	*
1016	* @returns NULL on success, pointer to the offending text on failure.
1017	* @param ppszCur The text position (IN/OUT).
1018	* @param pu32 Where to store the value.
1019	*/
1020	static const char dmgXmlParseU32(const char ppszCur, uint32_t pu32)
1021	{
1022	const char psz = ppszCur;
1023
1024	/*
1025	* <string>0x00ff</string>
1026	*/
1027	REQUIRE_TAG_NO_STRIP(psz, "string");
1028
1029	char *pszNext;
1030	int rc = RTStrToUInt32Ex(psz, &pszNext, 0, pu32);
1031	if (rc != VWRN_TRAILING_CHARS)
1032	return *ppszCur;
1033	psz = pszNext;
1034
1035	REQUIRE_END_TAG(psz, "string");
1036	*ppszCur = psz;
1037	return NULL;
1038	}
1039
1040
1041	/**
1042	* Reads a string value.
1043	*
1044	* @returns NULL on success, pointer to the offending text on failure.
1045	* @param ppszCur The text position (IN/OUT).
1046	* @param ppszString Where to store the pointer to the string. The caller
1047	* must free this using RTMemFree.
1048	*/
1049	static const char dmgXmlParseString(const char ppszCur, char *ppszString)
1050	{
1051	const char psz = ppszCur;
1052
1053	/*
1054	* <string>Driver Descriptor Map (DDM : 0)</string>
1055	*/
1056	REQUIRE_TAG_NO_STRIP(psz, "string");
1057
1058	const char *pszStart = psz;
1059	const char *pszEnd = dmgXmlFindEndTag(&psz, "string");
1060	if (!pszEnd)
1061	return *ppszCur;
1062	psz = RTStrStripL(psz);
1063
1064	ppszString = (char )RTMemDupEx(pszStart, pszEnd - pszStart, 1);
1065	if (!*ppszString)
1066	return *ppszCur;
1067
1068	*ppszCur = psz;
1069	return NULL;
1070	}
1071
1072
1073	/**
1074	* Parses the BASE-64 coded data tags.
1075	*
1076	* @returns NULL on success, pointer to the offending text on failure.
1077	* @param ppszCur The text position (IN/OUT).
1078	* @param ppbData Where to store the pointer to the data we've read. The
1079	* caller must free this using RTMemFree.
1080	* @param pcbData The number of bytes we're returning.
1081	*/
1082	static const char dmgXmlParseData(const char ppszCur, uint8_t ppbData, size_t pcbData)
1083	{
1084	const char psz = ppszCur;
1085
1086	/*
1087	* <data> AAAAA... </data>
1088	*/
1089	REQUIRE_TAG(psz, "data");
1090
1091	const char *pszStart = psz;
1092	ssize_t cbData = RTBase64DecodedSize(pszStart, (char **)&psz);
1093	if (cbData == -1)
1094	return *ppszCur;
1095
1096	REQUIRE_END_TAG(psz, "data");
1097
1098	ppbData = (uint8_t )RTMemAlloc(cbData);
1099	if (!*ppbData)
1100	return *ppszCur;
1101	char *pszIgnored;
1102	int rc = RTBase64Decode(pszStart, *ppbData, cbData, pcbData, &pszIgnored);
1103	if (RT_FAILURE(rc))
1104	{
1105	RTMemFree(*ppbData);
1106	*ppbData = NULL;
1107	return *ppszCur;
1108	}
1109
1110	*ppszCur = psz;
1111	return NULL;
1112	}
1113
1114
1115	/**
1116	* Parses the XML resource-fork in a rather presumptive manner.
1117	*
1118	* This function is supposed to construct the DMG::aRsrcs instance data
1119	* parts.
1120	*
1121	* @returns NULL on success, pointer to the problematic text on failure.
1122	* @param pThis The DMG instance data.
1123	* @param pszXml The XML text to parse, UTF-8.
1124	*/
1125	static const char dmgOpenXmlToRsrc(PDMGIMAGE pThis, char const pszXml)
1126	{
1127	const char *psz = pszXml;
1128
1129	/*
1130	* Verify the ?xml, !DOCTYPE and plist tags.
1131	*/
1132	SKIP_AHEAD(psz, "");
1133
1134	/* <?xml version="1.0" encoding="UTF-8"?> */
1135	REQUIRE_WORD(psz, "<?xml");
1136	while (*psz != '?')
1137	{
1138	if (!*psz)
1139	return psz;
1140	if (STARTS_WITH_WORD(psz, "version="))
1141	{
1142	SKIP_AHEAD(psz, "version=");
1143	REQUIRE_WORD(psz, "\"1.0\"");
1144	}
1145	else if (STARTS_WITH_WORD(psz, "encoding="))
1146	{
1147	SKIP_AHEAD(psz, "encoding=");
1148	REQUIRE_WORD(psz, "\"UTF-8\"");
1149	}
1150	else
1151	return psz;
1152	}
1153	SKIP_AHEAD(psz, "?>");
1154
1155	/* <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> */
1156	REQUIRE_WORD(psz, "<!DOCTYPE");
1157	REQUIRE_WORD(psz, "plist");
1158	REQUIRE_WORD(psz, "PUBLIC");
1159	psz = dmgXmlFindTagEnd(psz);
1160	REQUIRE_WORD(psz, ">");
1161
1162	/* <plist version="1.0"> */
1163	REQUIRE_WORD(psz, "<plist");
1164	REQUIRE_WORD(psz, "version=");
1165	REQUIRE_WORD(psz, "\"1.0\"");
1166	REQUIRE_WORD(psz, ">");
1167
1168	/*
1169	* Descend down to the 'resource-fork' dictionary.
1170	* ASSUME it's the only top level dictionary.
1171	*/
1172	/* <dict> <key>resource-fork</key> */
1173	REQUIRE_TAG(psz, "dict");
1174	REQUIRE_WORD(psz, "<key>resource-fork</key>");
1175
1176	/*
1177	* Parse the keys in the resource-fork dictionary.
1178	* ASSUME that there are just two, 'blkx' and 'plst'.
1179	*/
1180	REQUIRE_TAG(psz, "dict");
1181	while (!STARTS_WITH_WORD(psz, "</dict>"))
1182	{
1183	/*
1184	* Parse the key and Create the resource-fork entry.
1185	*/
1186	unsigned iRsrc;
1187	if (STARTS_WITH_WORD(psz, "<key>blkx</key>"))
1188	{
1189	REQUIRE_WORD(psz, "<key>blkx</key>");
1190	iRsrc = DMG_RSRC_IDX_BLKX;
1191	strcpy(&pThis->aRsrcs[iRsrc].szName[0], "blkx");
1192	}
1193	else if (STARTS_WITH_WORD(psz, "<key>plst</key>"))
1194	{
1195	REQUIRE_WORD(psz, "<key>plst</key>");
1196	iRsrc = DMG_RSRC_IDX_PLST;
1197	strcpy(&pThis->aRsrcs[iRsrc].szName[0], "plst");
1198	}
1199	else
1200	{
1201	SKIP_AHEAD(psz, "</array>");
1202	continue;
1203	}
1204
1205
1206	/*
1207	* Descend into the array and add the elements to the resource entry.
1208	*/
1209	/* <array> */
1210	REQUIRE_TAG(psz, "array");
1211	while (!STARTS_WITH_WORD(psz, "</array>"))
1212	{
1213	REQUIRE_TAG(psz, "dict");
1214	uint32_t i = pThis->aRsrcs[iRsrc].cEntries;
1215	if (i == RT_ELEMENTS(pThis->aRsrcs[iRsrc].aEntries))
1216	return psz;
1217
1218	while (!STARTS_WITH_WORD(psz, "</dict>"))
1219	{
1220
1221	/* switch on the key. */
1222	const char *pszErr;
1223	if (STARTS_WITH_WORD(psz, "<key>Attributes</key>"))
1224	{
1225	REQUIRE_WORD(psz, "<key>Attributes</key>");
1226	pszErr = dmgXmlParseU32(&psz, &pThis->aRsrcs[iRsrc].aEntries[i].fAttributes);
1227	}
1228	else if (STARTS_WITH_WORD(psz, "<key>ID</key>"))
1229	{
1230	REQUIRE_WORD(psz, "<key>ID</key>");
1231	pszErr = dmgXmlParseS32(&psz, &pThis->aRsrcs[iRsrc].aEntries[i].iId);
1232	}
1233	else if (STARTS_WITH_WORD(psz, "<key>Name</key>"))
1234	{
1235	REQUIRE_WORD(psz, "<key>Name</key>");
1236	pszErr = dmgXmlParseString(&psz, &pThis->aRsrcs[iRsrc].aEntries[i].pszName);
1237	}
1238	else if (STARTS_WITH_WORD(psz, "<key>CFName</key>"))
1239	{
1240	REQUIRE_WORD(psz, "<key>CFName</key>");
1241	pszErr = dmgXmlParseString(&psz, &pThis->aRsrcs[iRsrc].aEntries[i].pszCFName);
1242	}
1243	else if (STARTS_WITH_WORD(psz, "<key>Data</key>"))
1244	{
1245	REQUIRE_WORD(psz, "<key>Data</key>");
1246	pszErr = dmgXmlParseData(&psz, &pThis->aRsrcs[iRsrc].aEntries[i].pbData, &pThis->aRsrcs[iRsrc].aEntries[i].cbData);
1247	}
1248	else
1249	pszErr = psz;
1250	if (pszErr)
1251	return pszErr;
1252	} /* while not </dict> */
1253	REQUIRE_END_TAG(psz, "dict");
1254
1255	pThis->aRsrcs[iRsrc].cEntries++;
1256	} /* while not </array> */
1257	REQUIRE_END_TAG(psz, "array");
1258
1259	} /* while not </dict> */
1260	REQUIRE_END_TAG(psz, "dict");
1261
1262	/*
1263	* ASSUMING there is only the 'resource-fork', we'll now see the end of
1264	* the outer dict, plist and text.
1265	*/
1266	/* </dict> </plist> */
1267	REQUIRE_END_TAG(psz, "dict");
1268	REQUIRE_END_TAG(psz, "plist");
1269
1270	/* the end */
1271	if (*psz)
1272	return psz;
1273
1274	return NULL;
1275	}
1276
1277	#undef REQUIRE_END_TAG
1278	#undef REQUIRE_TAG_NO_STRIP
1279	#undef REQUIRE_TAG
1280	#undef REQUIRE_WORD
1281	#undef SKIP_AHEAD
1282	#undef STARTS_WITH_WORD
1283	#undef STARTS_WITH
1284
1285	/**
1286	* Returns the data attached to a resource.
1287	*
1288	* @returns VBox status code.
1289	* @param pThis The DMG instance data.
1290	* @param pcszRsrcName Name of the resource to get.
1291	* @param ppcRsrc Where to store the pointer to the resource data on success.
1292	*/
1293	static int dmgGetRsrcData(PDMGIMAGE pThis, const char *pcszRsrcName,
1294	PCDMGUDIFRSRCARRAY *ppcRsrc)
1295	{
1296	int rc = VERR_NOT_FOUND;
1297
1298	for (unsigned i = 0; i < RT_ELEMENTS(pThis->aRsrcs); i++)
1299	{
1300	if (!strcmp(pThis->aRsrcs[i].szName, pcszRsrcName))
1301	{
1302	*ppcRsrc = &pThis->aRsrcs[i];
1303	rc = VINF_SUCCESS;
1304	break;
1305	}
1306	}
1307
1308	return rc;
1309	}
1310
1311	/**
1312	* Creates a new extent from the given blkx descriptor.
1313	*
1314	* @returns VBox status code.
1315	* @param pThis DMG instance data.
1316	* @param uSectorPart First sector the partition owning the blkx descriptor has.
1317	* @param pBlkxDesc The blkx descriptor.
1318	*/
1319	static int dmgExtentCreateFromBlkxDesc(PDMGIMAGE pThis, uint64_t uSectorPart, PDMGBLKXDESC pBlkxDesc)
1320	{
1321	int rc = VINF_SUCCESS;
1322	DMGEXTENTTYPE enmExtentTypeNew;
1323	PDMGEXTENT pExtentNew = NULL;
1324
1325	if (pBlkxDesc->u32Type == DMGBLKXDESC_TYPE_RAW)
1326	enmExtentTypeNew = DMGEXTENTTYPE_RAW;
1327	else if (pBlkxDesc->u32Type == DMGBLKXDESC_TYPE_IGNORE)
1328	enmExtentTypeNew = DMGEXTENTTYPE_ZERO;
1329	else if (pBlkxDesc->u32Type == DMGBLKXDESC_TYPE_ZLIB)
1330	enmExtentTypeNew = DMGEXTENTTYPE_COMP_ZLIB;
1331	else
1332	{
1333	AssertMsgFailed(("This method supports only raw or zero extents!\n"));
1334	return VERR_NOT_SUPPORTED;
1335	}
1336
1337	/** @todo Merge raw extents if possible to save memory. */
1338	#if 0
1339	pExtentNew = pThis->pExtentLast;
1340	if ( pExtentNew
1341	&& pExtentNew->enmType == enmExtentTypeNew
1342	&& enmExtentTypeNew == DMGEXTENTTYPE_RAW
1343	&& pExtentNew->uSectorExtent + pExtentNew->cSectorsExtent == offDevice + pBlkxDesc->u64SectorStart * DMG_SECTOR_SIZE;
1344	&& pExtentNew->offFileStart + pExtentNew->cbExtent == pBlkxDesc->offData)
1345	{
1346	/* Increase the last extent. */
1347	pExtentNew->cbExtent += pBlkxDesc->cbData;
1348	}
1349	else
1350	#endif
1351	{
1352	if (pThis->cExtentsMax == pThis->cExtents)
1353	{
1354	pThis->cExtentsMax += 64;
1355
1356	/* Increase the array. */
1357	PDMGEXTENT paExtentsNew = (PDMGEXTENT)RTMemRealloc(pThis->paExtents, sizeof(DMGEXTENT) * pThis->cExtentsMax);
1358	if (!paExtentsNew)
1359	{
1360	rc = VERR_NO_MEMORY;
1361	pThis->cExtentsMax -= 64;
1362	}
1363	else
1364	pThis->paExtents = paExtentsNew;
1365	}
1366
1367	if (RT_SUCCESS(rc))
1368	{
1369	pExtentNew = &pThis->paExtents[pThis->cExtents++];
1370
1371	pExtentNew->enmType = enmExtentTypeNew;
1372	pExtentNew->uSectorExtent = uSectorPart + pBlkxDesc->u64SectorStart;
1373	pExtentNew->cSectorsExtent = pBlkxDesc->u64SectorCount;
1374	pExtentNew->offFileStart = pBlkxDesc->offData;
1375	pExtentNew->cbFile = pBlkxDesc->cbData;
1376	}
1377	}
1378
1379	return rc;
1380	}
1381
1382	/**
1383	* Find the extent for the given sector number.
1384	*/
1385	static PDMGEXTENT dmgExtentGetFromOffset(PDMGIMAGE pThis, uint64_t uSector)
1386	{
1387	/*
1388	* We assume that the array is ordered from lower to higher sector
1389	* numbers.
1390	* This makes it possible to bisect the array to find the extent
1391	* faster than using a linked list.
1392	*/
1393	PDMGEXTENT pExtent = NULL;
1394	unsigned idxCur = pThis->idxExtentLast;
1395	unsigned idxMax = pThis->cExtents;
1396	unsigned idxMin = 0;
1397
1398	while (idxMin < idxMax)
1399	{
1400	PDMGEXTENT pExtentCur = &pThis->paExtents[idxCur];
1401
1402	/* Determine the search direction. */
1403	if (uSector < pExtentCur->uSectorExtent)
1404	{
1405	/* Search left from the current extent. */
1406	idxMax = idxCur;
1407	}
1408	else if (uSector >= pExtentCur->uSectorExtent + pExtentCur->cSectorsExtent)
1409	{
1410	/* Search right from the current extent. */
1411	idxMin = idxCur;
1412	}
1413	else
1414	{
1415	/* The sector lies in the extent, stop searching. */
1416	pExtent = pExtentCur;
1417	break;
1418	}
1419
1420	idxCur = idxMin + (idxMax - idxMin) / 2;
1421	}
1422
1423	if (pExtent)
1424	pThis->idxExtentLast = idxCur;
1425
1426	return pExtent;
1427	}
1428
1429	/**
1430	* Goes through the BLKX structure and creates the necessary extents.
1431	*/
1432	static int dmgBlkxParse(PDMGIMAGE pThis, PDMGBLKX pBlkx)
1433	{
1434	int rc = VINF_SUCCESS;
1435	PDMGBLKXDESC pBlkxDesc = (PDMGBLKXDESC)(pBlkx + 1);
1436
1437	for (unsigned i = 0; i < pBlkx->cBlocksRunCount; i++)
1438	{
1439	dmgBlkxDescFile2HostEndian(pBlkxDesc);
1440
1441	switch (pBlkxDesc->u32Type)
1442	{
1443	case DMGBLKXDESC_TYPE_RAW:
1444	case DMGBLKXDESC_TYPE_IGNORE:
1445	case DMGBLKXDESC_TYPE_ZLIB:
1446	{
1447	rc = dmgExtentCreateFromBlkxDesc(pThis, pBlkx->cSectornumberFirst, pBlkxDesc);
1448	break;
1449	}
1450	case DMGBLKXDESC_TYPE_COMMENT:
1451	case DMGBLKXDESC_TYPE_TERMINATOR:
1452	break;
1453	default:
1454	rc = VERR_VD_DMG_INVALID_HEADER;
1455	break;
1456	}
1457
1458	if ( pBlkxDesc->u32Type == DMGBLKXDESC_TYPE_TERMINATOR
1459	\|\| RT_FAILURE(rc))
1460	break;
1461
1462	pBlkxDesc++;
1463	}
1464
1465	return rc;
1466	}
1467
1468
1469	/**
1470	* Worker for dmgOpenImage that tries to open a DMG inside a XAR file.
1471	*
1472	* We'll select the first .dmg inside the archive that we can get a file
1473	* interface to.
1474	*
1475	* @returns VBox status code.
1476	* @param fOpen Flags for defining the open type.
1477	* @param pVDIfIoInt The internal VD I/O interface to use.
1478	* @param pvStorage The storage pointer that goes with @a pVDIfsIo.
1479	* @param pszFilename The input filename, optional.
1480	* @param phXarFss Where to return the XAR file system stream handle on
1481	* success
1482	* @param phDmgFileInXar Where to return the VFS handle to the DMG file
1483	* within the XAR image on success.
1484	*
1485	* @remarks Not using the PDMGIMAGE structure directly here because the function
1486	* is being in serveral places.
1487	*/
1488	static int dmgOpenImageWithinXar(uint32_t fOpen, PVDINTERFACEIOINT pVDIfIoInt, void pvStorage, const char pszFilename,
1489	PRTVFSFSSTREAM phXarFss, PRTVFSFILE phDmgFileInXar)
1490	{
1491	/*
1492	* Open the XAR file stream.
1493	*/
1494	RTVFSFILE hVfsFile;
1495	#ifdef VBOX_WITH_DIRECT_XAR_ACCESS
1496	int rc = RTVfsFileOpenNormal(pszFilename, fOpen, &hVfsFile);
1497	#else
1498	int rc = VDIfCreateVfsFile(NULL, pVDIfIoInt, pvStorage, fOpen, &hVfsFile);
1499	#endif
1500	if (RT_FAILURE(rc))
1501	return rc;
1502
1503	RTVFSIOSTREAM hVfsIos = RTVfsFileToIoStream(hVfsFile);
1504	RTVfsFileRelease(hVfsFile);
1505
1506	RTVFSFSSTREAM hXarFss;
1507	rc = RTZipXarFsStreamFromIoStream(hVfsIos, 0 /fFlags/, &hXarFss);
1508	RTVfsIoStrmRelease(hVfsIos);
1509	if (RT_FAILURE(rc))
1510	return rc;
1511
1512	/*
1513	* Look for a DMG in the stream that we can use.
1514	*/
1515	for (;;)
1516	{
1517	char *pszName;
1518	RTVFSOBJTYPE enmType;
1519	RTVFSOBJ hVfsObj;
1520	rc = RTVfsFsStrmNext(hXarFss, &pszName, &enmType, &hVfsObj);
1521	if (RT_FAILURE(rc))
1522	break;
1523
1524	/* It must be a file object so it can be seeked, this also implies that
1525	it's uncompressed. Then it must have the .dmg suffix. */
1526	if (enmType == RTVFSOBJTYPE_FILE)
1527	{
1528	size_t cchName = strlen(pszName);
1529	const char *pszSuff = pszName + cchName - 4;
1530	if ( cchName >= 4
1531	&& pszSuff[0] == '.'
1532	&& (pszSuff[1] == 'd' \|\| pszSuff[1] == 'D')
1533	&& (pszSuff[2] == 'm' \|\| pszSuff[2] == 'M')
1534	&& (pszSuff[3] == 'g' \|\| pszSuff[3] == 'G'))
1535	{
1536	RTVFSFILE hDmgFileInXar = RTVfsObjToFile(hVfsObj);
1537	AssertBreakStmt(hDmgFileInXar != NIL_RTVFSFILE, rc = VERR_INTERNAL_ERROR_3);
1538
1539	if (pszFilename)
1540	DMG_PRINTF(("DMG: Using '%s' within XAR file '%s'...\n", pszName, pszFilename));
1541	*phXarFss = hXarFss;
1542	*phDmgFileInXar = hDmgFileInXar;
1543
1544	RTStrFree(pszName);
1545	RTVfsObjRelease(hVfsObj);
1546
1547	return VINF_SUCCESS;
1548	}
1549	}
1550
1551	/* Release the current return values. */
1552	RTStrFree(pszName);
1553	RTVfsObjRelease(hVfsObj);
1554	}
1555
1556	/* Not found or some kind of error. */
1557	RTVfsFsStrmRelease(hXarFss);
1558	if (rc == VERR_EOF)
1559	rc = VERR_VD_DMG_NOT_FOUND_INSIDE_XAR;
1560	AssertStmt(RT_FAILURE_NP(rc), rc = VERR_INTERNAL_ERROR_4);
1561	return rc;
1562	}
1563
1564
1565	/**
1566	* Worker for dmgOpen that reads in and validates all the necessary
1567	* structures from the image.
1568	*
1569	* @returns VBox status code.
1570	* @param pThis The DMG instance data.
1571	* @param uOpenFlags Flags for defining the open type.
1572	*/
1573	static DECLCALLBACK(int) dmgOpenImage(PDMGIMAGE pThis, unsigned uOpenFlags)
1574	{
1575	pThis->uOpenFlags = uOpenFlags;
1576
1577	pThis->pIfError = VDIfErrorGet(pThis->pVDIfsDisk);
1578	pThis->pIfIoXxx = VDIfIoIntGet(pThis->pVDIfsImage);
1579	pThis->hDmgFileInXar = NIL_RTVFSFILE;
1580	pThis->hXarFss = NIL_RTVFSFSSTREAM;
1581	AssertPtrReturn(pThis->pIfIoXxx, VERR_INVALID_PARAMETER);
1582
1583	int rc = vdIfIoIntFileOpen(pThis->pIfIoXxx, pThis->pszFilename,
1584	VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */),
1585	&pThis->pStorage);
1586	if (RT_FAILURE(rc))
1587	{
1588	/* Do NOT signal an appropriate error here, as the VD layer has the
1589	* choice of retrying the open if it failed. */
1590	return rc;
1591	}
1592
1593	/*
1594	* Check for XAR archive.
1595	*/
1596	uint32_t u32XarMagic;
1597	rc = dmgWrapFileReadSync(pThis, 0, &u32XarMagic, sizeof(u32XarMagic));
1598	if (RT_FAILURE(rc))
1599	return rc;
1600	if (u32XarMagic == XAR_HEADER_MAGIC)
1601	{
1602	rc = dmgOpenImageWithinXar(VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */),
1603	pThis->pIfIoXxx,
1604	pThis->pStorage,
1605	pThis->pszFilename,
1606	&pThis->hXarFss, &pThis->hDmgFileInXar);
1607	if (RT_FAILURE(rc))
1608	return rc;
1609	#ifdef VBOX_WITH_DIRECT_XAR_ACCESS
1610	vdIfIoIntFileClose(pThis->pIfIoXxx, pThis->pStorage);
1611	pThis->pStorage = NULL;
1612	#endif
1613	}
1614	#if 0 /* This is for testing whether the VFS wrappers actually works. */
1615	else
1616	{
1617	rc = RTVfsFileOpenNormal(pThis->pszFilename, VDOpenFlagsToFileOpenFlags(uOpenFlags, false /* fCreate */),
1618	&pThis->hDmgFileInXar);
1619	if (RT_FAILURE(rc))
1620	return rc;
1621	vdIfIoIntFileClose(pThis->pIfIoXxx, pThis->pStorage);
1622	pThis->pStorage = NULL;
1623	}
1624	#endif
1625
1626	/*
1627	* Read the footer.
1628	*/
1629	rc = dmgWrapFileGetSize(pThis, &pThis->cbFile);
1630	if (RT_FAILURE(rc))
1631	return rc;
1632	if (pThis->cbFile < 1024)
1633	return VERR_VD_DMG_INVALID_HEADER;
1634	rc = dmgWrapFileReadSync(pThis, pThis->cbFile - sizeof(pThis->Ftr), &pThis->Ftr, sizeof(pThis->Ftr));
1635	if (RT_FAILURE(rc))
1636	return rc;
1637	dmgUdifFtrFile2HostEndian(&pThis->Ftr);
1638
1639	/*
1640	* Do we recognize the footer structure? If so, is it valid?
1641	*/
1642	if (pThis->Ftr.u32Magic != DMGUDIF_MAGIC)
1643	return VERR_VD_DMG_INVALID_HEADER;
1644	if (pThis->Ftr.u32Version != DMGUDIF_VER_CURRENT)
1645	return VERR_VD_DMG_INVALID_HEADER;
1646	if (pThis->Ftr.cbFooter != sizeof(pThis->Ftr))
1647	return VERR_VD_DMG_INVALID_HEADER;
1648
1649	if (!dmgUdifFtrIsValid(&pThis->Ftr, pThis->cbFile - sizeof(pThis->Ftr)))
1650	{
1651	DMG_PRINTF(("Bad DMG: '%s' cbFile=%RTfoff\n", pThis->pszFilename, pThis->cbFile));
1652	return VERR_VD_DMG_INVALID_HEADER;
1653	}
1654
1655	pThis->cbSize = pThis->Ftr.cSectors * DMG_SECTOR_SIZE;
1656
1657	/*
1658	* Read and parse the XML portion.
1659	*/
1660	size_t cchXml = (size_t)pThis->Ftr.cbXml;
1661	char pszXml = (char )RTMemAlloc(cchXml + 1);
1662	if (!pszXml)
1663	return VERR_NO_MEMORY;
1664	rc = dmgWrapFileReadSync(pThis, pThis->Ftr.offXml, pszXml, cchXml);
1665	if (RT_SUCCESS(rc))
1666	{
1667	pszXml[cchXml] = '\0';
1668	const char *pszError = dmgOpenXmlToRsrc(pThis, pszXml);
1669	if (!pszError)
1670	{
1671	PCDMGUDIFRSRCARRAY pRsrcBlkx = NULL;
1672
1673	rc = dmgGetRsrcData(pThis, "blkx", &pRsrcBlkx);
1674	if (RT_SUCCESS(rc))
1675	{
1676	for (unsigned idxBlkx = 0; idxBlkx < pRsrcBlkx->cEntries; idxBlkx++)
1677	{
1678	PDMGBLKX pBlkx = NULL;
1679
1680	if (pRsrcBlkx->aEntries[idxBlkx].cbData < sizeof(DMGBLKX))
1681	{
1682	rc = VERR_VD_DMG_INVALID_HEADER;
1683	break;
1684	}
1685
1686	pBlkx = (PDMGBLKX)RTMemAllocZ(pRsrcBlkx->aEntries[idxBlkx].cbData);
1687	if (!pBlkx)
1688	{
1689	rc = VERR_NO_MEMORY;
1690	break;
1691	}
1692
1693	memcpy(pBlkx, pRsrcBlkx->aEntries[idxBlkx].pbData, pRsrcBlkx->aEntries[idxBlkx].cbData);
1694
1695	dmgBlkxFile2HostEndian(pBlkx);
1696
1697	if ( dmgBlkxIsValid(pBlkx)
1698	&& pRsrcBlkx->aEntries[idxBlkx].cbData == pBlkx->cBlocksRunCount * sizeof(DMGBLKXDESC) + sizeof(DMGBLKX))
1699	rc = dmgBlkxParse(pThis, pBlkx);
1700	else
1701	rc = VERR_VD_DMG_INVALID_HEADER;
1702
1703	RTMemFree(pBlkx);
1704
1705	if (RT_FAILURE(rc))
1706	break;
1707	}
1708	}
1709	else
1710	rc = VERR_VD_DMG_INVALID_HEADER;
1711	}
1712	else
1713	{
1714	DMG_PRINTF(("** XML DUMP BEGIN \n%s\n* XML DUMP END **\n", pszXml));
1715	DMG_PRINTF(("** Bad XML at %#lx (%lu) \n%.256s\n* Bad XML END **\n",
1716	(unsigned long)(pszError - pszXml), (unsigned long)(pszError - pszXml), pszError));
1717	rc = VERR_VD_DMG_XML_PARSE_ERROR;
1718	}
1719	}
1720	RTMemFree(pszXml);
1721
1722	if (RT_SUCCESS(rc))
1723	{
1724	PVDREGIONDESC pRegion = &pThis->RegionList.aRegions[0];
1725	pThis->RegionList.fFlags = 0;
1726	pThis->RegionList.cRegions = 1;
1727
1728	pRegion->offRegion = 0; /* Disk start. */
1729	pRegion->cbBlock = 2048;
1730	pRegion->enmDataForm = VDREGIONDATAFORM_RAW;
1731	pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
1732	pRegion->cbData = 2048;
1733	pRegion->cbMetadata = 0;
1734	pRegion->cRegionBlocksOrBytes = pThis->cbSize;
1735	}
1736	else
1737	dmgFreeImage(pThis, false);
1738	return rc;
1739	}
1740
1741
1742	/** @interface_method_impl{VDIMAGEBACKEND,pfnProbe} */
1743	static DECLCALLBACK(int) dmgProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1744	PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
1745	{
1746	RT_NOREF(pVDIfsDisk, enmDesiredType);
1747	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
1748	pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
1749
1750	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
1751	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
1752
1753	/*
1754	* Open the file and check for XAR.
1755	*/
1756	PVDIOSTORAGE pStorage = NULL;
1757	int rc = vdIfIoIntFileOpen(pIfIo, pszFilename,
1758	VDOpenFlagsToFileOpenFlags(VD_OPEN_FLAGS_READONLY, false /* fCreate */),
1759	&pStorage);
1760	if (RT_FAILURE(rc))
1761	{
1762	LogFlowFunc(("returns %Rrc (error opening file)\n", rc));
1763	return rc;
1764	}
1765
1766	/*
1767	* Check for XAR file.
1768	*/
1769	RTVFSFSSTREAM hXarFss = NIL_RTVFSFSSTREAM;
1770	RTVFSFILE hDmgFileInXar = NIL_RTVFSFILE;
1771	uint32_t u32XarMagic;
1772	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0, &u32XarMagic, sizeof(u32XarMagic));
1773	if ( RT_SUCCESS(rc)
1774	&& u32XarMagic == XAR_HEADER_MAGIC)
1775	{
1776	rc = dmgOpenImageWithinXar(RTFILE_O_OPEN \| RTFILE_O_READ \| RTFILE_O_DENY_WRITE,
1777	pIfIo, pStorage, pszFilename,
1778	&hXarFss, &hDmgFileInXar);
1779	if (RT_FAILURE(rc))
1780	return rc;
1781	}
1782
1783	/*
1784	* Read the DMG footer.
1785	*/
1786	uint64_t cbFile;
1787	if (hDmgFileInXar == NIL_RTVFSFILE)
1788	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
1789	else
1790	rc = RTVfsFileQuerySize(hDmgFileInXar, &cbFile);
1791	if ( RT_SUCCESS(rc)
1792	&& cbFile >= sizeof(DMGUDIF))
1793	{
1794	DMGUDIF Ftr;
1795	uint64_t offFtr = cbFile - sizeof(Ftr);
1796	if (hDmgFileInXar == NIL_RTVFSFILE)
1797	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, offFtr, &Ftr, sizeof(Ftr));
1798	else
1799	rc = RTVfsFileReadAt(hDmgFileInXar, offFtr, &Ftr, sizeof(Ftr), NULL);
1800	if (RT_SUCCESS(rc))
1801	{
1802	/*
1803	* Do we recognize this stuff? Does it look valid?
1804	*/
1805	if ( Ftr.u32Magic == RT_H2BE_U32_C(DMGUDIF_MAGIC)
1806	&& Ftr.u32Version == RT_H2BE_U32_C(DMGUDIF_VER_CURRENT)
1807	&& Ftr.cbFooter == RT_H2BE_U32_C(sizeof(Ftr)))
1808	{
1809	dmgUdifFtrFile2HostEndian(&Ftr);
1810	if (dmgUdifFtrIsValid(&Ftr, offFtr))
1811	{
1812	rc = VINF_SUCCESS;
1813	*penmType = VDTYPE_OPTICAL_DISC;
1814	}
1815	else
1816	{
1817	DMG_PRINTF(("Bad DMG: '%s' offFtr=%RTfoff\n", pszFilename, offFtr));
1818	rc = VERR_VD_DMG_INVALID_HEADER;
1819	}
1820	}
1821	else
1822	rc = VERR_VD_DMG_INVALID_HEADER;
1823	}
1824	else
1825	rc = VERR_VD_DMG_INVALID_HEADER;
1826	}
1827	else
1828	rc = VERR_VD_DMG_INVALID_HEADER;
1829
1830	/* Clean up. */
1831	RTVfsFileRelease(hDmgFileInXar);
1832	RTVfsFsStrmRelease(hXarFss);
1833	vdIfIoIntFileClose(pIfIo, pStorage);
1834
1835	LogFlowFunc(("returns %Rrc\n", rc));
1836	return rc;
1837	}
1838
1839	/** @interface_method_impl{VDIMAGEBACKEND,pfnOpen} */
1840	static DECLCALLBACK(int) dmgOpen(const char *pszFilename, unsigned uOpenFlags,
1841	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1842	VDTYPE enmType, void **ppBackendData)
1843	{
1844	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n", pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
1845
1846	NOREF(enmType); /*< @todo r=klaus make use of the type info. /
1847
1848	/* Check open flags. All valid flags are (in principle) supported. */
1849	AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
1850
1851	/* Check remaining arguments. */
1852	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
1853	AssertReturn(*pszFilename, VERR_INVALID_PARAMETER);
1854
1855	/*
1856	* Reject combinations we don't currently support.
1857	*
1858	* There is no point in being paranoid about the input here as we're just a
1859	* simple backend and can expect the caller to be the only user and already
1860	* have validate what it passes thru to us.
1861	*/
1862	if ( !(uOpenFlags & VD_OPEN_FLAGS_READONLY)
1863	\|\| (uOpenFlags & VD_OPEN_FLAGS_ASYNC_IO))
1864	{
1865	LogFlowFunc(("Unsupported flag(s): %#x\n", uOpenFlags));
1866	return VERR_INVALID_PARAMETER;
1867	}
1868
1869	/*
1870	* Create the basic instance data structure and open the file,
1871	* then hand it over to a worker function that does all the rest.
1872	*/
1873	int rc = VERR_NO_MEMORY;
1874	PDMGIMAGE pThis = (PDMGIMAGE)RTMemAllocZ(RT_UOFFSETOF(DMGIMAGE, RegionList.aRegions[1]));
1875	if (pThis)
1876	{
1877	pThis->pszFilename = pszFilename;
1878	pThis->pStorage = NULL;
1879	pThis->pVDIfsDisk = pVDIfsDisk;
1880	pThis->pVDIfsImage = pVDIfsImage;
1881
1882	rc = dmgOpenImage(pThis, uOpenFlags);
1883	if (RT_SUCCESS(rc))
1884	*ppBackendData = pThis;
1885	else
1886	RTMemFree(pThis);
1887	}
1888
1889	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1890	return rc;
1891	}
1892
1893	/** @interface_method_impl{VDIMAGEBACKEND,pfnCreate} */
1894	static DECLCALLBACK(int) dmgCreate(const char *pszFilename, uint64_t cbSize,
1895	unsigned uImageFlags, const char *pszComment,
1896	PCVDGEOMETRY pPCHSGeometry, PCVDGEOMETRY pLCHSGeometry,
1897	PCRTUUID pUuid, unsigned uOpenFlags,
1898	unsigned uPercentStart, unsigned uPercentSpan,
1899	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1900	PVDINTERFACE pVDIfsOperation, VDTYPE enmType,
1901	void **ppBackendData)
1902	{
1903	RT_NOREF8(pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags);
1904	RT_NOREF7(uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData);
1905	LogFlowFunc(("pszFilename=\"%s\" cbSize=%llu uImageFlags=%#x pszComment=\"%s\" pPCHSGeometry=%#p pLCHSGeometry=%#p Uuid=%RTuuid uOpenFlags=%#x uPercentStart=%u uPercentSpan=%u pVDIfsDisk=%#p pVDIfsImage=%#p pVDIfsOperation=%#p enmType=%u ppBackendData=%#p",
1906	pszFilename, cbSize, uImageFlags, pszComment, pPCHSGeometry, pLCHSGeometry, pUuid, uOpenFlags, uPercentStart, uPercentSpan, pVDIfsDisk, pVDIfsImage, pVDIfsOperation, enmType, ppBackendData));
1907	int rc = VERR_NOT_SUPPORTED;
1908
1909	LogFlowFunc(("returns %Rrc\n", rc));
1910	return rc;
1911	}
1912
1913	/** @interface_method_impl{VDIMAGEBACKEND,pfnRename} */
1914	static DECLCALLBACK(int) dmgRename(void pBackendData, const char pszFilename)
1915	{
1916	RT_NOREF2(pBackendData, pszFilename);
1917	LogFlowFunc(("pBackendData=%#p pszFilename=%#p\n", pBackendData, pszFilename));
1918	int rc = VERR_NOT_SUPPORTED;
1919
1920	LogFlowFunc(("returns %Rrc\n", rc));
1921	return rc;
1922	}
1923
1924	/** @interface_method_impl{VDIMAGEBACKEND,pfnClose} */
1925	static DECLCALLBACK(int) dmgClose(void *pBackendData, bool fDelete)
1926	{
1927	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1928	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
1929
1930	int rc = dmgFreeImage(pThis, fDelete);
1931	RTMemFree(pThis);
1932
1933	LogFlowFunc(("returns %Rrc\n", rc));
1934	return rc;
1935	}
1936
1937	/** @interface_method_impl{VDIMAGEBACKEND,pfnRead} */
1938	static DECLCALLBACK(int) dmgRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1939	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1940	{
1941	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToRead=%zu pcbActuallyRead=%#p\n",
1942	pBackendData, uOffset, pIoCtx, cbToRead, pcbActuallyRead));
1943	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
1944	PDMGEXTENT pExtent = NULL;
1945	int rc = VINF_SUCCESS;
1946
1947	AssertPtr(pThis);
1948	Assert(uOffset % DMG_SECTOR_SIZE == 0);
1949	Assert(cbToRead % DMG_SECTOR_SIZE == 0);
1950
1951	if ( uOffset + cbToRead > pThis->cbSize
1952	\|\| cbToRead == 0)
1953	{
1954	LogFlowFunc(("returns VERR_INVALID_PARAMETER\n"));
1955	return VERR_INVALID_PARAMETER;
1956	}
1957
1958	pExtent = dmgExtentGetFromOffset(pThis, DMG_BYTE2BLOCK(uOffset));
1959
1960	if (pExtent)
1961	{
1962	uint64_t uExtentRel = DMG_BYTE2BLOCK(uOffset) - pExtent->uSectorExtent;
1963
1964	/* Remain in this extent. */
1965	cbToRead = RT_MIN(cbToRead, DMG_BLOCK2BYTE(pExtent->cSectorsExtent - uExtentRel));
1966
1967	switch (pExtent->enmType)
1968	{
1969	case DMGEXTENTTYPE_RAW:
1970	{
1971	rc = dmgWrapFileReadUser(pThis, pExtent->offFileStart + DMG_BLOCK2BYTE(uExtentRel), pIoCtx, cbToRead);
1972	break;
1973	}
1974	case DMGEXTENTTYPE_ZERO:
1975	{
1976	vdIfIoIntIoCtxSet(pThis->pIfIoXxx, pIoCtx, 0, cbToRead);
1977	break;
1978	}
1979	case DMGEXTENTTYPE_COMP_ZLIB:
1980	{
1981	if (pThis->pExtentDecomp != pExtent)
1982	{
1983	if (DMG_BLOCK2BYTE(pExtent->cSectorsExtent) > pThis->cbDecompExtent)
1984	{
1985	if (RT_LIKELY(pThis->pvDecompExtent))
1986	RTMemFree(pThis->pvDecompExtent);
1987
1988	pThis->pvDecompExtent = RTMemAllocZ(DMG_BLOCK2BYTE(pExtent->cSectorsExtent));
1989	if (!pThis->pvDecompExtent)
1990	rc = VERR_NO_MEMORY;
1991	else
1992	pThis->cbDecompExtent = DMG_BLOCK2BYTE(pExtent->cSectorsExtent);
1993	}
1994
1995	if (RT_SUCCESS(rc))
1996	{
1997	rc = dmgFileInflateSync(pThis, pExtent->offFileStart, pExtent->cbFile,
1998	pThis->pvDecompExtent,
1999	RT_MIN(pThis->cbDecompExtent, DMG_BLOCK2BYTE(pExtent->cSectorsExtent)));
2000	if (RT_SUCCESS(rc))
2001	pThis->pExtentDecomp = pExtent;
2002	}
2003	}
2004
2005	if (RT_SUCCESS(rc))
2006	vdIfIoIntIoCtxCopyTo(pThis->pIfIoXxx, pIoCtx,
2007	(uint8_t *)pThis->pvDecompExtent + DMG_BLOCK2BYTE(uExtentRel),
2008	cbToRead);
2009	break;
2010	}
2011	default:
2012	AssertMsgFailed(("Invalid extent type\n"));
2013	}
2014
2015	if (RT_SUCCESS(rc))
2016	*pcbActuallyRead = cbToRead;
2017	}
2018	else
2019	rc = VERR_INVALID_PARAMETER;
2020
2021	LogFlowFunc(("returns %Rrc\n", rc));
2022	return rc;
2023	}
2024
2025	/** @interface_method_impl{VDIMAGEBACKEND,pfnWrite} */
2026	static DECLCALLBACK(int) dmgWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
2027	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
2028	size_t *pcbPostRead, unsigned fWrite)
2029	{
2030	RT_NOREF7(uOffset, cbToWrite, pIoCtx, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
2031	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
2032	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
2033	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2034	int rc = VERR_NOT_IMPLEMENTED;
2035
2036	AssertPtr(pThis);
2037	Assert(uOffset % 512 == 0);
2038	Assert(cbToWrite % 512 == 0);
2039
2040	if (!(pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY))
2041	AssertMsgFailed(("Not implemented\n"));
2042	else
2043	rc = VERR_VD_IMAGE_READ_ONLY;
2044
2045	LogFlowFunc(("returns %Rrc\n", rc));
2046	return rc;
2047	}
2048
2049	/** @interface_method_impl{VDIMAGEBACKEND,pfnFlush} */
2050	static DECLCALLBACK(int) dmgFlush(void *pBackendData, PVDIOCTX pIoCtx)
2051	{
2052	RT_NOREF1(pIoCtx);
2053	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2054	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2055	int rc;
2056
2057	AssertPtr(pThis);
2058
2059	rc = dmgFlushImage(pThis);
2060
2061	LogFlowFunc(("returns %Rrc\n", rc));
2062	return rc;
2063	}
2064
2065	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetVersion} */
2066	static DECLCALLBACK(unsigned) dmgGetVersion(void *pBackendData)
2067	{
2068	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2069	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2070
2071	AssertPtrReturn(pThis, 0);
2072
2073	return 1;
2074	}
2075
2076	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetFileSize} */
2077	static DECLCALLBACK(uint64_t) dmgGetFileSize(void *pBackendData)
2078	{
2079	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2080	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2081
2082	AssertPtrReturn(pThis, 0);
2083
2084	uint64_t cbFile = 0;
2085	if (pThis->pStorage \|\| pThis->hDmgFileInXar != NIL_RTVFSFILE)
2086	{
2087	int rc = dmgWrapFileGetSize(pThis, &cbFile);
2088	if (RT_FAILURE(rc))
2089	cbFile = 0; /* Make sure it is 0 */
2090	}
2091
2092	LogFlowFunc(("returns %lld\n", cbFile));
2093	return cbFile;
2094	}
2095
2096	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetPCHSGeometry} */
2097	static DECLCALLBACK(int) dmgGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
2098	{
2099	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
2100	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2101	int rc = VINF_SUCCESS;
2102
2103	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
2104
2105	if (pThis->PCHSGeometry.cCylinders)
2106	*pPCHSGeometry = pThis->PCHSGeometry;
2107	else
2108	rc = VERR_VD_GEOMETRY_NOT_SET;
2109
2110	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
2111	return rc;
2112	}
2113
2114	/** @interface_method_impl{VDIMAGEBACKEND,pfnSetPCHSGeometry} */
2115	static DECLCALLBACK(int) dmgSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
2116	{
2117	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
2118	pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
2119	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2120	int rc = VINF_SUCCESS;
2121
2122	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
2123
2124	if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2125	rc = VERR_VD_IMAGE_READ_ONLY;
2126	else
2127	pThis->PCHSGeometry = *pPCHSGeometry;
2128
2129	LogFlowFunc(("returns %Rrc\n", rc));
2130	return rc;
2131	}
2132
2133	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetLCHSGeometry} */
2134	static DECLCALLBACK(int) dmgGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
2135	{
2136	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
2137	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2138	int rc = VINF_SUCCESS;
2139
2140	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
2141
2142	if (pThis->LCHSGeometry.cCylinders)
2143	*pLCHSGeometry = pThis->LCHSGeometry;
2144	else
2145	rc = VERR_VD_GEOMETRY_NOT_SET;
2146
2147	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
2148	return rc;
2149	}
2150
2151	/** @interface_method_impl{VDIMAGEBACKEND,pfnSetLCHSGeometry} */
2152	static DECLCALLBACK(int) dmgSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
2153	{
2154	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
2155	pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
2156	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2157	int rc = VINF_SUCCESS;
2158
2159	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
2160
2161	if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
2162	rc = VERR_VD_IMAGE_READ_ONLY;
2163	else
2164	pThis->LCHSGeometry = *pLCHSGeometry;
2165
2166	LogFlowFunc(("returns %Rrc\n", rc));
2167	return rc;
2168	}
2169
2170	/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
2171	static DECLCALLBACK(int) dmgQueryRegions(void pBackendData, PCVDREGIONLIST ppRegionList)
2172	{
2173	LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
2174	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2175
2176	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
2177
2178	*ppRegionList = &pThis->RegionList;
2179	LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
2180	return VINF_SUCCESS;
2181	}
2182
2183	/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
2184	static DECLCALLBACK(void) dmgRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
2185	{
2186	RT_NOREF1(pRegionList);
2187	LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
2188	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2189	AssertPtr(pThis); RT_NOREF(pThis);
2190
2191	/* Nothing to do here. */
2192	}
2193
2194	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetImageFlags} */
2195	static DECLCALLBACK(unsigned) dmgGetImageFlags(void *pBackendData)
2196	{
2197	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2198	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2199	AssertPtrReturn(pThis, 0);
2200
2201	LogFlowFunc(("returns %#x\n", pThis->uImageFlags));
2202	return pThis->uImageFlags;
2203	}
2204
2205	/** @interface_method_impl{VDIMAGEBACKEND,pfnGetOpenFlags} */
2206	static DECLCALLBACK(unsigned) dmgGetOpenFlags(void *pBackendData)
2207	{
2208	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
2209	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2210
2211	AssertPtrReturn(pThis, 0);
2212
2213	LogFlowFunc(("returns %#x\n", pThis->uOpenFlags));
2214	return pThis->uOpenFlags;
2215	}
2216
2217	/** @interface_method_impl{VDIMAGEBACKEND,pfnSetOpenFlags} */
2218	static DECLCALLBACK(int) dmgSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
2219	{
2220	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
2221	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2222	int rc = VINF_SUCCESS;
2223
2224	/* Image must be opened and the new flags must be valid. */
2225	if (!pThis \|\| (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
2226	\| VD_OPEN_FLAGS_SHAREABLE \| VD_OPEN_FLAGS_SEQUENTIAL
2227	\| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
2228	rc = VERR_INVALID_PARAMETER;
2229	else
2230	{
2231	/* Implement this operation via reopening the image. */
2232	rc = dmgFreeImage(pThis, false);
2233	if (RT_SUCCESS(rc))
2234	rc = dmgOpenImage(pThis, uOpenFlags);
2235	}
2236
2237	LogFlowFunc(("returns %Rrc\n", rc));
2238	return rc;
2239	}
2240
2241	/** @copydoc VDIMAGEBACKEND::pfnGetComment */
2242	VD_BACKEND_CALLBACK_GET_COMMENT_DEF_NOT_SUPPORTED(dmgGetComment);
2243
2244	/** @copydoc VDIMAGEBACKEND::pfnSetComment */
2245	VD_BACKEND_CALLBACK_SET_COMMENT_DEF_NOT_SUPPORTED(dmgSetComment, PDMGIMAGE);
2246
2247	/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
2248	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(dmgGetUuid);
2249
2250	/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
2251	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(dmgSetUuid, PDMGIMAGE);
2252
2253	/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
2254	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(dmgGetModificationUuid);
2255
2256	/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
2257	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(dmgSetModificationUuid, PDMGIMAGE);
2258
2259	/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
2260	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(dmgGetParentUuid);
2261
2262	/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
2263	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(dmgSetParentUuid, PDMGIMAGE);
2264
2265	/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
2266	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(dmgGetParentModificationUuid);
2267
2268	/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
2269	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(dmgSetParentModificationUuid, PDMGIMAGE);
2270
2271	/** @interface_method_impl{VDIMAGEBACKEND,pfnDump} */
2272	static DECLCALLBACK(void) dmgDump(void *pBackendData)
2273	{
2274	PDMGIMAGE pThis = (PDMGIMAGE)pBackendData;
2275
2276	AssertPtrReturnVoid(pThis);
2277	vdIfErrorMessage(pThis->pIfError, "Header: Geometry PCHS=%u/%u/%u LCHS=%u/%u/%u cSectors=%llu\n",
2278	pThis->PCHSGeometry.cCylinders, pThis->PCHSGeometry.cHeads, pThis->PCHSGeometry.cSectors,
2279	pThis->LCHSGeometry.cCylinders, pThis->LCHSGeometry.cHeads, pThis->LCHSGeometry.cSectors,
2280	pThis->cbSize / DMG_SECTOR_SIZE);
2281	}
2282
2283
2284	const VDIMAGEBACKEND g_DmgBackend =
2285	{
2286	/* u32Version */
2287	VD_IMGBACKEND_VERSION,
2288	/* pszBackendName */
2289	"DMG",
2290	/* uBackendCaps */
2291	VD_CAP_FILE \| VD_CAP_VFS,
2292	/* paFileExtensions */
2293	s_aDmgFileExtensions,
2294	/* paConfigInfo */
2295	NULL,
2296	/* pfnProbe */
2297	dmgProbe,
2298	/* pfnOpen */
2299	dmgOpen,
2300	/* pfnCreate */
2301	dmgCreate,
2302	/* pfnRename */
2303	dmgRename,
2304	/* pfnClose */
2305	dmgClose,
2306	/* pfnRead */
2307	dmgRead,
2308	/* pfnWrite */
2309	dmgWrite,
2310	/* pfnFlush */
2311	dmgFlush,
2312	/* pfnDiscard */
2313	NULL,
2314	/* pfnGetVersion */
2315	dmgGetVersion,
2316	/* pfnGetFileSize */
2317	dmgGetFileSize,
2318	/* pfnGetPCHSGeometry */
2319	dmgGetPCHSGeometry,
2320	/* pfnSetPCHSGeometry */
2321	dmgSetPCHSGeometry,
2322	/* pfnGetLCHSGeometry */
2323	dmgGetLCHSGeometry,
2324	/* pfnSetLCHSGeometry */
2325	dmgSetLCHSGeometry,
2326	/* pfnQueryRegions */
2327	dmgQueryRegions,
2328	/* pfnRegionListRelease */
2329	dmgRegionListRelease,
2330	/* pfnGetImageFlags */
2331	dmgGetImageFlags,
2332	/* pfnGetOpenFlags */
2333	dmgGetOpenFlags,
2334	/* pfnSetOpenFlags */
2335	dmgSetOpenFlags,
2336	/* pfnGetComment */
2337	dmgGetComment,
2338	/* pfnSetComment */
2339	dmgSetComment,
2340	/* pfnGetUuid */
2341	dmgGetUuid,
2342	/* pfnSetUuid */
2343	dmgSetUuid,
2344	/* pfnGetModificationUuid */
2345	dmgGetModificationUuid,
2346	/* pfnSetModificationUuid */
2347	dmgSetModificationUuid,
2348	/* pfnGetParentUuid */
2349	dmgGetParentUuid,
2350	/* pfnSetParentUuid */
2351	dmgSetParentUuid,
2352	/* pfnGetParentModificationUuid */
2353	dmgGetParentModificationUuid,
2354	/* pfnSetParentModificationUuid */
2355	dmgSetParentModificationUuid,
2356	/* pfnDump */
2357	dmgDump,
2358	/* pfnGetTimestamp */
2359	NULL,
2360	/* pfnGetParentTimestamp */
2361	NULL,
2362	/* pfnSetParentTimestamp */
2363	NULL,
2364	/* pfnGetParentFilename */
2365	NULL,
2366	/* pfnSetParentFilename */
2367	NULL,
2368	/* pfnComposeLocation */
2369	genericFileComposeLocation,
2370	/* pfnComposeName */
2371	genericFileComposeName,
2372	/* pfnCompact */
2373	NULL,
2374	/* pfnResize */
2375	NULL,
2376	/* pfnRepair */
2377	NULL,
2378	/* pfnTraverseMetadata */
2379	NULL,
2380	/* u32VersionEnd */
2381	VD_IMGBACKEND_VERSION
2382	};
2383

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

source: vbox/trunk/src/VBox/Storage/DMG.cpp@ 82837

Download in other formats: