fileio.cpp@ 57918

Last change on this file since 57918 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 22.7 KB

Line
1	/* $Id: fileio.cpp 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - File I/O.
4	*/
5
6	/*
7	* Copyright (C) 2006-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	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#include "internal/iprt.h"
32	#include <iprt/file.h>
33
34	#include <iprt/mem.h>
35	#include <iprt/assert.h>
36	#include <iprt/alloca.h>
37	#include <iprt/string.h>
38	#include <iprt/err.h>
39	#include "internal/file.h"
40
41
42	/*********************************************************************************************************************************
43	* Global Variables *
44	*********************************************************************************************************************************/
45	/** Set of forced set open flags for files opened read-only. */
46	static unsigned g_fOpenReadSet = 0;
47
48	/** Set of forced cleared open flags for files opened read-only. */
49	static unsigned g_fOpenReadMask = 0;
50
51	/** Set of forced set open flags for files opened write-only. */
52	static unsigned g_fOpenWriteSet = 0;
53
54	/** Set of forced cleared open flags for files opened write-only. */
55	static unsigned g_fOpenWriteMask = 0;
56
57	/** Set of forced set open flags for files opened read-write. */
58	static unsigned g_fOpenReadWriteSet = 0;
59
60	/** Set of forced cleared open flags for files opened read-write. */
61	static unsigned g_fOpenReadWriteMask = 0;
62
63
64	/**
65	* Force the use of open flags for all files opened after the setting is
66	* changed. The caller is responsible for not causing races with RTFileOpen().
67	*
68	* @returns iprt status code.
69	* @param fOpenForAccess Access mode to which the set/mask settings apply.
70	* @param fSet Open flags to be forced set.
71	* @param fMask Open flags to be masked out.
72	*/
73	RTR3DECL(int) RTFileSetForceFlags(unsigned fOpenForAccess, unsigned fSet, unsigned fMask)
74	{
75	/*
76	* For now allow only RTFILE_O_WRITE_THROUGH. The other flags either
77	* make no sense in this context or are not useful to apply to all files.
78	*/
79	if ((fSet \| fMask) & ~RTFILE_O_WRITE_THROUGH)
80	return VERR_INVALID_PARAMETER;
81	switch (fOpenForAccess)
82	{
83	case RTFILE_O_READ:
84	g_fOpenReadSet = fSet;
85	g_fOpenReadMask = fMask;
86	break;
87	case RTFILE_O_WRITE:
88	g_fOpenWriteSet = fSet;
89	g_fOpenWriteMask = fMask;
90	break;
91	case RTFILE_O_READWRITE:
92	g_fOpenReadWriteSet = fSet;
93	g_fOpenReadWriteMask = fMask;
94	break;
95	default:
96	AssertMsgFailed(("Invalid access mode %d\n", fOpenForAccess));
97	return VERR_INVALID_PARAMETER;
98	}
99	return VINF_SUCCESS;
100	}
101
102
103	/**
104	* Adjusts and validates the flags.
105	*
106	* The adjustments are made according to the wishes specified using the RTFileSetForceFlags API.
107	*
108	* @returns IPRT status code.
109	* @param pfOpen Pointer to the user specified flags on input.
110	* Updated on successful return.
111	* @internal
112	*/
113	int rtFileRecalcAndValidateFlags(uint64_t *pfOpen)
114	{
115	/*
116	* Recalc.
117	*/
118	uint32_t fOpen = *pfOpen;
119	switch (fOpen & RTFILE_O_ACCESS_MASK)
120	{
121	case RTFILE_O_READ:
122	fOpen \|= g_fOpenReadSet;
123	fOpen &= ~g_fOpenReadMask;
124	break;
125	case RTFILE_O_WRITE:
126	fOpen \|= g_fOpenWriteSet;
127	fOpen &= ~g_fOpenWriteMask;
128	break;
129	case RTFILE_O_READWRITE:
130	fOpen \|= g_fOpenReadWriteSet;
131	fOpen &= ~g_fOpenReadWriteMask;
132	break;
133	default:
134	AssertMsgFailed(("Invalid RW value, fOpen=%#llx\n", fOpen));
135	return VERR_INVALID_PARAMETER;
136	}
137
138	/*
139	* Validate .
140	*/
141	AssertMsgReturn(fOpen & RTFILE_O_ACCESS_MASK, ("Missing RTFILE_O_READ/WRITE: fOpen=%#llx\n", fOpen), VERR_INVALID_PARAMETER);
142	#if defined(RT_OS_WINDOWS) \|\| defined(RT_OS_OS2)
143	AssertMsgReturn(!(fOpen & (~(uint64_t)RTFILE_O_VALID_MASK \| RTFILE_O_NON_BLOCK)), ("%#llx\n", fOpen), VERR_INVALID_PARAMETER);
144	#else
145	AssertMsgReturn(!(fOpen & ~(uint64_t)RTFILE_O_VALID_MASK), ("%#llx\n", fOpen), VERR_INVALID_PARAMETER);
146	#endif
147	AssertMsgReturn((fOpen & (RTFILE_O_TRUNCATE \| RTFILE_O_WRITE)) != RTFILE_O_TRUNCATE, ("%#llx\n", fOpen), VERR_INVALID_PARAMETER);
148
149	switch (fOpen & RTFILE_O_ACTION_MASK)
150	{
151	case 0: /* temporarily */
152	AssertMsgFailed(("Missing RTFILE_O_OPEN/CREATE*! (continuable assertion)\n"));
153	fOpen \|= RTFILE_O_OPEN;
154	break;
155	case RTFILE_O_OPEN:
156	AssertMsgReturn(!(RTFILE_O_NOT_CONTENT_INDEXED & fOpen), ("%#llx\n", fOpen), VERR_INVALID_PARAMETER);
157	case RTFILE_O_OPEN_CREATE:
158	case RTFILE_O_CREATE:
159	case RTFILE_O_CREATE_REPLACE:
160	break;
161	default:
162	AssertMsgFailed(("Invalid action value: fOpen=%#llx\n", fOpen));
163	return VERR_INVALID_PARAMETER;
164	}
165
166	switch (fOpen & RTFILE_O_DENY_MASK)
167	{
168	case 0: /* temporarily */
169	AssertMsgFailed(("Missing RTFILE_O_DENY_*! (continuable assertion)\n"));
170	fOpen \|= RTFILE_O_DENY_NONE;
171	break;
172	case RTFILE_O_DENY_NONE:
173	case RTFILE_O_DENY_READ:
174	case RTFILE_O_DENY_WRITE:
175	case RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ:
176	case RTFILE_O_DENY_NOT_DELETE:
177	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_READ:
178	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_WRITE:
179	case RTFILE_O_DENY_NOT_DELETE \| RTFILE_O_DENY_WRITE \| RTFILE_O_DENY_READ:
180	break;
181	default:
182	AssertMsgFailed(("Invalid deny value: fOpen=%#llx\n", fOpen));
183	return VERR_INVALID_PARAMETER;
184	}
185
186	/* done */
187	*pfOpen = fOpen;
188	return VINF_SUCCESS;
189	}
190
191
192
193	/**
194	* Read bytes from a file at a given offset.
195	* This function may modify the file position.
196	*
197	* @returns iprt status code.
198	* @param File Handle to the file.
199	* @param off Where to read.
200	* @param pvBuf Where to put the bytes we read.
201	* @param cbToRead How much to read.
202	* @param *pcbRead How much we actually read.
203	* If NULL an error will be returned for a partial read.
204	*/
205	RTR3DECL(int) RTFileReadAt(RTFILE File, RTFOFF off, void pvBuf, size_t cbToRead, size_t pcbRead)
206	{
207	int rc = RTFileSeek(File, off, RTFILE_SEEK_BEGIN, NULL);
208	if (RT_SUCCESS(rc))
209	rc = RTFileRead(File, pvBuf, cbToRead, pcbRead);
210	return rc;
211	}
212
213
214	/**
215	* Read bytes from a file at a given offset into a S/G buffer.
216	* This function may modify the file position.
217	*
218	* @returns iprt status code.
219	* @param hFile Handle to the file.
220	* @param off Where to read.
221	* @param pSgBuf Pointer to the S/G buffer to read into.
222	* @param cbToRead How much to read.
223	* @param pcbRead How much we actually read.
224	* If NULL an error will be returned for a partial read.
225	*/
226	RTR3DECL(int) RTFileSgReadAt(RTFILE hFile, RTFOFF off, PRTSGBUF pSgBuf, size_t cbToRead, size_t *pcbRead)
227	{
228	int rc = VINF_SUCCESS;
229	size_t cbRead = 0;
230
231	while (cbToRead)
232	{
233	size_t cbThisRead = 0;
234	size_t cbBuf = cbToRead;
235	void *pvBuf = RTSgBufGetNextSegment(pSgBuf, &cbBuf);
236
237	rc = RTFileReadAt(hFile, off, pvBuf, cbBuf, pcbRead ? &cbThisRead : NULL);
238	if (RT_SUCCESS(rc))
239	cbRead += cbThisRead;
240
241	if ( RT_FAILURE(rc)
242	\|\| ( cbThisRead < cbBuf
243	&& pcbRead))
244	break;
245
246	cbToRead -= cbBuf;
247	off += cbBuf;
248	}
249
250	if (pcbRead)
251	*pcbRead = cbRead;
252
253	return rc;
254	}
255
256
257	/**
258	* Write bytes to a file at a given offset.
259	* This function may modify the file position.
260	*
261	* @returns iprt status code.
262	* @param File Handle to the file.
263	* @param off Where to write.
264	* @param pvBuf What to write.
265	* @param cbToWrite How much to write.
266	* @param *pcbWritten How much we actually wrote.
267	* If NULL an error will be returned for a partial write.
268	*/
269	RTR3DECL(int) RTFileWriteAt(RTFILE File, RTFOFF off, const void pvBuf, size_t cbToWrite, size_t pcbWritten)
270	{
271	int rc = RTFileSeek(File, off, RTFILE_SEEK_BEGIN, NULL);
272	if (RT_SUCCESS(rc))
273	rc = RTFileWrite(File, pvBuf, cbToWrite, pcbWritten);
274	return rc;
275	}
276
277
278	/**
279	* Write bytes from a S/G buffer to a file at a given offset.
280	* This function may modify the file position.
281	*
282	* @returns iprt status code.
283	* @param hFile Handle to the file.
284	* @param off Where to write.
285	* @param pSgBuf What to write.
286	* @param cbToWrite How much to write.
287	* @param pcbWritten How much we actually wrote.
288	* If NULL an error will be returned for a partial write.
289	*/
290	RTR3DECL(int) RTFileSgWriteAt(RTFILE hFile, RTFOFF off, PRTSGBUF pSgBuf, size_t cbToWrite, size_t *pcbWritten)
291	{
292	int rc = VINF_SUCCESS;
293	size_t cbWritten = 0;
294
295	while (cbToWrite)
296	{
297	size_t cbThisWritten = 0;
298	size_t cbBuf = cbToWrite;
299	void *pvBuf = RTSgBufGetNextSegment(pSgBuf, &cbBuf);
300
301	rc = RTFileWriteAt(hFile, off, pvBuf, cbBuf, pcbWritten ? &cbThisWritten : NULL);
302	if (RT_SUCCESS(rc))
303	cbWritten += cbThisWritten;
304
305	if ( RT_FAILURE(rc)
306	\|\| ( cbThisWritten < cbBuf
307	&& pcbWritten))
308	break;
309
310	cbToWrite -= cbBuf;
311	off += cbBuf;
312	}
313
314	if (pcbWritten)
315	*pcbWritten = cbWritten;
316
317	return rc;
318	}
319
320
321	/**
322	* Gets the current file position.
323	*
324	* @returns File offset.
325	* @returns ~0UUL on failure.
326	* @param File File handle.
327	*/
328	RTR3DECL(uint64_t) RTFileTell(RTFILE File)
329	{
330	/*
331	* Call the seek api to query the stuff.
332	*/
333	uint64_t off = 0;
334	int rc = RTFileSeek(File, 0, RTFILE_SEEK_CURRENT, &off);
335	if (RT_SUCCESS(rc))
336	return off;
337	AssertMsgFailed(("RTFileSeek(%d) -> %d\n", File, rc));
338	return ~0ULL;
339	}
340
341
342	/**
343	* Determine the maximum file size.
344	*
345	* @returns The max size of the file.
346	* -1 on failure, the file position is undefined.
347	* @param File Handle to the file.
348	* @see RTFileGetMaxSizeEx.
349	*/
350	RTR3DECL(RTFOFF) RTFileGetMaxSize(RTFILE File)
351	{
352	RTFOFF cbMax;
353	int rc = RTFileGetMaxSizeEx(File, &cbMax);
354	return RT_SUCCESS(rc) ? cbMax : -1;
355	}
356
357
358	RTDECL(int) RTFileCopyByHandles(RTFILE FileSrc, RTFILE FileDst)
359	{
360	return RTFileCopyByHandlesEx(FileSrc, FileDst, NULL, NULL);
361	}
362
363
364	RTDECL(int) RTFileCopyEx(const char pszSrc, const char pszDst, uint32_t fFlags, PFNRTPROGRESS pfnProgress, void *pvUser)
365	{
366	/*
367	* Validate input.
368	*/
369	AssertMsgReturn(VALID_PTR(pszSrc), ("pszSrc=%p\n", pszSrc), VERR_INVALID_PARAMETER);
370	AssertMsgReturn(*pszSrc, ("pszSrc=%p\n", pszSrc), VERR_INVALID_PARAMETER);
371	AssertMsgReturn(VALID_PTR(pszDst), ("pszDst=%p\n", pszDst), VERR_INVALID_PARAMETER);
372	AssertMsgReturn(*pszDst, ("pszDst=%p\n", pszDst), VERR_INVALID_PARAMETER);
373	AssertMsgReturn(!pfnProgress \|\| VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
374	AssertMsgReturn(!(fFlags & ~RTFILECOPY_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
375
376	/*
377	* Open the files.
378	*/
379	RTFILE FileSrc;
380	int rc = RTFileOpen(&FileSrc, pszSrc,
381	RTFILE_O_READ \| RTFILE_O_OPEN
382	\| (fFlags & RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
383	if (RT_SUCCESS(rc))
384	{
385	RTFILE FileDst;
386	rc = RTFileOpen(&FileDst, pszDst,
387	RTFILE_O_WRITE \| RTFILE_O_CREATE
388	\| (fFlags & RTFILECOPY_FLAGS_NO_DST_DENY_WRITE ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
389	if (RT_SUCCESS(rc))
390	{
391	/*
392	* Call the ByHandles version and let it do the job.
393	*/
394	rc = RTFileCopyByHandlesEx(FileSrc, FileDst, pfnProgress, pvUser);
395
396	/*
397	* Close the files regardless of the result.
398	* Don't bother cleaning up or anything like that.
399	*/
400	int rc2 = RTFileClose(FileDst);
401	AssertRC(rc2);
402	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
403	rc = rc2;
404	}
405
406	int rc2 = RTFileClose(FileSrc);
407	AssertRC(rc2);
408	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
409	rc = rc2;
410	}
411	return rc;
412	}
413
414
415	RTDECL(int) RTFileCopyByHandlesEx(RTFILE FileSrc, RTFILE FileDst, PFNRTPROGRESS pfnProgress, void *pvUser)
416	{
417	/*
418	* Validate input.
419	*/
420	AssertMsgReturn(RTFileIsValid(FileSrc), ("FileSrc=%RTfile\n", FileSrc), VERR_INVALID_PARAMETER);
421	AssertMsgReturn(RTFileIsValid(FileDst), ("FileDst=%RTfile\n", FileDst), VERR_INVALID_PARAMETER);
422	AssertMsgReturn(!pfnProgress \|\| VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
423
424	/*
425	* Save file offset.
426	*/
427	RTFOFF offSrcSaved;
428	int rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_CURRENT, (uint64_t *)&offSrcSaved);
429	if (RT_FAILURE(rc))
430	return rc;
431
432	/*
433	* Get the file size.
434	*/
435	RTFOFF cbSrc;
436	rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_END, (uint64_t *)&cbSrc);
437	if (RT_FAILURE(rc))
438	return rc;
439
440	/*
441	* Allocate buffer.
442	*/
443	size_t cbBuf;
444	uint8_t *pbBufFree = NULL;
445	uint8_t *pbBuf;
446	if (cbSrc < _512K)
447	{
448	cbBuf = 8*_1K;
449	pbBuf = (uint8_t *)alloca(cbBuf);
450	}
451	else
452	{
453	cbBuf = _128K;
454	pbBuf = pbBufFree = (uint8_t *)RTMemTmpAlloc(cbBuf);
455	}
456	if (pbBuf)
457	{
458	/*
459	* Seek to the start of each file
460	* and set the size of the destination file.
461	*/
462	rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_BEGIN, NULL);
463	if (RT_SUCCESS(rc))
464	{
465	rc = RTFileSeek(FileDst, 0, RTFILE_SEEK_BEGIN, NULL);
466	if (RT_SUCCESS(rc))
467	rc = RTFileSetSize(FileDst, cbSrc);
468	if (RT_SUCCESS(rc) && pfnProgress)
469	rc = pfnProgress(0, pvUser);
470	if (RT_SUCCESS(rc))
471	{
472	/*
473	* Copy loop.
474	*/
475	unsigned uPercentage = 0;
476	RTFOFF off = 0;
477	RTFOFF cbPercent = cbSrc / 100;
478	RTFOFF offNextPercent = cbPercent;
479	while (off < cbSrc)
480	{
481	/* copy block */
482	RTFOFF cbLeft = cbSrc - off;
483	size_t cbBlock = cbLeft >= (RTFOFF)cbBuf ? cbBuf : (size_t)cbLeft;
484	rc = RTFileRead(FileSrc, pbBuf, cbBlock, NULL);
485	if (RT_FAILURE(rc))
486	break;
487	rc = RTFileWrite(FileDst, pbBuf, cbBlock, NULL);
488	if (RT_FAILURE(rc))
489	break;
490
491	/* advance */
492	off += cbBlock;
493	if (pfnProgress && offNextPercent < off)
494	{
495	while (offNextPercent < off)
496	{
497	uPercentage++;
498	offNextPercent += cbPercent;
499	}
500	rc = pfnProgress(uPercentage, pvUser);
501	if (RT_FAILURE(rc))
502	break;
503	}
504	}
505
506	#if 0
507	/*
508	* Copy OS specific data (EAs and stuff).
509	*/
510	rtFileCopyOSStuff(FileSrc, FileDst);
511	#endif
512
513	/* 100% */
514	if (pfnProgress && uPercentage < 100 && RT_SUCCESS(rc))
515	rc = pfnProgress(100, pvUser);
516	}
517	}
518	RTMemTmpFree(pbBufFree);
519	}
520	else
521	rc = VERR_NO_MEMORY;
522
523	/*
524	* Restore source position.
525	*/
526	RTFileSeek(FileSrc, offSrcSaved, RTFILE_SEEK_BEGIN, NULL);
527
528	return rc;
529	}
530
531
532	RTDECL(int) RTFileCompare(const char pszFile1, const char pszFile2)
533	{
534	return RTFileCompareEx(pszFile1, pszFile2, 0 /fFlags/, NULL, NULL);
535	}
536
537
538	RTDECL(int) RTFileCompareByHandles(RTFILE hFile1, RTFILE hFile2)
539	{
540	return RTFileCompareByHandlesEx(hFile1, hFile2, 0 /fFlags/, NULL, NULL);
541	}
542
543
544	RTDECL(int) RTFileCompareEx(const char pszFile1, const char pszFile2, uint32_t fFlags, PFNRTPROGRESS pfnProgress, void *pvUser)
545	{
546	/*
547	* Validate input.
548	*/
549	AssertPtrReturn(pszFile1, VERR_INVALID_POINTER);
550	AssertReturn(*pszFile1, VERR_INVALID_PARAMETER);
551	AssertPtrReturn(pszFile2, VERR_INVALID_POINTER);
552	AssertReturn(*pszFile2, VERR_INVALID_PARAMETER);
553	AssertMsgReturn(!pfnProgress \|\| VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
554	AssertMsgReturn(!(fFlags & ~RTFILECOMP_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
555
556	/*
557	* Open the files.
558	*/
559	RTFILE hFile1;
560	int rc = RTFileOpen(&hFile1, pszFile1,
561	RTFILE_O_READ \| RTFILE_O_OPEN
562	\| (fFlags & RTFILECOMP_FLAGS_NO_DENY_WRITE_FILE1 ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
563	if (RT_SUCCESS(rc))
564	{
565	RTFILE hFile2;
566	rc = RTFileOpen(&hFile2, pszFile2,
567	RTFILE_O_READ \| RTFILE_O_OPEN
568	\| (fFlags & RTFILECOMP_FLAGS_NO_DENY_WRITE_FILE2 ? RTFILE_O_DENY_NONE : RTFILE_O_DENY_WRITE));
569	if (RT_SUCCESS(rc))
570	{
571	/*
572	* Call the ByHandles version and let it do the job.
573	*/
574	rc = RTFileCompareByHandlesEx(hFile1, hFile2, fFlags, pfnProgress, pvUser);
575
576	/* Clean up */
577	int rc2 = RTFileClose(hFile2);
578	AssertRC(rc2);
579	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
580	rc = rc2;
581	}
582
583	int rc2 = RTFileClose(hFile1);
584	AssertRC(rc2);
585	if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
586	rc = rc2;
587	}
588	return rc;
589	}
590
591
592	RTDECL(int) RTFileCompareByHandlesEx(RTFILE hFile1, RTFILE hFile2, uint32_t fFlags, PFNRTPROGRESS pfnProgress, void *pvUser)
593	{
594	/*
595	* Validate input.
596	*/
597	AssertReturn(RTFileIsValid(hFile1), VERR_INVALID_HANDLE);
598	AssertReturn(RTFileIsValid(hFile1), VERR_INVALID_HANDLE);
599	AssertMsgReturn(!pfnProgress \|\| VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
600	AssertMsgReturn(!(fFlags & ~RTFILECOMP_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
601
602	/*
603	* Compare the file sizes first.
604	*/
605	uint64_t cbFile1;
606	int rc = RTFileGetSize(hFile1, &cbFile1);
607	if (RT_FAILURE(rc))
608	return rc;
609
610	uint64_t cbFile2;
611	rc = RTFileGetSize(hFile1, &cbFile2);
612	if (RT_FAILURE(rc))
613	return rc;
614
615	if (cbFile1 != cbFile2)
616	return VERR_NOT_EQUAL;
617
618
619	/*
620	* Allocate buffer.
621	*/
622	size_t cbBuf;
623	uint8_t *pbBuf1Free = NULL;
624	uint8_t *pbBuf1;
625	uint8_t *pbBuf2Free = NULL;
626	uint8_t *pbBuf2;
627	if (cbFile1 < _512K)
628	{
629	cbBuf = 8*_1K;
630	pbBuf1 = (uint8_t *)alloca(cbBuf);
631	pbBuf2 = (uint8_t *)alloca(cbBuf);
632	}
633	else
634	{
635	cbBuf = _128K;
636	pbBuf1 = pbBuf1Free = (uint8_t *)RTMemTmpAlloc(cbBuf);
637	pbBuf2 = pbBuf2Free = (uint8_t *)RTMemTmpAlloc(cbBuf);
638	}
639	if (pbBuf1 && pbBuf2)
640	{
641	/*
642	* Seek to the start of each file
643	* and set the size of the destination file.
644	*/
645	rc = RTFileSeek(hFile1, 0, RTFILE_SEEK_BEGIN, NULL);
646	if (RT_SUCCESS(rc))
647	{
648	rc = RTFileSeek(hFile2, 0, RTFILE_SEEK_BEGIN, NULL);
649	if (RT_SUCCESS(rc) && pfnProgress)
650	rc = pfnProgress(0, pvUser);
651	if (RT_SUCCESS(rc))
652	{
653	/*
654	* Compare loop.
655	*/
656	unsigned uPercentage = 0;
657	RTFOFF off = 0;
658	RTFOFF cbPercent = cbFile1 / 100;
659	RTFOFF offNextPercent = cbPercent;
660	while (off < (RTFOFF)cbFile1)
661	{
662	/* read the blocks */
663	RTFOFF cbLeft = cbFile1 - off;
664	size_t cbBlock = cbLeft >= (RTFOFF)cbBuf ? cbBuf : (size_t)cbLeft;
665	rc = RTFileRead(hFile1, pbBuf1, cbBlock, NULL);
666	if (RT_FAILURE(rc))
667	break;
668	rc = RTFileRead(hFile2, pbBuf2, cbBlock, NULL);
669	if (RT_FAILURE(rc))
670	break;
671
672	/* compare */
673	if (memcmp(pbBuf1, pbBuf2, cbBlock))
674	{
675	rc = VERR_NOT_EQUAL;
676	break;
677	}
678
679	/* advance */
680	off += cbBlock;
681	if (pfnProgress && offNextPercent < off)
682	{
683	while (offNextPercent < off)
684	{
685	uPercentage++;
686	offNextPercent += cbPercent;
687	}
688	rc = pfnProgress(uPercentage, pvUser);
689	if (RT_FAILURE(rc))
690	break;
691	}
692	}
693
694	#if 0
695	/*
696	* Compare OS specific data (EAs and stuff).
697	*/
698	if (RT_SUCCESS(rc))
699	rc = rtFileCompareOSStuff(hFile1, hFile2);
700	#endif
701
702	/* 100% */
703	if (pfnProgress && uPercentage < 100 && RT_SUCCESS(rc))
704	rc = pfnProgress(100, pvUser);
705	}
706	}
707	}
708	else
709	rc = VERR_NO_MEMORY;
710	RTMemTmpFree(pbBuf2Free);
711	RTMemTmpFree(pbBuf1Free);
712
713	return rc;
714	}
715

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

source: vbox/trunk/src/VBox/Runtime/r3/fileio.cpp@ 57918

Download in other formats: