manifest3.cpp@ 100908

Last change on this file since 100908 was 100908, checked in by vboxsync, 15 months ago
IPRT,Storage,Puel: Changed the pfnRead and pfnWrite VFS methods and the RTVfsIoStrmSgRead, RTVfsIoStrmSgWrite, RTVfsFileSgRead and RTVfsFileSgWrite APIs to advance pSgBuf and respect the incoming position just like RTFileSgRead & RTFileSgWrite.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 21.1 KB

Line
1	/* $Id: manifest3.cpp 100908 2023-08-19 02:57:05Z vboxsync $ */
2	/** @file
3	* IPRT - Manifest, the bits with the most dependencies.
4	*/
5
6	/*
7	* Copyright (C) 2010-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include "internal/iprt.h"
42	#include <iprt/manifest.h>
43
44	#include <iprt/alloca.h>
45	#include <iprt/asm.h>
46	#include <iprt/assert.h>
47	#include <iprt/err.h>
48	#include <iprt/file.h>
49	#include <iprt/md5.h>
50	#include <iprt/mem.h>
51	#include <iprt/sha.h>
52	#include <iprt/string.h>
53	#include <iprt/vfs.h>
54	#include <iprt/vfslowlevel.h>
55	#include <iprt/zero.h>
56
57
58	/*********************************************************************************************************************************
59	* Structures and Typedefs *
60	*********************************************************************************************************************************/
61	/**
62	* Hashes data.
63	*
64	* Used when hashing a file, stream or similar.
65	*/
66	typedef struct RTMANIFESTHASHES
67	{
68	/** The desired attribute types.
69	* Only the hashes indicated by this will be calculated. */
70	uint32_t fAttrs;
71	/** The size. */
72	RTFOFF cbStream;
73
74	/** The MD5 context. */
75	RTMD5CONTEXT Md5Ctx;
76	/** The SHA-1 context. */
77	RTSHA1CONTEXT Sha1Ctx;
78	/** The SHA-256 context. */
79	RTSHA256CONTEXT Sha256Ctx;
80	/** The SHA-512 context. */
81	RTSHA512CONTEXT Sha512Ctx;
82
83	/** The MD5 digest. */
84	uint8_t abMd5Digest[RTMD5_HASH_SIZE];
85	/** The SHA-1 digest. */
86	uint8_t abSha1Digest[RTSHA1_HASH_SIZE];
87	/** The SHA-256 digest. */
88	uint8_t abSha256Digest[RTSHA256_HASH_SIZE];
89	/** The SHA-512 digest. */
90	uint8_t abSha512Digest[RTSHA512_HASH_SIZE];
91	} RTMANIFESTHASHES;
92	/** Pointer to a the hashes for a stream. */
93	typedef RTMANIFESTHASHES *PRTMANIFESTHASHES;
94
95
96	/**
97	* The internal data of a manifest passthru I/O stream.
98	*/
99	typedef struct RTMANIFESTPTIOS
100	{
101	/** The stream we're reading from or writing to. */
102	RTVFSIOSTREAM hVfsIos;
103	/** The hashes. */
104	PRTMANIFESTHASHES pHashes;
105	/** The current hash position. */
106	RTFOFF offCurPos;
107	/** Whether we're reading or writing. */
108	bool fReadOrWrite;
109	/** Whether we've already added the entry to the manifest. */
110	bool fAddedEntry;
111	/** The entry name. */
112	char *pszEntry;
113	/** The manifest to add the entry to. */
114	RTMANIFEST hManifest;
115	} RTMANIFESTPTIOS;
116	/** Pointer to a the internal data of a manifest passthru I/O stream. */
117	typedef RTMANIFESTPTIOS *PRTMANIFESTPTIOS;
118
119
120
121	/**
122	* Creates a hashes structure.
123	*
124	* @returns Pointer to a hashes structure.
125	* @param fAttrs The desired hashes, RTMANIFEST_ATTR_XXX.
126	*/
127	static PRTMANIFESTHASHES rtManifestHashesCreate(uint32_t fAttrs)
128	{
129	PRTMANIFESTHASHES pHashes = (PRTMANIFESTHASHES)RTMemTmpAllocZ(sizeof(*pHashes));
130	if (pHashes)
131	{
132	pHashes->fAttrs = fAttrs;
133	/pHashes->cbStream = 0;/
134	if (fAttrs & RTMANIFEST_ATTR_MD5)
135	RTMd5Init(&pHashes->Md5Ctx);
136	if (fAttrs & RTMANIFEST_ATTR_SHA1)
137	RTSha1Init(&pHashes->Sha1Ctx);
138	if (fAttrs & RTMANIFEST_ATTR_SHA256)
139	RTSha256Init(&pHashes->Sha256Ctx);
140	if (fAttrs & RTMANIFEST_ATTR_SHA512)
141	RTSha512Init(&pHashes->Sha512Ctx);
142	}
143	return pHashes;
144	}
145
146
147	/**
148	* Updates the hashes with a block of data.
149	*
150	* @param pHashes The hashes structure.
151	* @param pvBuf The data block.
152	* @param cbBuf The size of the data block.
153	*/
154	static void rtManifestHashesUpdate(PRTMANIFESTHASHES pHashes, void const *pvBuf, size_t cbBuf)
155	{
156	pHashes->cbStream += cbBuf;
157	if (pHashes->fAttrs & RTMANIFEST_ATTR_MD5)
158	RTMd5Update(&pHashes->Md5Ctx, pvBuf, cbBuf);
159	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA1)
160	RTSha1Update(&pHashes->Sha1Ctx, pvBuf, cbBuf);
161	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA256)
162	RTSha256Update(&pHashes->Sha256Ctx, pvBuf, cbBuf);
163	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA512)
164	RTSha512Update(&pHashes->Sha512Ctx, pvBuf, cbBuf);
165	}
166
167
168	/**
169	* Finalizes all the hashes.
170	*
171	* @param pHashes The hashes structure.
172	*/
173	static void rtManifestHashesFinal(PRTMANIFESTHASHES pHashes)
174	{
175	if (pHashes->fAttrs & RTMANIFEST_ATTR_MD5)
176	RTMd5Final(pHashes->abMd5Digest, &pHashes->Md5Ctx);
177	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA1)
178	RTSha1Final(&pHashes->Sha1Ctx, pHashes->abSha1Digest);
179	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA256)
180	RTSha256Final(&pHashes->Sha256Ctx, pHashes->abSha256Digest);
181	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA512)
182	RTSha512Final(&pHashes->Sha512Ctx, pHashes->abSha512Digest);
183	}
184
185
186	/**
187	* Adds the hashes to a manifest entry.
188	*
189	* @returns IPRT status code.
190	* @param pHashes The hashes structure.
191	* @param hManifest The manifest to add them to.
192	* @param pszEntry The entry name.
193	*/
194	static int rtManifestHashesSetAttrs(PRTMANIFESTHASHES pHashes, RTMANIFEST hManifest, const char *pszEntry)
195	{
196	char szValue[RTSHA512_DIGEST_LEN + 8];
197	int rc = VINF_SUCCESS;
198	int rc2;
199
200	if (pHashes->fAttrs & RTMANIFEST_ATTR_SIZE)
201	{
202	RTStrPrintf(szValue, sizeof(szValue), "%RU64", (uint64_t)pHashes->cbStream);
203	rc2 = RTManifestEntrySetAttr(hManifest, pszEntry, "SIZE", szValue, RTMANIFEST_ATTR_SIZE);
204	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
205	rc = rc2;
206	}
207
208	if (pHashes->fAttrs & RTMANIFEST_ATTR_MD5)
209	{
210	rc2 = RTMd5ToString(pHashes->abMd5Digest, szValue, sizeof(szValue));
211	if (RT_SUCCESS(rc2))
212	rc2 = RTManifestEntrySetAttr(hManifest, pszEntry, "MD5", szValue, RTMANIFEST_ATTR_MD5);
213	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
214	rc = rc2;
215	}
216
217	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA1)
218	{
219	rc2 = RTSha1ToString(pHashes->abSha1Digest, szValue, sizeof(szValue));
220	if (RT_SUCCESS(rc2))
221	rc2 = RTManifestEntrySetAttr(hManifest, pszEntry, "SHA1", szValue, RTMANIFEST_ATTR_SHA1);
222	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
223	rc = rc2;
224	}
225
226	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA256)
227	{
228	rc2 = RTSha256ToString(pHashes->abSha256Digest, szValue, sizeof(szValue));
229	if (RT_SUCCESS(rc2))
230	rc2 = RTManifestEntrySetAttr(hManifest, pszEntry, "SHA256", szValue, RTMANIFEST_ATTR_SHA256);
231	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
232	rc = rc2;
233	}
234
235	if (pHashes->fAttrs & RTMANIFEST_ATTR_SHA512)
236	{
237	rc2 = RTSha512ToString(pHashes->abSha512Digest, szValue, sizeof(szValue));
238	if (RT_SUCCESS(rc2))
239	rc2 = RTManifestEntrySetAttr(hManifest, pszEntry, "SHA512", szValue, RTMANIFEST_ATTR_SHA512);
240	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
241	rc = rc2;
242	}
243	return rc;
244	}
245
246
247	/**
248	* Destroys the hashes.
249	*
250	* @param pHashes The hashes structure. NULL is ignored.
251	*/
252	static void rtManifestHashesDestroy(PRTMANIFESTHASHES pHashes)
253	{
254	RTMemTmpFree(pHashes);
255	}
256
257
258
259	/*
260	*
261	* M a n i f e s t p a s s t h r u I / O s t r e a m
262	* M a n i f e s t p a s s t h r u I / O s t r e a m
263	* M a n i f e s t p a s s t h r u I / O s t r e a m
264	*
265	*/
266
267
268	/**
269	* @interface_method_impl{RTVFSOBJOPS,pfnClose}
270	*/
271	static DECLCALLBACK(int) rtManifestPtIos_Close(void *pvThis)
272	{
273	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
274
275	int rc = VINF_SUCCESS;
276	if (!pThis->fAddedEntry)
277	{
278	rtManifestHashesFinal(pThis->pHashes);
279	rc = rtManifestHashesSetAttrs(pThis->pHashes, pThis->hManifest, pThis->pszEntry);
280	}
281
282	RTVfsIoStrmRelease(pThis->hVfsIos);
283	pThis->hVfsIos = NIL_RTVFSIOSTREAM;
284	rtManifestHashesDestroy(pThis->pHashes);
285	pThis->pHashes = NULL;
286	RTStrFree(pThis->pszEntry);
287	pThis->pszEntry = NULL;
288	RTManifestRelease(pThis->hManifest);
289	pThis->hManifest = NIL_RTMANIFEST;
290
291	return rc;
292	}
293
294
295	/**
296	* @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo}
297	*/
298	static DECLCALLBACK(int) rtManifestPtIos_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr)
299	{
300	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
301	return RTVfsIoStrmQueryInfo(pThis->hVfsIos, pObjInfo, enmAddAttr);
302	}
303
304	/**
305	* Updates the hashes with a scather/gather buffer.
306	*
307	* @param pThis The passthru I/O stream instance data.
308	* @param pSgBuf The scather/gather buffer (clone, can be
309	* updated).
310	* @param cbLeft The number of bytes to take from the buffer.
311	*/
312	static void rtManifestPtIos_UpdateHashes(PRTMANIFESTPTIOS pThis, PRTSGBUF pSgBuf, size_t cbLeft)
313	{
314	while (cbLeft > 0)
315	{
316	Assert(!RTSgBufIsAtEnd(pSgBuf));
317	size_t cbSeg = cbLeft;
318	void const * const pvSeg = RTSgBufGetNextSegment(pSgBuf, &cbSeg);
319	rtManifestHashesUpdate(pThis->pHashes, pvSeg, cbSeg);
320	cbLeft -= cbSeg;
321	}
322	}
323
324	/**
325	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead}
326	*/
327	static DECLCALLBACK(int) rtManifestPtIos_Read(void pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t pcbRead)
328	{
329	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
330	int rc;
331
332	/*
333	* Clone the buffer for the manifest pass.
334	*/
335	RTSGBUF CloneSgBuf;
336	RTSgBufClone(&CloneSgBuf, pSgBuf);
337
338	/*
339	* To make sure we're continuing where we left off, we must have the exact
340	* stream position since a previous read using 'off' may change it.
341	*/
342	RTFOFF offActual = off == -1 ? RTVfsIoStrmTell(pThis->hVfsIos) : off;
343	if (offActual == pThis->offCurPos)
344	{
345	size_t const cbReq = RTSgBufCalcLengthLeft(pSgBuf);
346	rc = RTVfsIoStrmSgRead(pThis->hVfsIos, off, pSgBuf, fBlocking, pcbRead);
347	if (RT_SUCCESS(rc))
348	{
349	rtManifestPtIos_UpdateHashes(pThis, &CloneSgBuf, pcbRead ? *pcbRead : cbReq);
350	pThis->offCurPos += pcbRead ? *pcbRead : cbReq;
351	}
352	Assert(RTVfsIoStrmTell(pThis->hVfsIos) == pThis->offCurPos);
353	}
354	else
355	{
356	/*
357	* If we're skipping over stuff, we need to read the gap and hash it.
358	*/
359	if (pThis->offCurPos < offActual)
360	{
361	size_t cbBuf = _8K;
362	void *pvBuf = alloca(cbBuf);
363	do
364	{
365	RTFOFF cbGap = off - pThis->offCurPos;
366	size_t cbThisRead = cbGap >= (RTFOFF)cbBuf ? cbBuf : (size_t)cbGap;
367	size_t cbActual;
368	rc = RTVfsIoStrmReadAt(pThis->hVfsIos, pThis->offCurPos, pvBuf, cbThisRead, fBlocking, &cbActual);
369	if (RT_FAILURE(rc) \|\| rc == VINF_TRY_AGAIN)
370	return rc;
371
372	rtManifestHashesUpdate(pThis->pHashes, pvBuf, cbActual);
373	pThis->offCurPos += cbActual;
374
375	if (rc == VINF_EOF)
376	{
377	if (pcbRead)
378	*pcbRead = 0;
379	else
380	rc = VERR_EOF;
381	return rc;
382	}
383	} while (pThis->offCurPos < offActual);
384	Assert(RTVfsIoStrmTell(pThis->hVfsIos) == offActual);
385	}
386
387	/*
388	* At this point we've eliminated any gap and can execute the requested read.
389	*/
390	rc = RTVfsIoStrmSgRead(pThis->hVfsIos, off, pSgBuf, fBlocking, pcbRead);
391	if (RT_SUCCESS(rc))
392	{
393	/* See if there is anything to update the hash with. */
394	size_t cbLeft = pcbRead ? *pcbRead : RTSgBufCalcLengthLeft(&CloneSgBuf);
395	while (cbLeft > 0)
396	{
397	Assert(!RTSgBufIsAtEnd(&CloneSgBuf));
398	size_t cbSeg = cbLeft;
399	const uint8_t pbSeg = (uint8_t const )RTSgBufGetNextSegment(&CloneSgBuf, &cbSeg);
400
401	if ( offActual >= pThis->offCurPos
402	&& pThis->offCurPos < offActual + (ssize_t)cbSeg)
403	{
404	size_t offSeg = (size_t)(offActual - pThis->offCurPos);
405	rtManifestHashesUpdate(pThis->pHashes, &pbSeg[offSeg], cbSeg - offSeg);
406	pThis->offCurPos += cbSeg - offSeg;
407	}
408
409	cbLeft -= cbSeg;
410	}
411	}
412	}
413	return rc;
414	}
415
416
417	/**
418	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite}
419	*/
420	static DECLCALLBACK(int) rtManifestPtIos_Write(void pvThis, RTFOFF off, PRTSGBUF pSgBuf, bool fBlocking, size_t pcbWritten)
421	{
422	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
423	Assert(RTVfsIoStrmTell(pThis->hVfsIos) == pThis->offCurPos);
424
425	/*
426	* Validate the offset.
427	*/
428	if (off < 0 \|\| off == pThis->offCurPos)
429	{ /* likely */ }
430	else
431	{
432	/* We cannot go back and rewrite stuff. Sorry. */
433	AssertReturn(off > pThis->offCurPos, VERR_WRONG_ORDER);
434
435	/*
436	* We've got a gap between the current and new position.
437	* Fill it with zeros and hope for the best.
438	*/
439	uint64_t cbZeroGap = off - pThis->offCurPos;
440	do
441	{
442	size_t cbToZero = cbZeroGap >= sizeof(g_abRTZero64K) ? sizeof(g_abRTZero64K) : (size_t)cbZeroGap;
443	size_t cbZeroed = 0;
444	int rc = RTVfsIoStrmWrite(pThis->hVfsIos, g_abRTZero64K, cbToZero, true /fBlocking/, &cbZeroed);
445	if (RT_FAILURE(rc))
446	return rc;
447	pThis->offCurPos += cbZeroed;
448	rtManifestHashesUpdate(pThis->pHashes, g_abRTZero64K, cbZeroed);
449	cbZeroGap -= cbZeroed;
450	} while (cbZeroGap > 0);
451	Assert(off == pThis->offCurPos);
452	}
453
454	/*
455	* Clone the buffer for the manifest pass.
456	*/
457	RTSGBUF CloneSgBuf;
458	RTSgBufClone(&CloneSgBuf, pSgBuf);
459	size_t const cbReq = RTSgBufCalcLengthLeft(pSgBuf);
460
461	/*
462	* Do the writing.
463	*/
464	int rc = RTVfsIoStrmSgWrite(pThis->hVfsIos, -1 /off/, pSgBuf, fBlocking, pcbWritten);
465	if (RT_SUCCESS(rc))
466	{
467	rtManifestPtIos_UpdateHashes(pThis, &CloneSgBuf, pcbWritten ? *pcbWritten : cbReq);
468	pThis->offCurPos += pcbWritten ? *pcbWritten : cbReq;
469	}
470	return rc;
471	}
472
473
474	/**
475	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush}
476	*/
477	static DECLCALLBACK(int) rtManifestPtIos_Flush(void *pvThis)
478	{
479	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
480	return RTVfsIoStrmFlush(pThis->hVfsIos);
481	}
482
483
484	/**
485	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne}
486	*/
487	static DECLCALLBACK(int) rtManifestPtIos_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr,
488	uint32_t *pfRetEvents)
489	{
490	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
491	return RTVfsIoStrmPoll(pThis->hVfsIos, fEvents, cMillies, fIntr, pfRetEvents);
492	}
493
494
495	/**
496	* @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell}
497	*/
498	static DECLCALLBACK(int) rtManifestPtIos_Tell(void *pvThis, PRTFOFF poffActual)
499	{
500	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)pvThis;
501	RTFOFF off = RTVfsIoStrmTell(pThis->hVfsIos);
502	if (off < 0)
503	return (int)off;
504	*poffActual = off;
505	return VINF_SUCCESS;
506	}
507
508
509	/**
510	* The manifest passthru I/O stream vtable.
511	*/
512	static RTVFSIOSTREAMOPS g_rtManifestPassthruIosOps =
513	{
514	{ /* Obj */
515	RTVFSOBJOPS_VERSION,
516	RTVFSOBJTYPE_IO_STREAM,
517	"manifest passthru I/O stream",
518	rtManifestPtIos_Close,
519	rtManifestPtIos_QueryInfo,
520	NULL,
521	RTVFSOBJOPS_VERSION
522	},
523	RTVFSIOSTREAMOPS_VERSION,
524	0,
525	rtManifestPtIos_Read,
526	rtManifestPtIos_Write,
527	rtManifestPtIos_Flush,
528	rtManifestPtIos_PollOne,
529	rtManifestPtIos_Tell,
530	NULL /* Skip */,
531	NULL /* ZeroFill */,
532	RTVFSIOSTREAMOPS_VERSION,
533	};
534
535
536
537	RTDECL(int) RTManifestEntryAddPassthruIoStream(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos, const char *pszEntry,
538	uint32_t fAttrs, bool fReadOrWrite, PRTVFSIOSTREAM phVfsIosPassthru)
539	{
540	/*
541	* Validate input.
542	*/
543	AssertReturn(fAttrs < RTMANIFEST_ATTR_END, VERR_INVALID_PARAMETER);
544	AssertPtr(pszEntry);
545	AssertPtr(phVfsIosPassthru);
546
547	RTFOFF const offCurPos = RTVfsIoStrmTell(hVfsIos);
548	AssertReturn(offCurPos >= 0, (int)offCurPos);
549
550	uint32_t cRefs = RTManifestRetain(hManifest);
551	AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE);
552
553	cRefs = RTVfsIoStrmRetain(hVfsIos);
554	AssertReturnStmt(cRefs != UINT32_MAX, RTManifestRelease(hManifest), VERR_INVALID_HANDLE);
555
556	/*
557	* Create an instace of the passthru I/O stream.
558	*/
559	PRTMANIFESTPTIOS pThis;
560	RTVFSIOSTREAM hVfsPtIos;
561	int rc = RTVfsNewIoStream(&g_rtManifestPassthruIosOps, sizeof(*pThis), fReadOrWrite ? RTFILE_O_READ : RTFILE_O_WRITE,
562	NIL_RTVFS, NIL_RTVFSLOCK, &hVfsPtIos, (void **)&pThis);
563	if (RT_SUCCESS(rc))
564	{
565	pThis->hVfsIos = hVfsIos;
566	pThis->pHashes = rtManifestHashesCreate(fAttrs);
567	pThis->offCurPos = offCurPos;
568	pThis->hManifest = hManifest;
569	pThis->fReadOrWrite = fReadOrWrite;
570	pThis->fAddedEntry = false;
571	pThis->pszEntry = RTStrDup(pszEntry);
572	if (pThis->pszEntry && pThis->pHashes)
573	{
574	*phVfsIosPassthru = hVfsPtIos;
575	return VINF_SUCCESS;
576	}
577
578	RTVfsIoStrmRelease(hVfsPtIos);
579	}
580	else
581	{
582	RTVfsIoStrmRelease(hVfsIos);
583	RTManifestRelease(hManifest);
584	}
585	return rc;
586	}
587
588
589	RTDECL(int) RTManifestPtIosAddEntryNow(RTVFSIOSTREAM hVfsPtIos)
590	{
591	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)RTVfsIoStreamToPrivate(hVfsPtIos, &g_rtManifestPassthruIosOps);
592	AssertReturn(pThis, VERR_INVALID_HANDLE);
593	AssertReturn(!pThis->fAddedEntry, VERR_WRONG_ORDER);
594
595	pThis->fAddedEntry = true;
596	rtManifestHashesFinal(pThis->pHashes);
597	return rtManifestHashesSetAttrs(pThis->pHashes, pThis->hManifest, pThis->pszEntry);
598	}
599
600
601	RTDECL(bool) RTManifestPtIosIsInstanceOf(RTVFSIOSTREAM hVfsPtIos)
602	{
603	if (hVfsPtIos != NIL_RTVFSIOSTREAM)
604	{
605	PRTMANIFESTPTIOS pThis = (PRTMANIFESTPTIOS)RTVfsIoStreamToPrivate(hVfsPtIos, &g_rtManifestPassthruIosOps);
606	if (pThis)
607	return true;
608	}
609	return false;
610	}
611
612
613	RTDECL(int) RTManifestEntryAddIoStream(RTMANIFEST hManifest, RTVFSIOSTREAM hVfsIos, const char *pszEntry, uint32_t fAttrs)
614	{
615	/*
616	* Note! This is a convenicence function, so just use the available public
617	* methods to get the job done.
618	*/
619	AssertReturn(fAttrs < RTMANIFEST_ATTR_END, VERR_INVALID_PARAMETER);
620	AssertPtr(pszEntry);
621
622	/*
623	* Allocate and initialize the hash contexts, hash digests and I/O buffer.
624	*/
625	PRTMANIFESTHASHES pHashes = rtManifestHashesCreate(fAttrs);
626	if (!pHashes)
627	return VERR_NO_TMP_MEMORY;
628
629	int rc;
630	size_t cbBuf = _1M;
631	void *pvBuf = RTMemTmpAlloc(cbBuf);
632	if (RT_UNLIKELY(!pvBuf))
633	{
634	cbBuf = _4K;
635	pvBuf = RTMemTmpAlloc(cbBuf);
636	}
637	if (RT_LIKELY(pvBuf))
638	{
639	/*
640	* Process the stream data.
641	*/
642	for (;;)
643	{
644	size_t cbRead;
645	rc = RTVfsIoStrmRead(hVfsIos, pvBuf, cbBuf, true /fBlocking/, &cbRead);
646	if ( (rc == VINF_EOF && cbRead == 0)
647	\|\| RT_FAILURE(rc))
648	break;
649	rtManifestHashesUpdate(pHashes, pvBuf, cbRead);
650	}
651	RTMemTmpFree(pvBuf);
652	if (RT_SUCCESS(rc))
653	{
654	/*
655	* Add the entry with the finalized hashes.
656	*/
657	rtManifestHashesFinal(pHashes);
658	rc = RTManifestEntryAdd(hManifest, pszEntry);
659	if (RT_SUCCESS(rc))
660	rc = rtManifestHashesSetAttrs(pHashes, hManifest, pszEntry);
661	}
662	}
663	else
664	rc = VERR_NO_TMP_MEMORY;
665
666	rtManifestHashesDestroy(pHashes);
667	return rc;
668	}
669

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

source: vbox/trunk/src/VBox/Runtime/common/checksum/manifest3.cpp@ 100908

Download in other formats: