VirtualBox

source: vbox/trunk/src/VBox/Runtime/r3/isofs.cpp@ 67954

Last change on this file since 67954 was 62477, checked in by vboxsync, 8 years ago

(C) 2016

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.6 KB
Line 
1/* $Id: isofs.cpp 62477 2016-07-22 18:27:37Z vboxsync $ */
2/** @file
3 * IPRT - ISO 9660 file system handling.
4 */
5
6/*
7 * Copyright (C) 2010-2016 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 <iprt/isofs.h>
32
33#include <iprt/file.h>
34#include <iprt/err.h>
35#include <iprt/mem.h>
36#include <iprt/path.h>
37#include <iprt/string.h>
38
39
40/**
41 * Destroys the path cache.
42 *
43 * @param pFile ISO handle.
44 */
45static void rtIsoFsDestroyPathCache(PRTISOFSFILE pFile)
46{
47 PRTISOFSPATHTABLEENTRY pNode = RTListGetFirst(&pFile->listPaths, RTISOFSPATHTABLEENTRY, Node);
48 while (pNode)
49 {
50 PRTISOFSPATHTABLEENTRY pNext = RTListNodeGetNext(&pNode->Node, RTISOFSPATHTABLEENTRY, Node);
51 bool fLast = RTListNodeIsLast(&pFile->listPaths, &pNode->Node);
52
53 if (pNode->path)
54 RTStrFree(pNode->path);
55 if (pNode->path_full)
56 RTStrFree(pNode->path_full);
57 RTListNodeRemove(&pNode->Node);
58 RTMemFree(pNode);
59
60 if (fLast)
61 break;
62
63 pNode = pNext;
64 }
65}
66
67
68/**
69 * Adds a path entry to the path table list.
70 *
71 * @return IPRT status code.
72 * @param pList Path table list to add the path entry to.
73 * @param pszPath Path to add.
74 * @param pHeader Path header information to add.
75 */
76static int rtIsoFsAddToPathCache(PRTLISTNODE pList, const char *pszPath,
77 RTISOFSPATHTABLEHEADER *pHeader)
78{
79 AssertPtrReturn(pList, VERR_INVALID_PARAMETER);
80 AssertPtrReturn(pszPath, VERR_INVALID_PARAMETER);
81 AssertPtrReturn(pHeader, VERR_INVALID_PARAMETER);
82
83 PRTISOFSPATHTABLEENTRY pNode = (PRTISOFSPATHTABLEENTRY)RTMemAlloc(sizeof(RTISOFSPATHTABLEENTRY));
84 if (pNode == NULL)
85 return VERR_NO_MEMORY;
86
87 pNode->path = NULL;
88 if (RT_SUCCESS(RTStrAAppend(&pNode->path, pszPath)))
89 {
90 memcpy((RTISOFSPATHTABLEHEADER*)&pNode->header,
91 (RTISOFSPATHTABLEHEADER*)pHeader, sizeof(pNode->header));
92
93 pNode->path_full = NULL;
94 pNode->Node.pPrev = NULL;
95 pNode->Node.pNext = NULL;
96 RTListAppend(pList, &pNode->Node);
97 return VINF_SUCCESS;
98 }
99 return VERR_NO_MEMORY;
100}
101
102
103/**
104 * Retrieves the parent path of a given node, assuming that the path table
105 * (still) is in sync with the node's index.
106 *
107 * @return IPRT status code.
108 * @param pList Path table list to use.
109 * @param pNode Node of path table entry to lookup the full path for.
110 * @param pszPathNode Current (partial) parent path; needed for recursion.
111 * @param ppszPath Pointer to a pointer to store the retrieved full path to.
112 */
113static int rtIsoFsGetParentPathSub(PRTLISTNODE pList, PRTISOFSPATHTABLEENTRY pNode,
114 char *pszPathNode, char **ppszPath)
115{
116 int rc = VINF_SUCCESS;
117 /* Do we have a parent? */
118 if (pNode->header.parent_index > 1)
119 {
120 uint16_t idx = 1;
121 /* Get the parent of our current node (pNode) */
122 PRTISOFSPATHTABLEENTRY pNodeParent = RTListGetFirst(pList, RTISOFSPATHTABLEENTRY, Node);
123 while (idx++ < pNode->header.parent_index)
124 pNodeParent = RTListNodeGetNext(&pNodeParent->Node, RTISOFSPATHTABLEENTRY, Node);
125 /* Construct intermediate path (parent + current path). */
126 char *pszPath = RTPathJoinA(pNodeParent->path, pszPathNode);
127 if (pszPath)
128 {
129 /* ... and do the same with the parent's parent until we reached the root. */
130 rc = rtIsoFsGetParentPathSub(pList, pNodeParent, pszPath, ppszPath);
131 RTStrFree(pszPath);
132 }
133 else
134 rc = VERR_NO_STR_MEMORY;
135 }
136 else /* No parent (left), this must be the root path then. */
137 *ppszPath = RTStrDup(pszPathNode);
138 return rc;
139}
140
141
142/**
143 * Updates the path table cache of an ISO file.
144 *
145 * @return IPRT status code.
146 * @param pFile ISO handle.
147 */
148static int rtIsoFsUpdatePathCache(PRTISOFSFILE pFile)
149{
150 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
151 rtIsoFsDestroyPathCache(pFile);
152
153 RTListInit(&pFile->listPaths);
154
155 /* Seek to path tables. */
156 int rc = VINF_SUCCESS;
157 Assert(pFile->pvd.path_table_start_first > 16);
158 uint64_t uTableStart = (pFile->pvd.path_table_start_first * RTISOFS_SECTOR_SIZE);
159 Assert(uTableStart % RTISOFS_SECTOR_SIZE == 0); /* Make sure it's aligned. */
160 if (RTFileTell(pFile->file) != uTableStart)
161 rc = RTFileSeek(pFile->file, uTableStart, RTFILE_SEEK_BEGIN, &uTableStart);
162
163 /*
164 * Since this is a sequential format, for performance it's best to read the
165 * complete path table (every entry can have its own level (directory depth) first
166 * and the actual directories of the path table afterwards.
167 */
168
169 /* Read in the path table ... */
170 size_t cbLeft = pFile->pvd.path_table_size;
171 RTISOFSPATHTABLEHEADER header;
172 while ((cbLeft > 0) && RT_SUCCESS(rc))
173 {
174 size_t cbRead;
175 rc = RTFileRead(pFile->file, (RTISOFSPATHTABLEHEADER*)&header, sizeof(RTISOFSPATHTABLEHEADER), &cbRead);
176 if (RT_FAILURE(rc))
177 break;
178 cbLeft -= cbRead;
179 if (header.length)
180 {
181 Assert(cbLeft >= header.length);
182 Assert(header.length <= 31);
183 /* Allocate and read in the actual path name. */
184 char *pszName = RTStrAlloc(header.length + 1);
185 rc = RTFileRead(pFile->file, (char*)pszName, header.length, &cbRead);
186 if (RT_SUCCESS(rc))
187 {
188 cbLeft -= cbRead;
189 pszName[cbRead] = '\0'; /* Terminate string. */
190 /* Add entry to cache ... */
191 rc = rtIsoFsAddToPathCache(&pFile->listPaths, pszName, &header);
192 }
193 RTStrFree(pszName);
194 /* Read padding if required ... */
195 if ((header.length % 2) != 0) /* If we have an odd length, read/skip the padding byte. */
196 {
197 rc = RTFileSeek(pFile->file, 1, RTFILE_SEEK_CURRENT, NULL);
198 cbLeft--;
199 }
200 }
201 }
202
203 /* Transform path names into full paths. This is a bit ugly right now. */
204 PRTISOFSPATHTABLEENTRY pNode = RTListGetLast(&pFile->listPaths, RTISOFSPATHTABLEENTRY, Node);
205 while ( pNode
206 && !RTListNodeIsFirst(&pFile->listPaths, &pNode->Node)
207 && RT_SUCCESS(rc))
208 {
209 rc = rtIsoFsGetParentPathSub(&pFile->listPaths, pNode,
210 pNode->path, &pNode->path_full);
211 if (RT_SUCCESS(rc))
212 pNode = RTListNodeGetPrev(&pNode->Node, RTISOFSPATHTABLEENTRY, Node);
213 }
214
215 return rc;
216}
217
218
219RTR3DECL(int) RTIsoFsOpen(PRTISOFSFILE pFile, const char *pszFileName)
220{
221 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
222 AssertPtrReturn(pszFileName, VERR_INVALID_PARAMETER);
223
224 RTListInit(&pFile->listPaths);
225#if 0
226 Assert(sizeof(RTISOFSDATESHORT) == 7);
227 Assert(sizeof(RTISOFSDATELONG) == 17);
228 int l = sizeof(RTISOFSDIRRECORD);
229 RTPrintf("RTISOFSDIRRECORD=%ld\n", l);
230 Assert(l == 33);
231 /* Each volume descriptor exactly occupies one sector. */
232 l = sizeof(RTISOFSPRIVOLDESC);
233 RTPrintf("RTISOFSPRIVOLDESC=%ld\n", l);
234 Assert(l == RTISOFS_SECTOR_SIZE);
235#endif
236 int rc = RTFileOpen(&pFile->file, pszFileName, RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_WRITE);
237 if (RT_SUCCESS(rc))
238 {
239 uint64_t cbSize;
240 rc = RTFileGetSize(pFile->file, &cbSize);
241 if ( RT_SUCCESS(rc)
242 && cbSize > 16 * RTISOFS_SECTOR_SIZE)
243 {
244 uint64_t cbOffset = 16 * RTISOFS_SECTOR_SIZE; /* Start reading at 32k. */
245 size_t cbRead;
246 RTISOFSPRIVOLDESC pvd;
247 bool fFoundPrimary = false;
248 bool fIsValid = false;
249 while (cbOffset < _1M)
250 {
251 /* Get primary descriptor. */
252 rc = RTFileRead(pFile->file, (PRTISOFSPRIVOLDESC)&pvd, sizeof(RTISOFSPRIVOLDESC), &cbRead);
253 if (RT_FAILURE(rc) || cbRead < sizeof(RTISOFSPRIVOLDESC))
254 break;
255 if ( RTStrStr((char*)pvd.name_id, RTISOFS_STANDARD_ID)
256 && pvd.type == 0x1 /* Primary Volume Descriptor */)
257 {
258 memcpy((PRTISOFSPRIVOLDESC)&pFile->pvd,
259 (PRTISOFSPRIVOLDESC)&pvd, sizeof(RTISOFSPRIVOLDESC));
260 fFoundPrimary = true;
261 }
262 else if(pvd.type == 0xff /* Termination Volume Descriptor */)
263 {
264 if (fFoundPrimary)
265 fIsValid = true;
266 break;
267 }
268 cbOffset += sizeof(RTISOFSPRIVOLDESC);
269 }
270
271 if (fIsValid)
272 rc = rtIsoFsUpdatePathCache(pFile);
273 else
274 rc = VERR_INVALID_PARAMETER;
275 }
276 if (RT_FAILURE(rc))
277 RTIsoFsClose(pFile);
278 }
279 return rc;
280}
281
282
283RTR3DECL(void) RTIsoFsClose(PRTISOFSFILE pFile)
284{
285 if (pFile)
286 {
287 rtIsoFsDestroyPathCache(pFile);
288 RTFileClose(pFile->file);
289 }
290}
291
292
293/**
294 * Parses an extent given at the specified sector + size and
295 * searches for a file name to return an allocated directory record.
296 *
297 * @return IPRT status code.
298 * @param pFile ISO handle.
299 * @param pszFileName Absolute file name to search for.
300 * @param uExtentSector Sector of extent.
301 * @param cbExtent Size (in bytes) of extent.
302 * @param ppRec Pointer to a pointer to return the
303 * directory record. Must be free'd with
304 * rtIsoFsFreeDirectoryRecord().
305 */
306static int rtIsoFsFindEntry(PRTISOFSFILE pFile, const char *pszFileName,
307 uint32_t uExtentSector, uint32_t cbExtent /* Bytes */,
308 PRTISOFSDIRRECORD *ppRec)
309{
310 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
311 Assert(uExtentSector > 16);
312
313 int rc = RTFileSeek(pFile->file, uExtentSector * RTISOFS_SECTOR_SIZE,
314 RTFILE_SEEK_BEGIN, NULL);
315 if (RT_SUCCESS(rc))
316 {
317 rc = VERR_FILE_NOT_FOUND;
318
319 uint8_t abBuffer[RTISOFS_SECTOR_SIZE];
320 size_t cbLeft = cbExtent;
321 while (!RT_SUCCESS(rc) && cbLeft > 0)
322 {
323 size_t cbRead = 0;
324 int rc2 = RTFileRead(pFile->file, &abBuffer[0], sizeof(abBuffer), &cbRead);
325 AssertRC(rc2);
326 Assert(cbRead == RTISOFS_SECTOR_SIZE);
327 cbLeft -= cbRead;
328
329 uint32_t idx = 0;
330 while (idx < cbRead)
331 {
332 PRTISOFSDIRRECORD pCurRecord = (PRTISOFSDIRRECORD)&abBuffer[idx];
333 if (pCurRecord->record_length == 0)
334 break;
335
336 char *pszName = RTStrAlloc(pCurRecord->name_len + 1);
337 if (RT_UNLIKELY(!pszName))
338 {
339 rc = VERR_NO_STR_MEMORY;
340 break;
341 }
342
343 Assert(idx + sizeof(RTISOFSDIRRECORD) < cbRead);
344 memcpy(pszName, &abBuffer[idx + sizeof(RTISOFSDIRRECORD)], pCurRecord->name_len);
345 pszName[pCurRecord->name_len] = '\0'; /* Force string termination. */
346
347 if ( pCurRecord->name_len == 1
348 && pszName[0] == 0x0)
349 {
350 /* This is a "." directory (self). */
351 }
352 else if ( pCurRecord->name_len == 1
353 && pszName[0] == 0x1)
354 {
355 /* This is a ".." directory (parent). */
356 }
357 else /* Regular directory or file */
358 {
359 if (pCurRecord->flags & RT_BIT(1)) /* Directory */
360 {
361 /* We don't recursively go into directories
362 * because we already have the cached path table. */
363 pszName[pCurRecord->name_len] = 0;
364 /*rc = rtIsoFsParseDir(pFile, pszFileName,
365 pDirHdr->extent_location, pDirHdr->extent_data_length);*/
366 }
367 else /* File */
368 {
369 /* Get last occurrence of ";" and cut it off. */
370 char *pTerm = strrchr(pszName, ';');
371 if (pTerm)
372 pszName[pTerm - pszName] = 0;
373
374 /* Don't use case sensitive comparison here, in IS0 9660 all
375 * file / directory names are UPPERCASE. */
376 if (!RTStrICmp(pszName, pszFileName))
377 {
378 PRTISOFSDIRRECORD pRec = (PRTISOFSDIRRECORD)RTMemAlloc(sizeof(RTISOFSDIRRECORD));
379 if (pRec)
380 {
381 memcpy(pRec, pCurRecord, sizeof(RTISOFSDIRRECORD));
382 *ppRec = pRec;
383 rc = VINF_SUCCESS;
384 }
385 else
386 rc = VERR_NO_MEMORY;
387 break;
388 }
389 }
390 }
391 idx += pCurRecord->record_length;
392 RTStrFree(pszName);
393 }
394 }
395 }
396 return rc;
397}
398
399
400/**
401 * Retrieves the sector of a file extent given by the
402 * full file path within the ISO.
403 *
404 * @return IPRT status code.
405 * @param pFile ISO handle.
406 * @param pszPath File path to resolve.
407 * @param puSector Pointer where to store the found sector to.
408 */
409static int rtIsoFsResolvePath(PRTISOFSFILE pFile, const char *pszPath, uint32_t *puSector)
410{
411 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
412 AssertPtrReturn(pszPath, VERR_INVALID_PARAMETER);
413 AssertPtrReturn(puSector, VERR_INVALID_PARAMETER);
414
415 int rc = VERR_FILE_NOT_FOUND;
416 char *pszTemp = RTStrDup(pszPath);
417 if (pszTemp)
418 {
419 RTPathStripFilename(pszTemp);
420
421 bool bFound = false;
422 PRTISOFSPATHTABLEENTRY pNode;
423 if (!RTStrCmp(pszTemp, ".")) /* Root directory? Use first node! */
424 {
425 pNode = RTListGetFirst(&pFile->listPaths, RTISOFSPATHTABLEENTRY, Node);
426 if (pNode)
427 bFound = true;
428 }
429 else
430 {
431 RTListForEach(&pFile->listPaths, pNode, RTISOFSPATHTABLEENTRY, Node)
432 {
433 if ( pNode->path_full != NULL /* Root does not have a path! */
434 && !RTStrICmp(pNode->path_full, pszTemp))
435 {
436 bFound = true;
437 break;
438 }
439 }
440 }
441 if (bFound)
442 {
443 AssertPtr(pNode);
444 *puSector = pNode->header.sector_dir_table;
445 rc = VINF_SUCCESS;
446 }
447 else
448 rc = VERR_FILE_NOT_FOUND;
449 RTStrFree(pszTemp);
450 }
451 else
452 rc = VERR_NO_MEMORY;
453 return rc;
454}
455
456
457/**
458 * Allocates a new directory record.
459 *
460 * @return Pointer to the newly allocated directory record.
461 */
462static PRTISOFSDIRRECORD rtIsoFsCreateDirectoryRecord(void)
463{
464 PRTISOFSDIRRECORD pRecord = (PRTISOFSDIRRECORD)RTMemAlloc(sizeof(RTISOFSDIRRECORD));
465 return pRecord;
466}
467
468
469/**
470 * Frees a previously allocated directory record.
471 *
472 * @return IPRT status code.
473 */
474static void rtIsoFsFreeDirectoryRecord(PRTISOFSDIRRECORD pRecord)
475{
476 RTMemFree(pRecord);
477}
478
479
480/**
481 * Returns an allocated directory record for a given file.
482 *
483 * @return IPRT status code.
484 * @param pFile ISO handle.
485 * @param pszPath File path to resolve.
486 * @param ppRecord Pointer to a pointer to return the
487 * directory record. Must be free'd with
488 * rtIsoFsFreeDirectoryRecord().
489 */
490static int rtIsoFsGetDirectoryRecord(PRTISOFSFILE pFile, const char *pszPath,
491 PRTISOFSDIRRECORD *ppRecord)
492{
493 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
494 AssertPtrReturn(pszPath, VERR_INVALID_PARAMETER);
495 AssertPtrReturn(ppRecord, VERR_INVALID_PARAMETER);
496
497 uint32_t uSector;
498 int rc = rtIsoFsResolvePath(pFile, pszPath, &uSector);
499 if (RT_SUCCESS(rc))
500 {
501 /* Seek and read the directory record of given file. */
502 rc = RTFileSeek(pFile->file, uSector * RTISOFS_SECTOR_SIZE,
503 RTFILE_SEEK_BEGIN, NULL);
504 if (RT_SUCCESS(rc))
505 {
506 size_t cbRead;
507 PRTISOFSDIRRECORD pRecord = rtIsoFsCreateDirectoryRecord();
508 if (pRecord)
509 {
510 rc = RTFileRead(pFile->file, (PRTISOFSDIRRECORD)pRecord, sizeof(RTISOFSDIRRECORD), &cbRead);
511 if (RT_SUCCESS(rc))
512 {
513 Assert(cbRead == sizeof(RTISOFSDIRRECORD));
514 *ppRecord = pRecord;
515 }
516 if (RT_FAILURE(rc))
517 rtIsoFsFreeDirectoryRecord(pRecord);
518 }
519 else
520 rc = VERR_NO_MEMORY;
521 }
522 }
523 return rc;
524}
525
526
527RTR3DECL(int) RTIsoFsGetFileInfo(PRTISOFSFILE pFile, const char *pszPath, uint32_t *poffInIso, size_t *pcbLength)
528{
529 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
530 AssertPtrReturn(pszPath, VERR_INVALID_PARAMETER);
531 AssertPtrReturn(poffInIso, VERR_INVALID_PARAMETER);
532
533 PRTISOFSDIRRECORD pDirRecord;
534 int rc = rtIsoFsGetDirectoryRecord(pFile, pszPath, &pDirRecord);
535 if (RT_SUCCESS(rc))
536 {
537 /* Get actual file record. */
538 PRTISOFSDIRRECORD pFileRecord = NULL; /* shut up gcc*/
539 rc = rtIsoFsFindEntry(pFile,
540 RTPathFilename(pszPath),
541 pDirRecord->extent_location,
542 pDirRecord->extent_data_length,
543 &pFileRecord);
544 if (RT_SUCCESS(rc))
545 {
546 *poffInIso = pFileRecord->extent_location * RTISOFS_SECTOR_SIZE;
547 *pcbLength = pFileRecord->extent_data_length;
548 rtIsoFsFreeDirectoryRecord(pFileRecord);
549 }
550 rtIsoFsFreeDirectoryRecord(pDirRecord);
551 }
552 return rc;
553}
554
555
556RTR3DECL(int) RTIsoFsExtractFile(PRTISOFSFILE pFile, const char *pszSrcPath, const char *pszDstPath)
557{
558 AssertPtrReturn(pFile, VERR_INVALID_PARAMETER);
559 AssertPtrReturn(pszSrcPath, VERR_INVALID_PARAMETER);
560 AssertPtrReturn(pszDstPath, VERR_INVALID_PARAMETER);
561
562 uint32_t cbOffset;
563 size_t cbLength;
564 int rc = RTIsoFsGetFileInfo(pFile, pszSrcPath, &cbOffset, &cbLength);
565 if (RT_SUCCESS(rc))
566 {
567 rc = RTFileSeek(pFile->file, cbOffset, RTFILE_SEEK_BEGIN, NULL);
568 if (RT_SUCCESS(rc))
569 {
570 RTFILE fileDest;
571 rc = RTFileOpen(&fileDest, pszDstPath, RTFILE_O_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE);
572 if (RT_SUCCESS(rc))
573 {
574 size_t cbToRead, cbRead, cbWritten;
575 uint8_t byBuffer[_64K];
576 while ( cbLength > 0
577 && RT_SUCCESS(rc))
578 {
579 cbToRead = RT_MIN(cbLength, _64K);
580 rc = RTFileRead(pFile->file, (uint8_t*)byBuffer, cbToRead, &cbRead);
581 if (RT_FAILURE(rc))
582 break;
583 rc = RTFileWrite(fileDest, (uint8_t*)byBuffer, cbRead, &cbWritten);
584 if (RT_FAILURE(rc))
585 break;
586 cbLength -= cbRead;
587 }
588 RTFileClose(fileDest);
589 }
590 }
591 }
592 return rc;
593}
594
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