VirtualBox

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

Last change on this file since 7465 was 7465, checked in by vboxsync, 17 years ago

fixed RTFileCopy* regression.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 16.1 KB
Line 
1/* $Id: fileio.cpp 7465 2008-03-15 21:32:06Z vboxsync $ */
2/** @file
3 * innotek Portable Runtime - File I/O.
4 */
5
6/*
7 * Copyright (C) 2006-2007 innotek GmbH
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* Header Files *
29*******************************************************************************/
30#include <iprt/file.h>
31#include <iprt/alloc.h>
32#include <iprt/assert.h>
33#include <iprt/alloca.h>
34#include <iprt/err.h>
35#include "internal/file.h"
36
37
38/*******************************************************************************
39* Global Variables *
40*******************************************************************************/
41/** Set of forced set open flags for files opened read-only. */
42static unsigned g_fOpenReadSet = 0;
43
44/** Set of forced cleared open flags for files opened read-only. */
45static unsigned g_fOpenReadMask = 0;
46
47/** Set of forced set open flags for files opened write-only. */
48static unsigned g_fOpenWriteSet = 0;
49
50/** Set of forced cleared open flags for files opened write-only. */
51static unsigned g_fOpenWriteMask = 0;
52
53/** Set of forced set open flags for files opened read-write. */
54static unsigned g_fOpenReadWriteSet = 0;
55
56/** Set of forced cleared open flags for files opened read-write. */
57static unsigned g_fOpenReadWriteMask = 0;
58
59
60/**
61 * Force the use of open flags for all files opened after the setting is
62 * changed. The caller is responsible for not causing races with RTFileOpen().
63 *
64 * @returns iprt status code.
65 * @param fOpenForAccess Access mode to which the set/mask settings apply.
66 * @param fSet Open flags to be forced set.
67 * @param fMask Open flags to be masked out.
68 */
69RTR3DECL(int) RTFileSetForceFlags(unsigned fOpenForAccess, unsigned fSet, unsigned fMask)
70{
71 /*
72 * For now allow only RTFILE_O_WRITE_THROUGH. The other flags either
73 * make no sense in this context or are not useful to apply to all files.
74 */
75 if ((fSet | fMask) & ~RTFILE_O_WRITE_THROUGH)
76 return VERR_INVALID_PARAMETER;
77 switch (fOpenForAccess)
78 {
79 case RTFILE_O_READ:
80 g_fOpenReadSet = fSet;
81 g_fOpenReadMask = fMask;
82 break;
83 case RTFILE_O_WRITE:
84 g_fOpenWriteSet = fSet;
85 g_fOpenWriteMask = fMask;
86 break;
87 case RTFILE_O_READWRITE:
88 g_fOpenReadWriteSet = fSet;
89 g_fOpenReadWriteMask = fMask;
90 break;
91 default:
92 AssertMsgFailed(("Invalid access mode %d\n", fOpenForAccess));
93 return VERR_INVALID_PARAMETER;
94 }
95 return VINF_SUCCESS;
96}
97
98
99/**
100 * Adjusts and validates the flags.
101 *
102 * The adjustments are made according to the wishes specified using the RTFileSetForceFlags API.
103 *
104 * @returns IPRT status code.
105 * @param pfOpen Pointer to the user specified flags on input.
106 * Updated on successful return.
107 * @internal
108 */
109int rtFileRecalcAndValidateFlags(unsigned *pfOpen)
110{
111 /*
112 * Recalc.
113 */
114 unsigned fOpen = *pfOpen;
115 switch (fOpen & RTFILE_O_ACCESS_MASK)
116 {
117 case RTFILE_O_READ:
118 fOpen |= g_fOpenReadSet;
119 fOpen &= ~g_fOpenReadMask;
120 break;
121 case RTFILE_O_WRITE:
122 fOpen |= g_fOpenWriteSet;
123 fOpen &= ~g_fOpenWriteMask;
124 break;
125 case RTFILE_O_READWRITE:
126 fOpen |= g_fOpenReadWriteSet;
127 fOpen &= ~g_fOpenReadWriteMask;
128 break;
129 default:
130 AssertMsgFailed(("RTFileOpen received an invalid RW value, fOpen=%#x\n", fOpen));
131 return VERR_INVALID_PARAMETER;
132 }
133
134 /*
135 * Validate .
136 */
137 if ( !(fOpen & RTFILE_O_ACCESS_MASK)
138#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
139 || (fOpen & (~RTFILE_O_VALID_MASK | RTFILE_O_NON_BLOCK))
140#else
141 || (fOpen & ~RTFILE_O_VALID_MASK)
142#endif
143 || (fOpen & (RTFILE_O_TRUNCATE | RTFILE_O_WRITE)) == RTFILE_O_TRUNCATE
144 || ( fOpen & RTFILE_O_NOT_CONTENT_INDEXED
145 && !( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE
146 || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE
147 || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE))
148 )
149 {
150 AssertMsgFailed(("Invalid parameters! fOpen=%#x\n", fOpen));
151 return VERR_INVALID_PARAMETER;
152 }
153
154 /* done */
155 *pfOpen = fOpen;
156 return VINF_SUCCESS;
157}
158
159
160
161/**
162 * Read bytes from a file at a given offset.
163 * This function may modify the file position.
164 *
165 * @returns iprt status code.
166 * @param File Handle to the file.
167 * @param off Where to read.
168 * @param pvBuf Where to put the bytes we read.
169 * @param cbToRead How much to read.
170 * @param *pcbRead How much we actually read.
171 * If NULL an error will be returned for a partial read.
172 */
173RTR3DECL(int) RTFileReadAt(RTFILE File, RTFOFF off, void *pvBuf, size_t cbToRead, size_t *pcbRead)
174{
175 int rc = RTFileSeek(File, off, RTFILE_SEEK_BEGIN, NULL);
176 if (RT_SUCCESS(rc))
177 rc = RTFileRead(File, pvBuf, cbToRead, pcbRead);
178 return rc;
179}
180
181
182/**
183 * Write bytes to a file at a given offset.
184 * This function may modify the file position.
185 *
186 * @returns iprt status code.
187 * @param File Handle to the file.
188 * @param off Where to write.
189 * @param pvBuf What to write.
190 * @param cbToWrite How much to write.
191 * @param *pcbWritten How much we actually wrote.
192 * If NULL an error will be returned for a partial write.
193 */
194RTR3DECL(int) RTFileWriteAt(RTFILE File, RTFOFF off, const void *pvBuf, size_t cbToWrite, size_t *pcbWritten)
195{
196 int rc = RTFileSeek(File, off, RTFILE_SEEK_BEGIN, NULL);
197 if (RT_SUCCESS(rc))
198 rc = RTFileWrite(File, pvBuf, cbToWrite, pcbWritten);
199 return rc;
200}
201
202
203/**
204 * Gets the current file position.
205 *
206 * @returns File offset.
207 * @returns ~0UUL on failure.
208 * @param File File handle.
209 */
210RTR3DECL(uint64_t) RTFileTell(RTFILE File)
211{
212 /*
213 * Call the seek api to query the stuff.
214 */
215 uint64_t off = 0;
216 int rc = RTFileSeek(File, 0, RTFILE_SEEK_CURRENT, &off);
217 if (RT_SUCCESS(rc))
218 return off;
219 AssertMsgFailed(("RTFileSeek(%d) -> %d\n", File, rc));
220 return ~0ULL;
221}
222
223
224/**
225 * Determine the maximum file size.
226 *
227 * @returns The max size of the file.
228 * -1 on failure, the file position is undefined.
229 * @param File Handle to the file.
230 * @see RTFileGetMaxSizeEx.
231 */
232RTR3DECL(RTFOFF) RTFileGetMaxSize(RTFILE File)
233{
234 RTFOFF cbMax;
235 int rc = RTFileGetMaxSizeEx(File, &cbMax);
236 return RT_SUCCESS(rc) ? cbMax : -1;
237}
238
239
240/**
241 * Determine the maximum file size.
242 *
243 * @returns IPRT status code.
244 * @param File Handle to the file.
245 * @param pcbMax Where to store the max file size.
246 * @see RTFileGetMaxSize.
247 */
248RTR3DECL(int) RTFileGetMaxSizeEx(RTFILE File, PRTFOFF pcbMax)
249{
250 /*
251 * Save the current location
252 */
253 uint64_t offOld;
254 int rc = RTFileSeek(File, 0, RTFILE_SEEK_CURRENT, &offOld);
255 if (RT_FAILURE(rc))
256 return rc;
257
258 /*
259 * Perform a binary search for the max file size.
260 */
261 uint64_t offLow = 0;
262 uint64_t offHigh = 8 * _1T; /* we don't need bigger files */
263 /** @todo r=bird: This isn't doing the trick for windows (at least not vista).
264 * Close to offHigh is returned regardless of NTFS or FAT32.
265 * We might have to make this code OS specific...
266 * In the worse case, we'll have to try GetVolumeInformationByHandle on vista and fall
267 * back on NtQueryVolumeInformationFile(,,,, FileFsAttributeInformation) else where, and
268 * check for known file system names. (For LAN shares we'll have to figure out the remote
269 * file system.) */
270 //uint64_t offHigh = INT64_MAX;
271 for (;;)
272 {
273 uint64_t cbInterval = (offHigh - offLow) >> 1;
274 if (cbInterval == 0)
275 {
276 if (pcbMax)
277 *pcbMax = offLow;
278 return RTFileSeek(File, offOld, RTFILE_SEEK_BEGIN, NULL);
279 }
280
281 rc = RTFileSeek(File, offLow + cbInterval, RTFILE_SEEK_BEGIN, NULL);
282 if (RT_FAILURE(rc))
283 offHigh = offLow + cbInterval;
284 else
285 offLow = offLow + cbInterval;
286 }
287}
288
289
290/**
291 * Copies a file given the handles to both files.
292 *
293 * @returns VBox Status code.
294 *
295 * @param FileSrc The source file. The file position is unaltered.
296 * @param FileDst The destination file.
297 * On successful returns the file position is at the end of the file.
298 * On failures the file position and size is undefined.
299 */
300RTDECL(int) RTFileCopyByHandles(RTFILE FileSrc, RTFILE FileDst)
301{
302 return RTFileCopyByHandlesEx(FileSrc, FileDst, NULL, NULL);
303}
304
305
306/**
307 * Copies a file.
308 *
309 * @returns VERR_ALREADY_EXISTS if the destination file exists.
310 * @returns VBox Status code.
311 *
312 * @param pszSrc The path to the source file.
313 * @param pszDst The path to the destination file.
314 * This file will be created.
315 * @param fFlags Flags, any of the RTFILECOPY_FLAGS_ \#defines.
316 * @param pfnProgress Pointer to callback function for reporting progress.
317 * @param pvUser User argument to pass to pfnProgress along with the completion precentage.
318 */
319RTDECL(int) RTFileCopyEx(const char *pszSrc, const char *pszDst, uint32_t fFlags, PFNRTPROGRESS pfnProgress, void *pvUser)
320{
321 /*
322 * Validate input.
323 */
324 AssertMsgReturn(VALID_PTR(pszSrc), ("pszSrc=%p\n", pszSrc), VERR_INVALID_PARAMETER);
325 AssertMsgReturn(*pszSrc, ("pszSrc=%p\n", pszSrc), VERR_INVALID_PARAMETER);
326 AssertMsgReturn(VALID_PTR(pszDst), ("pszDst=%p\n", pszDst), VERR_INVALID_PARAMETER);
327 AssertMsgReturn(*pszDst, ("pszDst=%p\n", pszDst), VERR_INVALID_PARAMETER);
328 AssertMsgReturn(!pfnProgress || VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
329 AssertMsgReturn(!(fFlags & ~RTFILECOPY_FLAGS_MASK), ("%#x\n", fFlags), VERR_INVALID_PARAMETER);
330
331 /*
332 * Open the files.
333 */
334 RTFILE FileSrc;
335 int rc = RTFileOpen(&FileSrc, pszSrc,
336 RTFILE_O_READ | (fFlags & RTFILECOPY_FLAGS_NO_SRC_DENY_WRITE ? 0 : RTFILE_O_DENY_WRITE) | RTFILE_O_OPEN);
337 if (RT_SUCCESS(rc))
338 {
339 RTFILE FileDst;
340 rc = RTFileOpen(&FileDst, pszDst,
341 RTFILE_O_WRITE | (fFlags & RTFILECOPY_FLAGS_NO_DST_DENY_WRITE ? 0 : RTFILE_O_DENY_WRITE) | RTFILE_O_CREATE);
342 if (RT_SUCCESS(rc))
343 {
344 /*
345 * Call the ByHandles version and let it do the job.
346 */
347 rc = RTFileCopyByHandlesEx(FileSrc, FileDst, pfnProgress, pvUser);
348
349 /*
350 * Close the files regardless of the result.
351 * Don't bother cleaning up or anything like that.
352 */
353 int rc2 = RTFileClose(FileDst);
354 AssertRC(rc2);
355 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
356 rc = rc2;
357 }
358
359 int rc2 = RTFileClose(FileSrc);
360 AssertRC(rc2);
361 if (RT_FAILURE(rc2) && RT_SUCCESS(rc))
362 rc = rc2;
363 }
364 return rc;
365}
366
367
368/**
369 * Copies a file given the handles to both files and
370 * provide progress callbacks.
371 *
372 * @returns VBox Status code.
373 *
374 * @param FileSrc The source file. The file position is unaltered.
375 * @param FileDst The destination file.
376 * On successful returns the file position is at the end of the file.
377 * On failures the file position and size is undefined.
378 * @param pfnProgress Pointer to callback function for reporting progress.
379 * @param pvUser User argument to pass to pfnProgress along with the completion precentage.
380 */
381RTDECL(int) RTFileCopyByHandlesEx(RTFILE FileSrc, RTFILE FileDst, PFNRTPROGRESS pfnProgress, void *pvUser)
382{
383 /*
384 * Validate input.
385 */
386 AssertMsgReturn(RTFileIsValid(FileSrc), ("FileSrc=%RTfile\n", FileSrc), VERR_INVALID_PARAMETER);
387 AssertMsgReturn(RTFileIsValid(FileDst), ("FileDst=%RTfile\n", FileDst), VERR_INVALID_PARAMETER);
388 AssertMsgReturn(!pfnProgress || VALID_PTR(pfnProgress), ("pfnProgress=%p\n", pfnProgress), VERR_INVALID_PARAMETER);
389
390 /*
391 * Save file offset.
392 */
393 RTFOFF offSrcSaved;
394 int rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_CURRENT, (uint64_t *)&offSrcSaved);
395 if (RT_FAILURE(rc))
396 return rc;
397
398 /*
399 * Get the file size.
400 */
401 RTFOFF cbSrc;
402 rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_END, (uint64_t *)&cbSrc);
403 if (RT_FAILURE(rc))
404 return rc;
405
406 /*
407 * Allocate buffer.
408 */
409 size_t cbBuf;
410 uint8_t *pbBufFree = NULL;
411 uint8_t *pbBuf;
412 if (cbSrc < _512K)
413 {
414 cbBuf = 8*_1K;
415 pbBuf = (uint8_t *)alloca(cbBuf);
416 }
417 else
418 {
419 cbBuf = _128K;
420 pbBuf = pbBufFree = (uint8_t *)RTMemTmpAlloc(cbBuf);
421 }
422 if (pbBuf)
423 {
424 /*
425 * Seek to the start of each file
426 * and set the size of the destination file.
427 */
428 rc = RTFileSeek(FileSrc, 0, RTFILE_SEEK_BEGIN, NULL);
429 if (RT_SUCCESS(rc))
430 {
431 rc = RTFileSeek(FileDst, 0, RTFILE_SEEK_BEGIN, NULL);
432 if (RT_SUCCESS(rc))
433 rc = RTFileSetSize(FileDst, cbSrc);
434 if (RT_SUCCESS(rc) && pfnProgress)
435 rc = pfnProgress(0, pvUser);
436 if (RT_SUCCESS(rc))
437 {
438 /*
439 * Copy loop.
440 */
441 unsigned uPercentage = 0;
442 RTFOFF off = 0;
443 RTFOFF cbPercent = cbSrc / 100;
444 RTFOFF offNextPercent = cbPercent;
445 while (off < cbSrc)
446 {
447 /* copy block */
448 RTFOFF cbLeft = cbSrc - off;
449 size_t cbBlock = cbLeft >= (RTFOFF)cbBuf ? cbBuf : (size_t)cbLeft;
450 rc = RTFileRead(FileSrc, pbBuf, cbBlock, NULL);
451 if (RT_FAILURE(rc))
452 break;
453 rc = RTFileWrite(FileDst, pbBuf, cbBlock, NULL);
454 if (RT_FAILURE(rc))
455 break;
456
457 /* advance */
458 off += cbBlock;
459 if (pfnProgress && offNextPercent < off)
460 {
461 while (offNextPercent < off)
462 {
463 uPercentage++;
464 offNextPercent += cbPercent;
465 }
466 rc = pfnProgress(uPercentage, pvUser);
467 if (RT_FAILURE(rc))
468 break;
469 }
470 }
471
472#if 0
473 /*
474 * Copy OS specific data (EAs and stuff).
475 */
476 rtFileCopyOSStuff(FileSrc, FileDst);
477#endif
478
479 /* 100% */
480 if (pfnProgress && uPercentage < 100 && RT_SUCCESS(rc))
481 rc = pfnProgress(100, pvUser);
482 }
483 }
484 RTMemTmpFree(pbBufFree);
485 }
486 else
487 rc = VERR_NO_MEMORY;
488
489 /*
490 * Restore source position.
491 */
492 RTFileSeek(FileSrc, offSrcSaved, RTFILE_SEEK_BEGIN, NULL);
493
494 return rc;
495}
496
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette