VISO.cpp@ 67954

Last change on this file since 67954 was 67761, checked in by vboxsync, 7 years ago
VISO.cpp: Massage the probe returns.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.6 KB

Rev	Line
[67455]	1	/* $Id: VISO.cpp 67761 2017-07-03 15:18:27Z vboxsync $ */
	2	/** @file
	3	* VISO - Virtual ISO disk image, Core Code.
	4	*/
	5
	6	/*
	7	* Copyright (C) 2017 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
	23	#include <VBox/vd-plugin.h>
	24	#include <VBox/err.h>
	25
	26	#include <VBox/log.h>
	27	//#include <VBox/scsiinline.h>
	28	#include <iprt/assert.h>
	29	#include <iprt/ctype.h>
	30	#include <iprt/fsisomaker.h>
	31	#include <iprt/getopt.h>
	32	#include <iprt/mem.h>
	33	#include <iprt/string.h>
[67465]	34	#include <iprt/uuid.h>
[67455]	35
	36	#include "VDBackends.h"
	37	#include "VDBackendsInline.h"
	38
	39
	40	/*********************************************************************************************************************************
	41	* Defined Constants And Macros *
	42	*********************************************************************************************************************************/
	43	/** The maximum file size. */
	44	#if ARCH_BITS >= 64
[67465]	45	# define VISO_MAX_FILE_SIZE _32M
[67455]	46	#else
[67465]	47	# define VISO_MAX_FILE_SIZE _8M
[67455]	48	#endif
	49
	50
	51	/*********************************************************************************************************************************
	52	* Structures and Typedefs *
	53	*********************************************************************************************************************************/
	54
	55	/**
	56	* VBox ISO maker image instance.
	57	*/
	58	typedef struct VISOIMAGE
	59	{
[67465]	60	/** The ISO maker output file handle.
	61	* This is NIL if in VD_OPEN_FLAGS_INFO mode. */
[67455]	62	RTVFSFILE hIsoFile;
	63	/** The image size. */
	64	uint64_t cbImage;
[67465]	65	/** The UUID ofr the image. */
	66	RTUUID Uuid;
	67
[67455]	68	/** Open flags passed by VD layer. */
	69	uint32_t fOpenFlags;
	70	/** Image name (for debug).
	71	* Allocation follows the region list, no need to free. */
	72	const char *pszFilename;
	73
	74	/** I/O interface. */
	75	PVDINTERFACEIOINT pIfIo;
	76	/** Error interface. */
	77	PVDINTERFACEERROR pIfError;
	78
	79	/** Internal region list (variable size). */
	80	VDREGIONLIST RegionList;
	81	} VISOIMAGE;
	82	/** Pointer to an VBox ISO make image instance. */
	83	typedef VISOIMAGE *PVISOIMAGE;
	84
	85
	86	/*********************************************************************************************************************************
	87	* Global Variables *
	88	*********************************************************************************************************************************/
	89	/** NULL-terminated array of supported file extensions. */
	90	static const VDFILEEXTENSION g_aVBoXIsoMakerFileExtensions[] =
	91	{
[67465]	92	//{ "vbox-iso-maker", VDTYPE_OPTICAL_DISC }, - clumsy.
[67455]	93	{ "viso", VDTYPE_OPTICAL_DISC },
	94	{ NULL, VDTYPE_INVALID }
	95	};
	96
	97
	98	/**
[67465]	99	* Parses the UUID that follows the marker argument.
	100	*
	101	* @returns IPRT status code.
	102	* @param pszMarker The marker.
	103	* @param pUuid Where to return the UUID.
[67455]	104	*/
[67465]	105	static int visoParseUuid(char *pszMarker, PRTUUID pUuid)
[67455]	106	{
[67465]	107	/* Skip the marker. */
	108	char ch;
	109	while ( (ch = *pszMarker) != '\0'
	110	&& !RT_C_IS_SPACE(ch)
	111	&& ch != ':'
	112	&& ch != '=')
	113	pszMarker++;
[67455]	114
[67465]	115	/* Skip chars before the value. */
	116	if ( ch == ':'
	117	\|\| ch == '=')
	118	ch = *++pszMarker;
	119	else
	120	while (RT_C_IS_SPACE(ch))
	121	ch = *++pszMarker;
	122	const char * const pszUuid = pszMarker;
[67455]	123
[67465]	124	/* Find the end of the UUID value. */
	125	while ( ch != '\0'
	126	&& !RT_C_IS_SPACE(ch))
	127	ch = *++pszMarker;
[67455]	128
[67465]	129	/* Validate the value (temporarily terminate the value string) */
	130	*pszMarker = '\0';
	131	int rc = RTUuidFromStr(pUuid, pszUuid);
	132	if (RT_SUCCESS(rc))
	133	{
	134	*pszMarker = ch;
	135	return VINF_SUCCESS;
	136	}
[67455]	137
[67465]	138	/* Complain and return VERR_VD_IMAGE_CORRUPTED to indicate we've identified
	139	the right image format, but the producer got something wrong. */
	140	if (pszUuid != pszMarker)
	141	LogRel(("visoParseUuid: Malformed UUID '%s': %Rrc\n", pszUuid, rc));
	142	else
	143	LogRel(("visoParseUuid: Empty/missing UUID!\n"));
	144	*pszMarker = ch;
	145
	146	return VERR_VD_IMAGE_CORRUPTED;
	147	}
	148
	149
	150	static int visoProbeWorker(const char *pszFilename, PVDINTERFACEIOINT pIfIo, PRTUUID pUuid)
	151	{
[67455]	152	PVDIOSTORAGE pStorage = NULL;
	153	int rc = vdIfIoIntFileOpen(pIfIo, pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE, &pStorage);
	154	if (RT_SUCCESS(rc))
	155	{
	156	/*
[67465]	157	* Read the first part of the file.
[67455]	158	*/
	159	uint64_t cbFile = 0;
	160	rc = vdIfIoIntFileGetSize(pIfIo, pStorage, &cbFile);
	161	if (RT_SUCCESS(rc))
	162	{
[67465]	163	char szChunk[_1K];
[67455]	164	size_t cbToRead = (size_t)RT_MIN(sizeof(szChunk) - 1, cbFile);
	165	rc = vdIfIoIntFileReadSync(pIfIo, pStorage, 0 /off/, szChunk, cbToRead);
	166	if (RT_SUCCESS(rc))
	167	{
	168	szChunk[cbToRead] = '\0';
[67465]	169
	170	/*
	171	* Skip leading spaces and check for the eye-catcher.
	172	*/
	173	char *psz = szChunk;
[67455]	174	while (RT_C_IS_SPACE(*psz))
	175	psz++;
[67465]	176	if (strncmp(psz, RT_STR_TUPLE("--iprt-iso-maker-file-marker")) == 0)
[67455]	177	{
[67465]	178	rc = visoParseUuid(psz, pUuid);
	179	if (RT_SUCCESS(rc))
[67455]	180	{
[67465]	181	/*
	182	* Check the file size.
	183	*/
	184	if (cbFile <= VISO_MAX_FILE_SIZE)
	185	rc = VINF_SUCCESS;
	186	else
	187	{
	188	LogRel(("visoProbeWorker: VERR_VD_INVALID_SIZE - cbFile=%#RX64 cbMaxFile=%#RX64\n",
	189	cbFile, (uint64_t)VISO_MAX_FILE_SIZE));
	190	rc = VERR_VD_INVALID_SIZE;
	191	}
[67455]	192	}
[67761]	193	else
	194	rc = VERR_VD_IMAGE_CORRUPTED;
[67455]	195	}
	196	else
	197	rc = VERR_VD_GEN_INVALID_HEADER;
	198	}
	199	}
	200	vdIfIoIntFileClose(pIfIo, pStorage);
	201	}
[67465]	202	LogFlowFunc(("returns %Rrc\n", rc));
[67455]	203	return rc;
	204	}
	205
	206	/**
[67465]	207	* @interface_method_impl{VDIMAGEBACKEND,pfnProbe}
[67455]	208	*/
[67465]	209	static DECLCALLBACK(int) visoProbe(const char pszFilename, PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage, VDTYPE penmType)
[67455]	210	{
	211	/*
	212	* Validate input.
	213	*/
[67465]	214	AssertPtrReturn(penmType, VERR_INVALID_POINTER);
	215	*penmType = VDTYPE_INVALID;
[67455]	216
	217	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
	218	AssertReturn(*pszFilename, VERR_INVALID_POINTER);
	219
	220	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
	221	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
	222
[67465]	223	RT_NOREF(pVDIfsDisk);
[67455]	224
[67465]	225	/*
	226	* Share worker with visoOpen and visoSetFlags.
	227	*/
	228	RTUUID UuidIgn;
	229	int rc = visoProbeWorker(pszFilename, pIfIo, &UuidIgn);
	230	if (RT_SUCCESS(rc))
	231	*penmType = VDTYPE_OPTICAL_DISC;
[67761]	232	else if (rc == VERR_VD_IMAGE_CORRUPTED \|\| rc == VERR_VD_INVALID_SIZE)
	233	*penmType = VDTYPE_OPTICAL_DISC;
	234	else
	235	rc = VERR_VD_GEN_INVALID_HEADER; /* Caller has strict, though undocument, status code expectations. */
[67455]	236
[67465]	237	LogFlowFunc(("returns %Rrc - penmType=%d\n", rc, penmType));
	238	return rc;
	239	}
	240
	241
	242	/**
	243	* Worker for visoOpen and visoSetOpenFlags that creates a VFS file for the ISO.
	244	*
	245	* This also updates cbImage and the Uuid members.
	246	*
[67599]	247	* @returns VBox status code.
	248	* @param pThis The VISO image instance.
[67465]	249	*/
	250	static int visoOpenWorker(PVISOIMAGE pThis)
	251	{
[67455]	252	/*
	253	* Open the file and read it into memory.
	254	*/
	255	PVDIOSTORAGE pStorage = NULL;
[67465]	256	int rc = vdIfIoIntFileOpen(pThis->pIfIo, pThis->pszFilename, RTFILE_O_READ \| RTFILE_O_OPEN \| RTFILE_O_DENY_NONE, &pStorage);
	257	if (RT_FAILURE(rc))
	258	return rc;
	259
	260	/*
	261	* Read the file into memory, prefixing it with a dummy command name.
	262	*/
	263	uint64_t cbFile = 0;
	264	rc = vdIfIoIntFileGetSize(pThis->pIfIo, pStorage, &cbFile);
[67455]	265	if (RT_SUCCESS(rc))
	266	{
[67465]	267	if (cbFile <= VISO_MAX_FILE_SIZE)
[67455]	268	{
[67465]	269	static char const s_szCmdPrefix[] = "VBox-Iso-Maker ";
	270
	271	char pszContent = (char )RTMemTmpAlloc(sizeof(s_szCmdPrefix) + cbFile);
	272	if (pszContent)
[67455]	273	{
[67465]	274	char *pszReadDst = &pszContent[sizeof(s_szCmdPrefix) - 1];
	275	rc = vdIfIoIntFileReadSync(pThis->pIfIo, pStorage, 0 /off/, pszReadDst, (size_t)cbFile);
	276	if (RT_SUCCESS(rc))
	277	{
	278	/*
	279	* Check the file marker and get the UUID that follows it.
	280	* Ignore leading blanks.
	281	*/
	282	pszReadDst[(size_t)cbFile] = '\0';
	283	memcpy(pszContent, s_szCmdPrefix, sizeof(s_szCmdPrefix) - 1);
[67455]	284
[67465]	285	while (RT_C_IS_SPACE(*pszReadDst))
	286	pszReadDst++;
	287	if (strncmp(pszReadDst, RT_STR_TUPLE("--iprt-iso-maker-file-marker")) == 0)
[67455]	288	{
[67465]	289	rc = visoParseUuid(pszReadDst, &pThis->Uuid);
	290	if (RT_SUCCESS(rc))
[67455]	291	{
	292	/*
[67599]	293	* Make sure it's valid UTF-8 before letting
[67455]	294	*/
[67599]	295	rc = RTStrValidateEncodingEx(pszContent, sizeof(s_szCmdPrefix) + cbFile,
	296	RTSTR_VALIDATE_ENCODING_EXACT_LENGTH
	297	\| RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED);
[67455]	298	if (RT_SUCCESS(rc))
	299	{
	300	/*
[67599]	301	* Convert it into an argument vector.
	302	* Free the content afterwards to reduce memory pressure.
[67455]	303	*/
[67599]	304	uint32_t fGetOpt = strncmp(pszReadDst, RT_STR_TUPLE("--iprt-iso-maker-file-marker-ms")) != 0
	305	? RTGETOPTARGV_CNV_QUOTE_BOURNE_SH : RTGETOPTARGV_CNV_QUOTE_MS_CRT;
	306	fGetOpt \|= RTGETOPTARGV_CNV_MODIFY_INPUT;
	307	char **papszArgs;
	308	int cArgs;
	309	rc = RTGetOptArgvFromString(&papszArgs, &cArgs, pszContent, fGetOpt, NULL);
[67455]	310
	311	if (RT_SUCCESS(rc))
	312	{
[67599]	313	/*
	314	* Try instantiate the ISO image maker.
	315	* Free the argument vector afterward to reduce memory pressure.
	316	*/
	317	RTVFSFILE hVfsFile;
	318	RTERRINFOSTATIC ErrInfo;
	319	rc = RTFsIsoMakerCmdEx(cArgs, papszArgs, &hVfsFile, RTErrInfoInitStatic(&ErrInfo));
	320
	321	RTGetOptArgvFreeEx(papszArgs, fGetOpt);
	322	papszArgs = NULL;
	323
[67455]	324	if (RT_SUCCESS(rc))
	325	{
[67599]	326	uint64_t cbImage;
	327	rc = RTVfsFileGetSize(hVfsFile, &cbImage);
	328	if (RT_SUCCESS(rc))
	329	{
	330	/*
	331	* Update the state.
	332	*/
	333	pThis->cbImage = cbImage;
	334	pThis->RegionList.aRegions[0].cRegionBlocksOrBytes = cbImage;
[67455]	335
[67599]	336	pThis->hIsoFile = hVfsFile;
	337	hVfsFile = NIL_RTVFSFILE;
[67455]	338
[67599]	339	rc = VINF_SUCCESS;
[67603]	340	LogRel(("VISO: %'RU64 bytes (%#RX64) - %s\n", cbImage, cbImage, pThis->pszFilename));
[67599]	341	}
	342
	343	RTVfsFileRelease(hVfsFile);
[67455]	344	}
[67599]	345	else if (RTErrInfoIsSet(&ErrInfo.Core))
	346	{
[67465]	347	LogRel(("visoOpenWorker: RTFsIsoMakerCmdEx failed: %Rrc - %s\n", rc, ErrInfo.Core.pszMsg));
[67599]	348	vdIfError(pThis->pIfError, rc, RT_SRC_POS, "VISO: %s", ErrInfo.Core.pszMsg);
	349	}
[67465]	350	else
[67599]	351	{
[67465]	352	LogRel(("visoOpenWorker: RTFsIsoMakerCmdEx failed: %Rrc\n", rc));
[67599]	353	vdIfError(pThis->pIfError, rc, RT_SRC_POS, "VISO: RTFsIsoMakerCmdEx failed: %Rrc", rc);
	354	}
[67455]	355	}
	356	}
[67599]	357	else
	358	vdIfError(pThis->pIfError, rc, RT_SRC_POS, "VISO: Invalid file encoding");
[67455]	359	}
	360	}
[67465]	361	else
	362	rc = VERR_VD_GEN_INVALID_HEADER;
	363	}
[67455]	364
[67465]	365	RTMemTmpFree(pszContent);
[67455]	366	}
	367	else
[67465]	368	rc = VERR_NO_TMP_MEMORY;
[67455]	369	}
[67465]	370	else
	371	{
	372	LogRel(("visoOpen: VERR_VD_INVALID_SIZE - cbFile=%#RX64 cbMaxFile=%#RX64\n",
	373	cbFile, (uint64_t)VISO_MAX_FILE_SIZE));
	374	rc = VERR_VD_INVALID_SIZE;
	375	}
[67455]	376	}
[67465]	377
	378	vdIfIoIntFileClose(pThis->pIfIo, pStorage);
[67455]	379	return rc;
	380	}
	381
[67465]	382
[67455]	383	/**
[67465]	384	* @interface_method_impl{VDIMAGEBACKEND,pfnOpen}
	385	*/
	386	static DECLCALLBACK(int) visoOpen(const char *pszFilename, unsigned uOpenFlags, PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
	387	VDTYPE enmType, void **ppBackendData)
	388	{
	389	uint32_t const fOpenFlags = uOpenFlags;
	390	LogFlowFunc(("pszFilename='%s' fOpenFlags=%#x pVDIfsDisk=%p pVDIfsImage=%p enmType=%u ppBackendData=%p\n",
	391	pszFilename, fOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
	392
	393	/*
	394	* Validate input.
	395	*/
	396	AssertPtrReturn(ppBackendData, VERR_INVALID_POINTER);
	397	*ppBackendData = NULL;
	398
	399	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
	400	AssertReturn(*pszFilename, VERR_INVALID_POINTER);
	401
	402	AssertReturn(!(fOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_FLAGS);
	403
	404	PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
	405	AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
	406
	407	PVDINTERFACEERROR pIfError = VDIfErrorGet(pVDIfsDisk);
	408
	409	AssertReturn(enmType == VDTYPE_OPTICAL_DISC, VERR_NOT_SUPPORTED);
	410
	411	/*
	412	* Allocate and initialize the backend image instance data.
	413	*/
	414	int rc;
	415	size_t cbFilename = strlen(pszFilename) + 1;
	416	PVISOIMAGE pThis = (PVISOIMAGE)RTMemAllocZ(RT_UOFFSETOF(VISOIMAGE, RegionList.aRegions[1]) + cbFilename);
	417	if (pThis)
	418	{
	419	pThis->hIsoFile = NIL_RTVFSFILE;
	420	pThis->cbImage = 0;
	421	pThis->fOpenFlags = fOpenFlags;
	422	pThis->pszFilename = (char *)memcpy(&pThis->RegionList.aRegions[1], pszFilename, cbFilename);
	423	pThis->pIfIo = pIfIo;
	424	pThis->pIfError = pIfError;
	425
	426	pThis->RegionList.fFlags = 0;
	427	pThis->RegionList.cRegions = 1;
	428	pThis->RegionList.aRegions[0].offRegion = 0;
	429	pThis->RegionList.aRegions[0].cRegionBlocksOrBytes = 0;
	430	pThis->RegionList.aRegions[0].cbBlock = 2048;
	431	pThis->RegionList.aRegions[0].enmDataForm = VDREGIONDATAFORM_RAW;
	432	pThis->RegionList.aRegions[0].enmMetadataForm = VDREGIONMETADATAFORM_NONE;
	433	pThis->RegionList.aRegions[0].cbData = 2048;
	434	pThis->RegionList.aRegions[0].cbMetadata = 0;
	435
	436	/*
	437	* Only go all the way if this isn't an info query. Re-mastering an ISO
	438	* can potentially be a lot of work and we don't want to go thru with it
	439	* just because the GUI wants to display the image size.
	440	*/
	441	if (!(fOpenFlags & VD_OPEN_FLAGS_INFO))
	442	rc = visoOpenWorker(pThis);
	443	else
	444	rc = visoProbeWorker(pThis->pszFilename, pThis->pIfIo, &pThis->Uuid);
	445	if (RT_SUCCESS(rc))
	446	{
	447	*ppBackendData = pThis;
	448	LogFlowFunc(("returns VINF_SUCCESS (UUID=%RTuuid, pszFilename=%s)\n", &pThis->Uuid, pThis->pszFilename));
	449	return VINF_SUCCESS;
	450	}
	451
	452	RTMemFree(pThis);
	453	}
	454	else
	455	rc = VERR_NO_MEMORY;
	456	LogFlowFunc(("returns %Rrc\n", rc));
	457	return rc;
	458	}
	459
	460
	461	/**
[67455]	462	* @interface_method_impl{VDIMAGEBACKEND,pfnClose}
	463	*/
	464	static DECLCALLBACK(int) visoClose(void *pBackendData, bool fDelete)
	465	{
	466	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	467	LogFlowFunc(("pThis=%p fDelete=%RTbool\n", pThis, fDelete));
	468
	469	if (pThis)
	470	{
	471	if (fDelete)
	472	vdIfIoIntFileDelete(pThis->pIfIo, pThis->pszFilename);
	473
[67465]	474	if (pThis->hIsoFile != NIL_RTVFSFILE)
	475	{
	476	RTVfsFileRelease(pThis->hIsoFile);
	477	pThis->hIsoFile = NIL_RTVFSFILE;
	478	}
[67455]	479
	480	RTMemFree(pThis);
	481	}
	482
[67465]	483	LogFlowFunc(("returns VINF_SUCCESS\n"));
[67455]	484	return VINF_SUCCESS;
	485	}
	486
	487	/**
	488	* @interface_method_impl{VDIMAGEBACKEND,pfnRead}
	489	*/
	490	static DECLCALLBACK(int) visoRead(void pBackendData, uint64_t uOffset, size_t cbToRead, PVDIOCTX pIoCtx, size_t pcbActuallyRead)
	491	{
	492	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	493	uint64_t off = uOffset;
	494	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	495	AssertReturn(pThis->hIsoFile != NIL_RTVFSFILE, VERR_VD_NOT_OPENED);
	496	LogFlowFunc(("pThis=%p off=%#RX64 cbToRead=%#zx pIoCtx=%p pcbActuallyRead=%p\n", pThis, off, cbToRead, pIoCtx, pcbActuallyRead));
	497
	498	/*
	499	* Check request.
	500	*/
	501	AssertReturn( off < pThis->cbImage
	502	\|\| (off == pThis->cbImage && cbToRead == 0), VERR_EOF);
	503
	504	uint64_t cbLeftInImage = pThis->cbImage - off;
	505	if (cbToRead >= cbLeftInImage)
	506	cbToRead = cbLeftInImage; /* ASSUMES the caller can deal with this, given the pcbActuallyRead parameter... */
	507
	508	/*
	509	* Work the I/O context using vdIfIoIntIoCtxSegArrayCreate.
	510	*/
	511	int rc = VINF_SUCCESS;
	512	size_t cbActuallyRead = 0;
	513	while (cbToRead > 0)
	514	{
	515	RTSGSEG Seg;
	516	unsigned cSegs = 1;
	517	size_t cbThisRead = vdIfIoIntIoCtxSegArrayCreate(pThis->pIfIo, pIoCtx, &Seg, &cSegs, cbToRead);
	518	AssertBreakStmt(cbThisRead != 0, rc = VERR_INTERNAL_ERROR_2);
	519	Assert(cbThisRead == Seg.cbSeg);
	520
	521	rc = RTVfsFileReadAt(pThis->hIsoFile, off, Seg.pvSeg, cbThisRead, NULL);
	522	AssertRCBreak(rc);
	523
	524	/* advance. */
	525	cbActuallyRead += cbThisRead;
	526	off += cbThisRead;
	527	cbToRead -= cbThisRead;
	528	}
	529
	530	*pcbActuallyRead = cbActuallyRead;
	531	return rc;
	532	}
	533
	534	/**
	535	* @interface_method_impl{VDIMAGEBACKEND,pfnWrite}
	536	*/
	537	static DECLCALLBACK(int) visoWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
	538	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
	539	size_t *pcbPostRead, unsigned fWrite)
	540	{
	541	RT_NOREF(uOffset, cbToWrite, pIoCtx, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
	542	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	543	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	544	AssertReturn(pThis->hIsoFile != NIL_RTVFSFILE, VERR_VD_NOT_OPENED);
	545	LogFlowFunc(("pThis=%p off=%#RX64 pIoCtx=%p cbToWrite=%#zx pcbWriteProcess=%p pcbPreRead=%p pcbPostRead=%p -> VERR_VD_IMAGE_READ_ONLY\n",
	546	pThis, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
	547	return VERR_VD_IMAGE_READ_ONLY;
	548	}
	549
	550	/**
	551	* @interface_method_impl{VDIMAGEBACKEND,pfnFlush}
	552	*/
	553	static DECLCALLBACK(int) visoFlush(void *pBackendData, PVDIOCTX pIoCtx)
	554	{
	555	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	556	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	557	AssertReturn(pThis->hIsoFile != NIL_RTVFSFILE, VERR_VD_NOT_OPENED);
	558	RT_NOREF(pIoCtx);
	559	return VINF_SUCCESS;
	560	}
	561
	562	/**
	563	* @interface_method_impl{VDIMAGEBACKEND,pfnGetVersion}
	564	*/
	565	static DECLCALLBACK(unsigned) visoGetVersion(void *pBackendData)
	566	{
	567	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	568	AssertPtrReturn(pThis, 0);
	569	LogFlowFunc(("pThis=%#p -> 1\n", pThis));
	570	return 1;
	571	}
	572
	573	/**
	574	* @interface_method_impl{VDIMAGEBACKEND,pfnGetFileSize}
	575	*/
	576	static DECLCALLBACK(uint64_t) visoGetFileSize(void *pBackendData)
	577	{
	578	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	579	AssertPtrReturn(pThis, 0);
[67465]	580	LogFlowFunc(("pThis=%p -> %RX64 (%s)\n", pThis, pThis->cbImage, pThis->hIsoFile == NIL_RTVFSFILE ? "fake!" : "real"));
[67455]	581	return pThis->cbImage;
	582	}
	583
	584	/**
	585	* @interface_method_impl{VDIMAGEBACKEND,pfnGetPCHSGeometry}
	586	*/
	587	static DECLCALLBACK(int) visoGetPCHSGeometry(void *pBackendData, PVDGEOMETRY pPCHSGeometry)
	588	{
	589	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	590	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	591	LogFlowFunc(("pThis=%p pPCHSGeometry=%p -> VERR_NOT_SUPPORTED\n", pThis, pPCHSGeometry));
	592	RT_NOREF(pPCHSGeometry);
	593	return VERR_NOT_SUPPORTED;
	594	}
	595
	596	/**
	597	* @interface_method_impl{VDIMAGEBACKEND,pfnSetPCHSGeometry}
	598	*/
	599	static DECLCALLBACK(int) visoSetPCHSGeometry(void *pBackendData, PCVDGEOMETRY pPCHSGeometry)
	600	{
	601	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	602	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	603	LogFlowFunc(("pThis=%p pPCHSGeometry=%p:{%u/%u/%u} -> VERR_VD_IMAGE_READ_ONLY\n",
	604	pThis, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
	605	RT_NOREF(pPCHSGeometry);
	606	return VERR_VD_IMAGE_READ_ONLY;
	607	}
	608
	609	/**
	610	* @interface_method_impl{VDIMAGEBACKEND,pfnGetLCHSGeometry}
	611	*/
	612	static DECLCALLBACK(int) visoGetLCHSGeometry(void *pBackendData, PVDGEOMETRY pLCHSGeometry)
	613	{
	614	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	615	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	616	LogFlowFunc(("pThis=%p pLCHSGeometry=%p -> VERR_NOT_SUPPORTED\n", pThis, pLCHSGeometry));
	617	RT_NOREF(pLCHSGeometry);
	618	return VERR_NOT_SUPPORTED;
	619	}
	620
	621	/**
	622	* @interface_method_impl{VDIMAGEBACKEND,pfnSetLCHSGeometry}
	623	*/
	624	static DECLCALLBACK(int) visoSetLCHSGeometry(void *pBackendData, PCVDGEOMETRY pLCHSGeometry)
	625	{
	626	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	627	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	628	LogFlowFunc(("pThis=%p pLCHSGeometry=%p:{%u/%u/%u} -> VERR_VD_IMAGE_READ_ONLY\n",
	629	pThis, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
	630	RT_NOREF(pLCHSGeometry);
	631	return VERR_VD_IMAGE_READ_ONLY;
	632	}
	633
	634	/**
	635	* @interface_method_impl{VDIMAGEBACKEND,pfnQueryRegions}
	636	*/
	637	static DECLCALLBACK(int) visoQueryRegions(void pBackendData, PCVDREGIONLIST ppRegionList)
	638	{
	639	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	640	*ppRegionList = NULL;
	641	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
	642
	643	*ppRegionList = &pThis->RegionList;
[67465]	644	LogFlowFunc(("returns VINF_SUCCESS (one region: 0 LB %RX64; pThis=%p)\n", pThis->RegionList.aRegions[0].cbData, pThis));
[67455]	645	return VINF_SUCCESS;
	646	}
	647
	648	/**
	649	* @interface_method_impl{VDIMAGEBACKEND,pfnRegionListRelease}
	650	*/
	651	static DECLCALLBACK(void) visoRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
	652	{
	653	/* Nothing to do here. Just assert the input to avoid unused parameter warnings. */
	654	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	655	LogFlowFunc(("pThis=%p pRegionList=%p\n", pThis, pRegionList));
	656	AssertPtrReturnVoid(pThis);
	657	AssertReturnVoid(pRegionList == &pThis->RegionList \|\| pRegionList == 0);
	658	}
	659
	660	/**
	661	* @interface_method_impl{VDIMAGEBACKEND,pfnGetImageFlags}
	662	*/
	663	static DECLCALLBACK(unsigned) visoGetImageFlags(void *pBackendData)
	664	{
	665	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	666	LogFlowFunc(("pThis=%p -> VD_IMAGE_FLAGS_NONE\n", pThis));
[67465]	667	AssertPtrReturn(pThis, VD_IMAGE_FLAGS_NONE);
[67455]	668	return VD_IMAGE_FLAGS_NONE;
	669	}
	670
	671	/**
	672	* @interface_method_impl{VDIMAGEBACKEND,pfnGetOpenFlags}
	673	*/
	674	static DECLCALLBACK(unsigned) visoGetOpenFlags(void *pBackendData)
	675	{
	676	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
	677	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	678	AssertPtrReturn(pThis, 0);
	679
	680	LogFlowFunc(("returns %#x\n", pThis->fOpenFlags));
	681	return pThis->fOpenFlags;
	682	}
	683
	684	/**
	685	* @interface_method_impl{VDIMAGEBACKEND,pfnSetOpenFlags}
	686	*/
	687	static DECLCALLBACK(int) visoSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
	688	{
	689	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	690	LogFlowFunc(("pThis=%p fOpenFlags=%#x\n", pThis, uOpenFlags));
	691
	692	AssertPtrReturn(pThis, VERR_INVALID_POINTER);
	693	uint32_t const fSupported = VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
	694	\| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE
	695	\| VD_OPEN_FLAGS_SEQUENTIAL \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS;
	696	AssertMsgReturn(!(uOpenFlags & ~fSupported), ("fOpenFlags=%#x\n", uOpenFlags), VERR_INVALID_FLAGS);
	697
	698	/*
[67465]	699	* Only react if we switch from VD_OPEN_FLAGS_INFO to non-VD_OPEN_FLAGS_INFO mode,
	700	* becuase that means we need to open the image.
[67455]	701	*/
[67465]	702	if ( (pThis->fOpenFlags & VD_OPEN_FLAGS_INFO)
	703	&& !(uOpenFlags & VD_OPEN_FLAGS_INFO)
	704	&& pThis->hIsoFile == NIL_RTVFSFILE)
	705	{
	706	int rc = visoOpenWorker(pThis);
	707	if (RT_FAILURE(rc))
	708	{
	709	LogFlowFunc(("returns %Rrc\n", rc));
	710	return rc;
	711	}
	712	}
	713
	714	/*
	715	* Update the flags.
	716	*/
[67455]	717	pThis->fOpenFlags &= ~fSupported;
	718	pThis->fOpenFlags \|= fSupported & uOpenFlags;
	719	pThis->fOpenFlags \|= VD_OPEN_FLAGS_READONLY;
[67465]	720	if (pThis->hIsoFile != NIL_RTVFSFILE)
	721	pThis->fOpenFlags &= ~VD_OPEN_FLAGS_INFO;
[67455]	722
	723	return VINF_SUCCESS;
	724	}
	725
	726	#define uOpenFlags fOpenFlags /* sigh */
	727
	728	/**
	729	* @interface_method_impl{VDIMAGEBACKEND,pfnGetComment}
	730	*/
	731	VD_BACKEND_CALLBACK_GET_COMMENT_DEF_NOT_SUPPORTED(visoGetComment);
	732
	733	/**
	734	* @interface_method_impl{VDIMAGEBACKEND,pfnSetComment}
	735	*/
	736	VD_BACKEND_CALLBACK_SET_COMMENT_DEF_NOT_SUPPORTED(visoSetComment, PVISOIMAGE);
	737
	738	/**
	739	* @interface_method_impl{VDIMAGEBACKEND,pfnGetUuid}
	740	*/
[67465]	741	static DECLCALLBACK(int) visoGetUuid(void *pBackendData, PRTUUID pUuid)
	742	{
	743	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	744	*pUuid = pThis->Uuid;
	745	LogFlowFunc(("returns VIF_SUCCESS (%RTuuid)\n", pUuid));
	746	return VINF_SUCCESS;
	747	}
[67455]	748
	749	/**
	750	* @interface_method_impl{VDIMAGEBACKEND,pfnSetUuid}
	751	*/
	752	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(visoSetUuid, PVISOIMAGE);
	753
	754	/**
	755	* @interface_method_impl{VDIMAGEBACKEND,pfnGetModificationUuid}
	756	*/
	757	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(visoGetModificationUuid);
	758
	759	/**
	760	* @interface_method_impl{VDIMAGEBACKEND,pfnSetModificationUuid}
	761	*/
	762	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(visoSetModificationUuid, PVISOIMAGE);
	763
	764	/**
	765	* @interface_method_impl{VDIMAGEBACKEND,pfnGetParentUuid}
	766	*/
	767	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(visoGetParentUuid);
	768
	769	/**
	770	* @interface_method_impl{VDIMAGEBACKEND,pfnSetParentUuid}
	771	*/
	772	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(visoSetParentUuid, PVISOIMAGE);
	773
	774	/**
	775	* @interface_method_impl{VDIMAGEBACKEND,pfnGetParentModificationUuid}
	776	*/
	777	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(visoGetParentModificationUuid);
	778
	779	/**
	780	* @interface_method_impl{VDIMAGEBACKEND,pfnSetParentModificationUuid}
	781	*/
	782	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(visoSetParentModificationUuid, PVISOIMAGE);
	783
	784	#undef uOpenFlags
	785
	786	/**
	787	* @interface_method_impl{VDIMAGEBACKEND,pfnDump}
	788	*/
	789	static DECLCALLBACK(void) visoDump(void *pBackendData)
	790	{
	791	PVISOIMAGE pThis = (PVISOIMAGE)pBackendData;
	792	AssertPtrReturnVoid(pThis);
	793
	794	vdIfErrorMessage(pThis->pIfError, "Dumping CUE image '%s' fOpenFlags=%x cbImage=%#RX64\n",
	795	pThis->pszFilename, pThis->fOpenFlags, pThis->cbImage);
	796	}
	797
	798
	799
	800	/**
	801	* VBox ISO maker backend.
	802	*/
	803	const VDIMAGEBACKEND g_VBoxIsoMakerBackend =
	804	{
	805	/* u32Version */
	806	VD_IMGBACKEND_VERSION,
	807	/* pszBackendName */
	808	"VBoxIsoMaker",
	809	/* uBackendCaps */
	810	VD_CAP_FILE,
	811	/* paFileExtensions */
	812	g_aVBoXIsoMakerFileExtensions,
	813	/* paConfigInfo */
	814	NULL,
	815	/* pfnProbe */
	816	visoProbe,
	817	/* pfnOpen */
	818	visoOpen,
	819	/* pfnCreate */
	820	NULL,
	821	/* pfnRename */
	822	NULL,
	823	/* pfnClose */
	824	visoClose,
	825	/* pfnRead */
	826	visoRead,
	827	/* pfnWrite */
	828	visoWrite,
	829	/* pfnFlush */
	830	visoFlush,
	831	/* pfnDiscard */
	832	NULL,
	833	/* pfnGetVersion */
	834	visoGetVersion,
	835	/* pfnGetFileSize */
	836	visoGetFileSize,
	837	/* pfnGetPCHSGeometry */
	838	visoGetPCHSGeometry,
	839	/* pfnSetPCHSGeometry */
	840	visoSetPCHSGeometry,
	841	/* pfnGetLCHSGeometry */
	842	visoGetLCHSGeometry,
	843	/* pfnSetLCHSGeometry */
	844	visoSetLCHSGeometry,
	845	/* pfnQueryRegions */
	846	visoQueryRegions,
	847	/* pfnRegionListRelease */
	848	visoRegionListRelease,
	849	/* pfnGetImageFlags */
	850	visoGetImageFlags,
	851	/* pfnGetOpenFlags */
	852	visoGetOpenFlags,
	853	/* pfnSetOpenFlags */
	854	visoSetOpenFlags,
	855	/* pfnGetComment */
	856	visoGetComment,
	857	/* pfnSetComment */
	858	visoSetComment,
	859	/* pfnGetUuid */
	860	visoGetUuid,
	861	/* pfnSetUuid */
	862	visoSetUuid,
	863	/* pfnGetModificationUuid */
	864	visoGetModificationUuid,
	865	/* pfnSetModificationUuid */
	866	visoSetModificationUuid,
	867	/* pfnGetParentUuid */
	868	visoGetParentUuid,
	869	/* pfnSetParentUuid */
	870	visoSetParentUuid,
	871	/* pfnGetParentModificationUuid */
	872	visoGetParentModificationUuid,
	873	/* pfnSetParentModificationUuid */
	874	visoSetParentModificationUuid,
	875	/* pfnDump */
	876	visoDump,
	877	/* pfnGetTimestamp */
	878	NULL,
	879	/* pfnGetParentTimestamp */
	880	NULL,
	881	/* pfnSetParentTimestamp */
	882	NULL,
	883	/* pfnGetParentFilename */
	884	NULL,
	885	/* pfnSetParentFilename */
	886	NULL,
	887	/* pfnComposeLocation */
	888	genericFileComposeLocation,
	889	/* pfnComposeName */
	890	genericFileComposeName,
	891	/* pfnCompact */
	892	NULL,
	893	/* pfnResize */
	894	NULL,
	895	/* pfnRepair */
	896	NULL,
	897	/* pfnTraverseMetadata */
	898	NULL,
	899	/* u32VersionEnd */
	900	VD_IMGBACKEND_VERSION
	901	};
	902

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

source: vbox/trunk/src/VBox/Storage/VISO.cpp@ 67954

Download in other formats: