DMG.cpp@ 55628

Last change on this file since 55628 was 54430, checked in by vboxsync, 10 years ago
Storage/VD: make use of the image type (hdd/dvd/floppy) for sanity checking when creating disk images
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 81.0 KB

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

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

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

Download in other formats: