diff options
Diffstat (limited to 'src/VBox/Runtime/common/fs')
| -rw-r--r-- | src/VBox/Runtime/common/fs/Makefile.kup | 0 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/RTFsCmdLs.cpp | 1836 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/extvfs.cpp | 2853 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/fatvfs.cpp | 6345 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/isomaker.cpp | 7438 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/isomakercmd-man.xml | 569 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/isomakercmd.cpp | 3594 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/isomakerimport.cpp | 2720 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/isovfs.cpp | 5992 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/ntfsvfs.cpp | 5683 | ||||
| -rw-r--r-- | src/VBox/Runtime/common/fs/xfsvfs.cpp | 2240 |
11 files changed, 39270 insertions, 0 deletions
diff --git a/src/VBox/Runtime/common/fs/Makefile.kup b/src/VBox/Runtime/common/fs/Makefile.kup new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/src/VBox/Runtime/common/fs/Makefile.kup diff --git a/src/VBox/Runtime/common/fs/RTFsCmdLs.cpp b/src/VBox/Runtime/common/fs/RTFsCmdLs.cpp new file mode 100644 index 00000000..1eb8e122 --- /dev/null +++ b/src/VBox/Runtime/common/fs/RTFsCmdLs.cpp @@ -0,0 +1,1836 @@ +/* $Id: RTFsCmdLs.cpp $ */ +/** @file + * IPRT - /bin/ls like utility for testing the VFS code. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#include <iprt/vfs.h> + +#include <iprt/buildconfig.h> +#include <iprt/err.h> +#include <iprt/file.h> +#include <iprt/getopt.h> +#include <iprt/initterm.h> +#include <iprt/mem.h> +#include <iprt/message.h> +#include <iprt/param.h> +#include <iprt/path.h> +#include <iprt/sort.h> +#include <iprt/stream.h> +#include <iprt/string.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Display entry. + */ +typedef struct RTCMDLSENTRY +{ + /** The information about the entry. */ + RTFSOBJINFO Info; + /** Symbolic link target (allocated after the name). */ + const char *pszTarget; + /** Owner if applicable(allocated after the name). */ + const char *pszOwner; + /** Group if applicable (allocated after the name). */ + const char *pszGroup; + /** The length of szName. */ + size_t cchName; + /** The entry name. */ + char szName[RT_FLEXIBLE_ARRAY]; +} RTCMDLSENTRY; +/** Pointer to a ls display entry. */ +typedef RTCMDLSENTRY *PRTCMDLSENTRY; +/** Pointer to a ls display entry pointer. */ +typedef PRTCMDLSENTRY *PPRTCMDLSENTRY; + + +/** + * Collection of display entries. + */ +typedef struct RTCMDLSCOLLECTION +{ + /** Current size of papEntries. */ + size_t cEntries; + /** Memory allocated for papEntries. */ + size_t cEntriesAllocated; + /** Current entries pending sorting and display. */ + PPRTCMDLSENTRY papEntries; + + /** Total number of bytes allocated for the above entries. */ + uint64_t cbTotalAllocated; + /** Total number of file content bytes. */ + uint64_t cbTotalFiles; + + /** The collection name (path). */ + char szName[RT_FLEXIBLE_ARRAY]; +} RTCMDLSCOLLECTION; +/** Pointer to a display entry collection. */ +typedef RTCMDLSCOLLECTION *PRTCMDLSCOLLECTION; +/** Pointer to a display entry collection pointer. */ +typedef PRTCMDLSCOLLECTION *PPRTCMDLSCOLLECTION; + + +/** Sorting. */ +typedef enum RTCMDLSSORT +{ + RTCMDLSSORT_INVALID = 0, + RTCMDLSSORT_NONE, + RTCMDLSSORT_NAME, + RTCMDLSSORT_EXTENSION, + RTCMDLSSORT_SIZE, + RTCMDLSSORT_TIME, + RTCMDLSSORT_VERSION +} RTCMDLSSORT; + +/** Time selection. */ +typedef enum RTCMDLSTIME +{ + RTCMDLSTIME_INVALID = 0, + RTCMDLSTIME_BTIME, + RTCMDLSTIME_CTIME, + RTCMDLSTIME_MTIME, + RTCMDLSTIME_ATIME +} RTCMDLSTIME; + +/** Time display style. */ +typedef enum RTCMDLSTIMESTYLE +{ + RTCMDLSTIMESTYLE_INVALID = 0, + RTCMDLSTIMESTYLE_FULL_ISO, + RTCMDLSTIMESTYLE_LONG_ISO, + RTCMDLSTIMESTYLE_ISO, + RTCMDLSTIMESTYLE_LOCALE, + RTCMDLSTIMESTYLE_CUSTOM +} RTCMDLSTIMESTYLE; + +/** Coloring selection. */ +typedef enum RTCMDLSCOLOR +{ + RTCMDLSCOLOR_INVALID = 0, + RTCMDLSCOLOR_NONE +} RTCMDLSCOLOR; + +/** Formatting. */ +typedef enum RTCMDLSFORMAT +{ + RTCMDLSFORMAT_INVALID = 0, + RTCMDLSFORMAT_COLS_VERTICAL, /**< -C/default */ + RTCMDLSFORMAT_COLS_HORIZONTAL, /**< -x */ + RTCMDLSFORMAT_COMMAS, /**< -m */ + RTCMDLSFORMAT_SINGLE, /**< -1 */ + RTCMDLSFORMAT_LONG, /**< -l */ + RTCMDLSFORMAT_MACHINE_READABLE /**< --machine-readable */ +} RTCMDLSFORMAT; + + +/** + * LS command options and state. + */ +typedef struct RTCMDLSOPTS +{ + /** @name Traversal. + * @{ */ + bool fFollowSymlinksInDirs; /**< -L */ + bool fFollowSymlinkToAnyArgs; + bool fFollowSymlinkToDirArgs; + bool fFollowDirectoryArgs; /**< Inverse -d/--directory. */ + bool fRecursive; /**< -R */ + /** @} */ + + + /** @name Filtering. + * @{ */ + bool fShowHidden; /**< -a/--all or -A/--almost-all */ + bool fShowDotAndDotDot; /**< -a vs -A */ + bool fShowBackups; /**< Inverse -B/--ignore-backups (*~). */ + /** @} */ + + /** @name Sorting + * @{ */ + RTCMDLSSORT enmSort; /**< --sort */ + bool fReverseSort; /**< -r */ + bool fGroupDirectoriesFirst; /**< fGroupDirectoriesFirst */ + /** @} */ + + /** @name Formatting + * @{ */ + RTCMDLSFORMAT enmFormat; /**< --format */ + + bool fEscapeNonGraphicChars; /**< -b, --escape */ + bool fEscapeControlChars; + bool fHideControlChars; /**< -q/--hide-control-chars, --show-control-chars */ + + bool fHumanReadableSizes; /**< -h */ + bool fSiUnits; /**< --si */ + uint32_t cbBlock; /**< --block-size=N, -k */ + + bool fShowOwner; + bool fShowGroup; + bool fNumericalIds; /**< -n */ + bool fShowINode; + bool fShowAllocatedSize; /**< -s */ + uint8_t cchTab; /**< -T */ + uint32_t cchWidth; /**< -w */ + + RTCMDLSCOLOR enmColor; /**< --color */ + + RTCMDLSTIME enmTime; /**< --time */ + RTCMDLSTIMESTYLE enmTimeStyle; /**< --time-style, --full-time */ + const char *pszTimeCustom; /**< --time-style=+xxx */ + /** @} */ + + /** @name State + * @{ */ + /** Current size of papCollections. */ + size_t cCollections; + /** Memory allocated for papCollections. */ + size_t cCollectionsAllocated; + /** Current entry collection pending display, the last may also be pending + * sorting. */ + PPRTCMDLSCOLLECTION papCollections; + /** @} */ +} RTCMDLSOPTS; +/** Pointer to ls options and state. */ +typedef RTCMDLSOPTS *PRTCMDLSOPTS; + + + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Unsorted} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstUnsorted(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + return !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); +} + + +/** @callback_method_impl{FNRTSORTCMP, Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpName(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + return RTStrCmp(pEntry1->szName, pEntry2->szName); +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstName(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, extension} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpExtension(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = RTStrCmp(RTPathSuffix(pEntry1->szName), RTPathSuffix(pEntry2->szName)); + if (!iDiff) + iDiff = RTStrCmp(pEntry1->szName, pEntry2->szName); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Ext + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstExtension(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpExtension(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Allocated size + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpAllocated(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + if (pEntry1->Info.cbAllocated == pEntry2->Info.cbAllocated) + return rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return pEntry1->Info.cbAllocated < pEntry2->Info.cbAllocated ? -1 : 1; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Allocated size + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstAllocated(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpAllocated(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Content size + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpSize(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + if (pEntry1->Info.cbObject == pEntry2->Info.cbObject) + return rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return pEntry1->Info.cbObject < pEntry2->Info.cbObject ? -1 : 1; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Content size + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstSize(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpSize(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Modification time + name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpMTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = RTTimeSpecCompare(&pEntry1->Info.ModificationTime, &pEntry2->Info.ModificationTime); + if (!iDiff) + iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Modification time + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstMTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpMTime(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Birth time + name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpBTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = RTTimeSpecCompare(&pEntry1->Info.BirthTime, &pEntry2->Info.BirthTime); + if (!iDiff) + iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Birth time + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstBTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpBTime(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Change time + name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpCTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = RTTimeSpecCompare(&pEntry1->Info.ChangeTime, &pEntry2->Info.ChangeTime); + if (!iDiff) + iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Change time + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstCTime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpCTime(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Accessed time + name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpATime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = RTTimeSpecCompare(&pEntry1->Info.AccessTime, &pEntry2->Info.AccessTime); + if (!iDiff) + iDiff = rtCmdLsEntryCmpName(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Accessed time + Name} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstATime(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpATime(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** @callback_method_impl{FNRTSORTCMP, Name as version} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpVersion(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + return RTStrVersionCompare(pEntry1->szName, pEntry2->szName); +} + + +/** @callback_method_impl{FNRTSORTCMP, Dirs first + Name as version} */ +static DECLCALLBACK(int) rtCmdLsEntryCmpDirFirstVersion(void const *pvElement1, void const *pvElement2, void *pvUser) +{ + RT_NOREF(pvUser); + PRTCMDLSENTRY pEntry1 = (PRTCMDLSENTRY)pvElement1; + PRTCMDLSENTRY pEntry2 = (PRTCMDLSENTRY)pvElement2; + int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode); + if (!iDiff) + iDiff = rtCmdLsEntryCmpVersion(pEntry1, pEntry2, pvUser); + return iDiff; +} + + +/** + * Sorts the entries in the collections according the sorting options. + * + * @param pOpts The options and state. + */ +static void rtCmdLsSortCollections(PRTCMDLSOPTS pOpts) +{ + /* + * Sort the entries in each collection. + */ + PFNRTSORTCMP pfnCmp; + switch (pOpts->enmSort) + { + case RTCMDLSSORT_NONE: + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstUnsorted : NULL; + break; + default: AssertFailed(); RT_FALL_THRU(); + case RTCMDLSSORT_NAME: + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstName : rtCmdLsEntryCmpName; + break; + case RTCMDLSSORT_EXTENSION: + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstExtension : rtCmdLsEntryCmpExtension; + break; + case RTCMDLSSORT_SIZE: + if (pOpts->fShowAllocatedSize) + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstAllocated : rtCmdLsEntryCmpAllocated; + else + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstSize : rtCmdLsEntryCmpSize; + break; + case RTCMDLSSORT_TIME: + switch (pOpts->enmTime) + { + default: AssertFailed(); RT_FALL_THRU(); + case RTCMDLSTIME_MTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstMTime : rtCmdLsEntryCmpMTime; break; + case RTCMDLSTIME_BTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstBTime : rtCmdLsEntryCmpBTime; break; + case RTCMDLSTIME_CTIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstCTime : rtCmdLsEntryCmpCTime; break; + case RTCMDLSTIME_ATIME: pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstATime : rtCmdLsEntryCmpATime; break; + } + break; + case RTCMDLSSORT_VERSION: + pfnCmp = pOpts->fGroupDirectoriesFirst ? rtCmdLsEntryCmpDirFirstVersion : rtCmdLsEntryCmpVersion; + break; + } + if (pfnCmp) + { + /* + * Walk thru the collections and sort their entries. + */ + size_t i = pOpts->cCollections; + while (i-- > 0) + { + PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[i]; + RTSortApvShell((void **)pCollection->papEntries, pCollection->cEntries, pfnCmp, NULL); + + if (pOpts->fReverseSort) + { + PPRTCMDLSENTRY papEntries = pCollection->papEntries; + size_t iHead = 0; + size_t iTail = pCollection->cEntries; + while (iHead < iTail) + { + PRTCMDLSENTRY pTmp = papEntries[iHead]; + papEntries[iHead] = papEntries[iTail]; + papEntries[iTail] = pTmp; + iHead++; + iTail--; + } + } + } + } + + /** @todo sort the collections too, except for the first one. */ +} + + +/** + * Format human readable size. + */ +static const char *rtCmdLsFormatSizeHumanReadable(PRTCMDLSOPTS pOpts, uint64_t cb, char *pszDst, size_t cbDst) +{ + if (pOpts->fHumanReadableSizes) + { + if (!pOpts->fSiUnits) + { + size_t cch = RTStrPrintf(pszDst, cbDst, "%Rhub", cb); + if (pszDst[cch - 1] == 'i') + pszDst[cch - 1] = '\0'; /* drop the trailing 'i' */ + } + else + RTStrPrintf(pszDst, cbDst, "%Rhui", cb); + } + else if (pOpts->cbBlock) + RTStrFormatU64(pszDst, cbDst, (cb + pOpts->cbBlock - 1) / pOpts->cbBlock, 10, 0, 0, 0); + else + RTStrFormatU64(pszDst, cbDst, cb, 10, 0, 0, 0); + return pszDst; +} + + +/** + * Format block count. + */ +static const char *rtCmdLsFormatBlocks(PRTCMDLSOPTS pOpts, uint64_t cb, char *pszDst, size_t cbDst) +{ + if (pOpts->fHumanReadableSizes) + return rtCmdLsFormatSizeHumanReadable(pOpts, cb, pszDst, cbDst); + + uint32_t cbBlock = pOpts->cbBlock; + if (cbBlock == 0) + cbBlock = _1K; + RTStrFormatU64(pszDst, cbDst, (cb + cbBlock / 2 - 1) / cbBlock, 10, 0, 0, 0); + return pszDst; +} + + +/** + * Format file size. + */ +static const char *rtCmdLsFormatSize(PRTCMDLSOPTS pOpts, uint64_t cb, char *pszDst, size_t cbDst) +{ + if (pOpts->fHumanReadableSizes) + return rtCmdLsFormatSizeHumanReadable(pOpts, cb, pszDst, cbDst); + if (pOpts->cbBlock > 0) + return rtCmdLsFormatBlocks(pOpts, cb, pszDst, cbDst); + RTStrFormatU64(pszDst, cbDst, cb, 10, 0, 0, 0); + return pszDst; +} + + +/** + * Format name, i.e. escape, hide, quote stuff. + */ +static const char *rtCmdLsFormatName(PRTCMDLSOPTS pOpts, const char *pszName, char *pszDst, size_t cbDst) +{ + if ( !pOpts->fEscapeNonGraphicChars + && !pOpts->fEscapeControlChars + && !pOpts->fHideControlChars) + return pszName; + /** @todo implement name formatting. */ + RT_NOREF(pszDst, cbDst); + return pszName; +} + + +/** + * Figures out the length for a 32-bit number when formatted as decimal. + * @returns Number of digits. + * @param uValue The number. + */ +DECLINLINE(size_t) rtCmdLsDecimalFormatLengthU32(uint32_t uValue) +{ + if (uValue < 10) + return 1; + if (uValue < 100) + return 2; + if (uValue < 1000) + return 3; + if (uValue < 10000) + return 4; + if (uValue < 100000) + return 5; + if (uValue < 1000000) + return 6; + if (uValue < 10000000) + return 7; + if (uValue < 100000000) + return 8; + if (uValue < 1000000000) + return 9; + return 10; +} + + +/** + * Formats the given group ID according to the specified options. + * + * @returns pszDst + * @param pOpts The options and state. + * @param gid The GID to format. + * @param pszOwner The owner returned by the FS. + * @param pszDst The output buffer. + * @param cbDst The output buffer size. + */ +static const char *rtCmdLsDecimalFormatGroup(PRTCMDLSOPTS pOpts, RTGID gid, const char *pszGroup, char *pszDst, size_t cbDst) +{ + if (!pOpts->fNumericalIds) + { + if (pszGroup) + { + RTStrCopy(pszDst, cbDst, pszGroup); + return pszDst; + } + if (gid == NIL_RTGID) + return "<Nil>"; + } + RTStrFormatU64(pszDst, cbDst, gid, 10, 0, 0, 0); + return pszDst; +} + + +/** + * Formats the given user ID according to the specified options. + * + * @returns pszDst + * @param pOpts The options and state. + * @param uid The UID to format. + * @param pszOwner The owner returned by the FS. + * @param pszDst The output buffer. + * @param cbDst The output buffer size. + */ +static const char *rtCmdLsDecimalFormatOwner(PRTCMDLSOPTS pOpts, RTUID uid, const char *pszOwner, char *pszDst, size_t cbDst) +{ + if (!pOpts->fNumericalIds) + { + if (pszOwner) + { + RTStrCopy(pszDst, cbDst, pszOwner); + return pszDst; + } + if (uid == NIL_RTUID) + return "<Nil>"; + } + RTStrFormatU64(pszDst, cbDst, uid, 10, 0, 0, 0); + return pszDst; +} + + +/** + * Formats the given timestamp according to the desired --time-style. + * + * @returns pszDst + * @param pOpts The options and state. + * @param pTimestamp The timestamp. + * @param pszDst The output buffer. + * @param cbDst The output buffer size. + */ +static const char *rtCmdLsFormatTimestamp(PRTCMDLSOPTS pOpts, PCRTTIMESPEC pTimestamp, char *pszDst, size_t cbDst) +{ + /** @todo timestamp formatting according to the given style. */ + RT_NOREF(pOpts); + return RTTimeSpecToString(pTimestamp, pszDst, cbDst); +} + + + +/** + * RTCMDLSFORMAT_MACHINE_READABLE: --machine-readable + */ +static RTEXITCODE rtCmdLsDisplayCollectionInMachineReadableFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection, + char *pszTmp, size_t cbTmp) +{ + RT_NOREF(pOpts, pCollection, pszTmp, cbTmp); + RTMsgError("Machine readable format not implemented\n"); + return RTEXITCODE_FAILURE; +} + + +/** + * RTCMDLSFORMAT_COMMAS: -m + */ +static RTEXITCODE rtCmdLsDisplayCollectionInCvsFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection, + char *pszTmp, size_t cbTmp) +{ + RT_NOREF(pOpts, pCollection, pszTmp, cbTmp); + RTMsgError("Table output formats not implemented\n"); + return RTEXITCODE_FAILURE; +} + + +/** + * RTCMDLSFORMAT_LONG: -l + */ +static RTEXITCODE rtCmdLsDisplayCollectionInLongFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection, + char *pszTmp, size_t cbTmp, size_t cchAllocatedCol) +{ + /* + * Figure the width of the size, the link count, the uid, the gid, and the inode columns. + */ + size_t cchSizeCol = 1; + size_t cchLinkCol = 1; + size_t cchUidCol = pOpts->fShowOwner ? 1 : 0; + size_t cchGidCol = pOpts->fShowGroup ? 1 : 0; + size_t cchINodeCol = pOpts->fShowINode ? 1 : 0; + + size_t i = pCollection->cEntries; + while (i-- > 0) + { + PRTCMDLSENTRY pEntry = pCollection->papEntries[i]; + + rtCmdLsFormatSize(pOpts, pEntry->Info.cbObject, pszTmp, cbTmp); + size_t cchTmp = strlen(pszTmp); + if (cchTmp > cchSizeCol) + cchSizeCol = cchTmp; + + cchTmp = rtCmdLsDecimalFormatLengthU32(pEntry->Info.Attr.u.Unix.cHardlinks) + 1; + if (cchTmp > cchLinkCol) + cchLinkCol = cchTmp; + + if (pOpts->fShowOwner) + { + rtCmdLsDecimalFormatOwner(pOpts, pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp); + cchTmp = strlen(pszTmp); + if (cchTmp > cchUidCol) + cchUidCol = cchTmp; + } + + if (pOpts->fShowGroup) + { + rtCmdLsDecimalFormatGroup(pOpts, pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp); + cchTmp = strlen(pszTmp); + if (cchTmp > cchGidCol) + cchGidCol = cchTmp; + } + + if (pOpts->fShowINode) + { + cchTmp = RTStrFormatU64(pszTmp, cchTmp, pEntry->Info.Attr.u.Unix.INodeId, 10, 0, 0, 0); + if (cchTmp > cchINodeCol) + cchINodeCol = cchTmp; + } + } + + /* + * Determin time member offset. + */ + size_t offTime; + switch (pOpts->enmTime) + { + default: AssertFailed(); RT_FALL_THRU(); + case RTCMDLSTIME_MTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ModificationTime); break; + case RTCMDLSTIME_BTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.BirthTime); break; + case RTCMDLSTIME_CTIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.ChangeTime); break; + case RTCMDLSTIME_ATIME: offTime = RT_UOFFSETOF(RTCMDLSENTRY, Info.AccessTime); break; + } + + /* + * Display the entries. + */ + for (i = 0; i < pCollection->cEntries; i++) + { + PRTCMDLSENTRY pEntry = pCollection->papEntries[i]; + + if (cchINodeCol) + RTPrintf("%*RU64 ", cchINodeCol, pEntry->Info.Attr.u.Unix.INodeId); + if (cchAllocatedCol) + RTPrintf("%*s ", cchAllocatedCol, rtCmdLsFormatBlocks(pOpts, pEntry->Info.cbAllocated, pszTmp, cbTmp)); + + RTFMODE fMode = pEntry->Info.Attr.fMode; + switch (fMode & RTFS_TYPE_MASK) + { + case RTFS_TYPE_FIFO: RTPrintf("f"); break; + case RTFS_TYPE_DEV_CHAR: RTPrintf("c"); break; + case RTFS_TYPE_DIRECTORY: RTPrintf("d"); break; + case RTFS_TYPE_DEV_BLOCK: RTPrintf("b"); break; + case RTFS_TYPE_FILE: RTPrintf("-"); break; + case RTFS_TYPE_SYMLINK: RTPrintf("l"); break; + case RTFS_TYPE_SOCKET: RTPrintf("s"); break; + case RTFS_TYPE_WHITEOUT: RTPrintf("w"); break; + default: RTPrintf("?"); AssertFailed(); break; + } + /** @todo sticy bits++ */ + RTPrintf("%c%c%c", + fMode & RTFS_UNIX_IRUSR ? 'r' : '-', + fMode & RTFS_UNIX_IWUSR ? 'w' : '-', + fMode & RTFS_UNIX_IXUSR ? 'x' : '-'); + RTPrintf("%c%c%c", + fMode & RTFS_UNIX_IRGRP ? 'r' : '-', + fMode & RTFS_UNIX_IWGRP ? 'w' : '-', + fMode & RTFS_UNIX_IXGRP ? 'x' : '-'); + RTPrintf("%c%c%c", + fMode & RTFS_UNIX_IROTH ? 'r' : '-', + fMode & RTFS_UNIX_IWOTH ? 'w' : '-', + fMode & RTFS_UNIX_IXOTH ? 'x' : '-'); + if (1) + { + RTPrintf(" %c%c%c%c%c%c%c%c%c%c%c%c%c%c", + fMode & RTFS_DOS_READONLY ? 'R' : '-', + fMode & RTFS_DOS_HIDDEN ? 'H' : '-', + fMode & RTFS_DOS_SYSTEM ? 'S' : '-', + fMode & RTFS_DOS_DIRECTORY ? 'D' : '-', + fMode & RTFS_DOS_ARCHIVED ? 'A' : '-', + fMode & RTFS_DOS_NT_DEVICE ? 'd' : '-', + fMode & RTFS_DOS_NT_NORMAL ? 'N' : '-', + fMode & RTFS_DOS_NT_TEMPORARY ? 'T' : '-', + fMode & RTFS_DOS_NT_SPARSE_FILE ? 'P' : '-', + fMode & RTFS_DOS_NT_REPARSE_POINT ? 'J' : '-', + fMode & RTFS_DOS_NT_COMPRESSED ? 'C' : '-', + fMode & RTFS_DOS_NT_OFFLINE ? 'O' : '-', + fMode & RTFS_DOS_NT_NOT_CONTENT_INDEXED ? 'I' : '-', + fMode & RTFS_DOS_NT_ENCRYPTED ? 'E' : '-'); + } + RTPrintf(" %*u", cchLinkCol, pEntry->Info.Attr.u.Unix.cHardlinks); + if (cchUidCol) + RTPrintf(" %*s", cchUidCol, + rtCmdLsDecimalFormatOwner(pOpts, pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp)); + if (cchGidCol) + RTPrintf(" %*s", cchGidCol, + rtCmdLsDecimalFormatGroup(pOpts, pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp)); + RTPrintf(" %*s", cchSizeCol, rtCmdLsFormatSize(pOpts, pEntry->Info.cbObject, pszTmp, cbTmp)); + + PCRTTIMESPEC pTime = (PCRTTIMESPEC)((uintptr_t)pEntry + offTime); + RTPrintf(" %s", rtCmdLsFormatTimestamp(pOpts, pTime, pszTmp, cbTmp)); + + RTPrintf(" %s\n", rtCmdLsFormatName(pOpts, pEntry->szName, pszTmp, cbTmp)); + } + + return RTEXITCODE_SUCCESS; +} + + +/** + * RTCMDLSFORMAT_SINGLE: -1 + */ +static RTEXITCODE rtCmdLsDisplayCollectionInSingleFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection, + char *pszTmp, size_t cbTmp, size_t cchAllocatedCol) +{ + if (cchAllocatedCol > 0) + for (size_t i = 0; i < pCollection->cEntries; i++) + { + PRTCMDLSENTRY pEntry = pCollection->papEntries[i]; + RTPrintf("%*s %s\n", + cchAllocatedCol, rtCmdLsFormatBlocks(pOpts, pEntry->Info.cbAllocated, pszTmp, cbTmp / 4), + rtCmdLsFormatName(pOpts, pEntry->szName, &pszTmp[cbTmp / 4], cbTmp / 4 * 3)); + } + else + for (size_t i = 0; i < pCollection->cEntries; i++) + { + PRTCMDLSENTRY pEntry = pCollection->papEntries[i]; + RTPrintf("%s\n", rtCmdLsFormatName(pOpts, pEntry->szName, pszTmp, cbTmp)); + } + + return RTEXITCODE_SUCCESS; +} + + +/** + * RTCMDLSFORMAT_COLS_VERTICAL: default, -C; RTCMDLSFORMAT_COLS_HORIZONTAL: -x + */ +static RTEXITCODE rtCmdLsDisplayCollectionInTableFormat(PRTCMDLSOPTS pOpts, PRTCMDLSCOLLECTION pCollection, + char *pszTmp, size_t cbTmp, size_t cchAllocatedCol) +{ + RT_NOREF(pOpts, pCollection, pszTmp, cbTmp, cchAllocatedCol); + RTMsgError("Table output formats not implemented\n"); + return RTEXITCODE_FAILURE; +} + + +/** + * Does the actual displaying of the entry collections. + * + * @returns Program exit code. + * @param pOpts The options and state. + */ +static RTEXITCODE rtCmdLsDisplayCollections(PRTCMDLSOPTS pOpts) +{ + rtCmdLsSortCollections(pOpts); + + bool const fNeedCollectionName = pOpts->cCollections > 2 + || ( pOpts->cCollections == 2 + && pOpts->papCollections[0]->cEntries > 0); + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + for (size_t iCollection = 0; iCollection < pOpts->cCollections; iCollection++) + { + PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[iCollection]; + char szTmp[RTPATH_MAX*2]; + + /* The header. */ + if (iCollection != 0) + { + if ( iCollection > 1 + || pOpts->papCollections[0]->cEntries > 0) + RTPrintf("\n"); + if (fNeedCollectionName) + RTPrintf("%s:\n", rtCmdLsFormatName(pOpts, pCollection->szName, szTmp, sizeof(szTmp))); + RTPrintf("total %s\n", rtCmdLsFormatBlocks(pOpts, pCollection->cbTotalAllocated, szTmp, sizeof(szTmp))); + } + + /* Format the entries. */ + RTEXITCODE rcExit2; + if (pOpts->enmFormat == RTCMDLSFORMAT_MACHINE_READABLE) + rcExit2 = rtCmdLsDisplayCollectionInMachineReadableFormat(pOpts, pCollection, szTmp, sizeof(szTmp)); + else if (pOpts->enmFormat == RTCMDLSFORMAT_COMMAS) + rcExit2 = rtCmdLsDisplayCollectionInCvsFormat(pOpts, pCollection, szTmp, sizeof(szTmp)); + else + { + /* If the allocated size is requested, calculate the column width. */ + size_t cchAllocatedCol = 0; + if (pOpts->fShowAllocatedSize) + { + size_t i = pCollection->cEntries; + while (i-- > 0) + { + rtCmdLsFormatBlocks(pOpts, pCollection->papEntries[i]->Info.cbAllocated, szTmp, sizeof(szTmp)); + size_t cchTmp = strlen(szTmp); + if (cchTmp > cchAllocatedCol) + cchAllocatedCol = cchTmp; + } + } + + /* Do the individual formatting. */ + if (pOpts->enmFormat == RTCMDLSFORMAT_LONG) + rcExit2 = rtCmdLsDisplayCollectionInLongFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol); + else if (pOpts->enmFormat == RTCMDLSFORMAT_SINGLE) + rcExit2 = rtCmdLsDisplayCollectionInSingleFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol); + else + rcExit2 = rtCmdLsDisplayCollectionInTableFormat(pOpts, pCollection, szTmp, sizeof(szTmp), cchAllocatedCol); + } + if (rcExit2 != RTEXITCODE_SUCCESS) + rcExit = rcExit2; + } + return rcExit; +} + + +/** + * Frees all collections and their entries. + * @param pOpts The options and state. + */ +static void rtCmdLsFreeCollections(PRTCMDLSOPTS pOpts) +{ + size_t i = pOpts->cCollections; + while (i-- > 0) + { + PRTCMDLSCOLLECTION pCollection = pOpts->papCollections[i]; + PPRTCMDLSENTRY papEntries = pCollection->papEntries; + size_t j = pCollection->cEntries; + while (j-- > 0) + { + RTMemFree(papEntries[j]); + papEntries[j] = NULL; + } + RTMemFree(papEntries); + pCollection->papEntries = NULL; + pCollection->cEntries = 0; + pCollection->cEntriesAllocated = 0; + RTMemFree(pCollection); + pOpts->papCollections[i] = NULL; + } + + RTMemFree(pOpts->papCollections); + pOpts->papCollections = NULL; + pOpts->cCollections = 0; + pOpts->cCollectionsAllocated = 0; +} + + +/** + * Allocates a new collection. + * + * @returns Pointer to the collection. + * @param pOpts The options and state. + * @param pszName The collection name. Empty for special first + * collection. + */ +static PRTCMDLSCOLLECTION rtCmdLsNewCollection(PRTCMDLSOPTS pOpts, const char *pszName) +{ + /* Grow the pointer table? */ + if (pOpts->cCollections >= pOpts->cCollectionsAllocated) + { + size_t cNew = pOpts->cCollectionsAllocated ? pOpts->cCollectionsAllocated * 2 : 16; + void *pvNew = RTMemRealloc(pOpts->papCollections, cNew * sizeof(pOpts->papCollections[0])); + if (!pvNew) + { + RTMsgError("Out of memory! (resize collections)"); + return NULL; + } + pOpts->cCollectionsAllocated = cNew; + pOpts->papCollections = (PPRTCMDLSCOLLECTION)pvNew; + + /* If this is the first time and pszName isn't empty, add the zero'th + entry for the command line stuff (hardcoded first collection). */ + if ( pOpts->cCollections == 0 + && *pszName) + { + PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF(RTCMDLSCOLLECTION, szName[1])); + if (!pCollection) + { + RTMsgError("Out of memory! (collection)"); + return NULL; + } + pOpts->papCollections[0] = pCollection; + pOpts->cCollections = 1; + } + } + + /* Add new collection. */ + size_t cbName = strlen(pszName) + 1; + PRTCMDLSCOLLECTION pCollection = (PRTCMDLSCOLLECTION)RTMemAllocZ(RT_UOFFSETOF_DYN(RTCMDLSCOLLECTION, szName[cbName])); + if (pCollection) + { + memcpy(pCollection->szName, pszName, cbName); + pOpts->papCollections[pOpts->cCollections++] = pCollection; + } + else + RTMsgError("Out of memory! (collection)"); + return pCollection; +} + + +/** + * Adds one entry to a collection. + * @returns Program exit code + * @param pCollection The collection. + * @param pszEntry The entry name. + * @param pInfo The entry info. + * @param pszOwner The owner name if available, otherwise NULL. + * @param pszGroup The group anme if available, otherwise NULL. + * @param pszTarget The symbolic link target if applicable and + * available, otherwise NULL. + */ +static RTEXITCODE rtCmdLsAddOne(PRTCMDLSCOLLECTION pCollection, const char *pszEntry, PRTFSOBJINFO pInfo, + const char *pszOwner, const char *pszGroup, const char *pszTarget) +{ + + /* Make sure there is space in the collection for the new entry. */ + if (pCollection->cEntries >= pCollection->cEntriesAllocated) + { + size_t cNew = pCollection->cEntriesAllocated ? pCollection->cEntriesAllocated * 2 : 16; + void *pvNew = RTMemRealloc(pCollection->papEntries, cNew * sizeof(pCollection->papEntries[0])); + if (!pvNew) + return RTMsgErrorExitFailure("Out of memory! (resize entries)"); + pCollection->papEntries = (PPRTCMDLSENTRY)pvNew; + pCollection->cEntriesAllocated = cNew; + } + + /* Create and insert a new entry. */ + size_t const cchEntry = strlen(pszEntry); + size_t const cbOwner = pszOwner ? strlen(pszOwner) + 1 : 0; + size_t const cbGroup = pszGroup ? strlen(pszGroup) + 1 : 0; + size_t const cbTarget = pszTarget ? strlen(pszTarget) + 1 : 0; + size_t const cbEntry = RT_UOFFSETOF_DYN(RTCMDLSENTRY, szName[cchEntry + 1 + cbOwner + cbGroup + cbTarget]); + PRTCMDLSENTRY pEntry = (PRTCMDLSENTRY)RTMemAlloc(cbEntry); + if (pEntry) + { + pEntry->Info = *pInfo; + pEntry->pszTarget = NULL; /** @todo symbolic links. */ + pEntry->pszOwner = NULL; + pEntry->pszGroup = NULL; + pEntry->cchName = cchEntry; + memcpy(pEntry->szName, pszEntry, cchEntry); + pEntry->szName[cchEntry] = '\0'; + + char *psz = &pEntry->szName[cchEntry + 1]; + if (pszTarget) + { + pEntry->pszTarget = psz; + memcpy(psz, pszTarget, cbTarget); + psz += cbTarget; + } + if (pszOwner) + { + pEntry->pszOwner = psz; + memcpy(psz, pszOwner, cbOwner); + psz += cbOwner; + } + if (pszGroup) + { + pEntry->pszGroup = psz; + memcpy(psz, pszGroup, cbGroup); + } + + pCollection->papEntries[pCollection->cEntries++] = pEntry; + pCollection->cbTotalAllocated += pEntry->Info.cbAllocated; + pCollection->cbTotalFiles += pEntry->Info.cbObject; + return RTEXITCODE_SUCCESS; + } + return RTMsgErrorExitFailure("Out of memory! (entry)"); +} + + +/** + * Checks if the entry is to be filtered out. + * + * @returns true if filtered out, false if included. + * @param pOpts The options and state. + * @param pszEntry The entry name. + * @param pInfo The entry info. + */ +static bool rtCmdLsIsFilteredOut(PRTCMDLSOPTS pOpts, const char *pszEntry, PCRTFSOBJINFO pInfo) +{ + /* + * Should we filter out this entry? + */ + if ( !pOpts->fShowHidden + && (pInfo->Attr.fMode & RTFS_DOS_HIDDEN)) + return true; + + size_t const cchEntry = strlen(pszEntry); + if ( !pOpts->fShowDotAndDotDot + && cchEntry <= 2 + && pszEntry[0] == '.' + && ( cchEntry == 1 + || pszEntry[1] == '.' )) + return true; + + if ( !pOpts->fShowBackups + && pszEntry[cchEntry - 1] == '~') + return true; + return false; +} + + +/** + * Processes a directory, recursing into subdirectories if desired. + * + * @returns Program exit code. + * @param pOpts The options. + * @param hVfsDir The directory. + * @param pszPath Path buffer, RTPATH_MAX in size. + * @param cchPath The length of the current path. + * @param pInfo The parent information. + */ +static RTEXITCODE rtCmdLsProcessDirectory(PRTCMDLSOPTS pOpts, RTVFSDIR hVfsDir, char *pszPath, size_t cchPath, PCRTFSOBJINFO pInfo) +{ + /* + * Create a new collection for this directory. + */ + RT_NOREF(pInfo); + PRTCMDLSCOLLECTION pCollection = rtCmdLsNewCollection(pOpts, pszPath); + if (!pCollection) + return RTEXITCODE_FAILURE; + + /* + * Process the directory entries. + */ + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + size_t cbDirEntryAlloced = sizeof(RTDIRENTRYEX); + PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced); + if (!pDirEntry) + return RTMsgErrorExitFailure("Out of memory! (direntry buffer)"); + + for (;;) + { + /* + * Read the next entry. + */ + size_t cbDirEntry = cbDirEntryAlloced; + int rc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX); + if (RT_FAILURE(rc)) + { + if (rc == VERR_BUFFER_OVERFLOW) + { + RTMemTmpFree(pDirEntry); + cbDirEntryAlloced = RT_ALIGN_Z(RT_MIN(cbDirEntry, cbDirEntryAlloced) + 64, 64); + pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced); + if (pDirEntry) + continue; + rcExit = RTMsgErrorExitFailure("Out of memory (direntry buffer)"); + } + else if (rc != VERR_NO_MORE_FILES) + rcExit = RTMsgErrorExitFailure("RTVfsDirReadEx failed: %Rrc\n", rc); + break; + } + + /* + * Process the entry. + */ + if (rtCmdLsIsFilteredOut(pOpts, pDirEntry->szName, &pDirEntry->Info)) + continue; + + + const char *pszOwner = NULL; + RTFSOBJINFO OwnerInfo; + if (pDirEntry->Info.Attr.u.Unix.uid != NIL_RTUID && pOpts->fShowOwner) + { + rc = RTVfsDirQueryPathInfo(hVfsDir, pDirEntry->szName, &OwnerInfo, RTFSOBJATTRADD_UNIX_OWNER, RTPATH_F_ON_LINK); + if (RT_SUCCESS(rc) && OwnerInfo.Attr.u.UnixOwner.szName[0]) + pszOwner = &OwnerInfo.Attr.u.UnixOwner.szName[0]; + } + + const char *pszGroup = NULL; + RTFSOBJINFO GroupInfo; + if (pDirEntry->Info.Attr.u.Unix.gid != NIL_RTGID && pOpts->fShowGroup) + { + rc = RTVfsDirQueryPathInfo(hVfsDir, pDirEntry->szName, &GroupInfo, RTFSOBJATTRADD_UNIX_GROUP, RTPATH_F_ON_LINK); + if (RT_SUCCESS(rc) && GroupInfo.Attr.u.UnixGroup.szName[0]) + pszGroup = &GroupInfo.Attr.u.UnixGroup.szName[0]; + } + + RTEXITCODE rcExit2 = rtCmdLsAddOne(pCollection, pDirEntry->szName, &pDirEntry->Info, pszOwner, pszGroup, NULL); + if (rcExit2 != RTEXITCODE_SUCCESS) + rcExit = rcExit2; + } + + RTMemTmpFree(pDirEntry); + + /* + * Recurse into subdirectories if requested. + */ + if (pOpts->fRecursive) + { + for (uint32_t i = 0; i < pCollection->cEntries; i++) + { + PRTCMDLSENTRY pEntry = pCollection->papEntries[i]; + if (RTFS_IS_SYMLINK(pEntry->Info.Attr.fMode)) + { + if (!pOpts->fFollowSymlinksInDirs) + continue; + /** @todo implement following symbolic links in the tree. */ + continue; + } + else if ( !RTFS_IS_DIRECTORY(pEntry->Info.Attr.fMode) + || ( pEntry->szName[0] == '.' + && ( pEntry->szName[1] == '\0' + || ( pEntry->szName[1] == '.' + && pEntry->szName[2] == '\0'))) ) + continue; + + /* Open subdirectory and process it. */ + RTVFSDIR hSubDir; + int rc = RTVfsDirOpenDir(hVfsDir, pEntry->szName, 0 /*fFlags*/, &hSubDir); + if (RT_SUCCESS(rc)) + { + if (cchPath + 1 + pEntry->cchName + 1 < RTPATH_MAX) + { + pszPath[cchPath] = RTPATH_SLASH; + memcpy(&pszPath[cchPath + 1], pEntry->szName, pEntry->cchName + 1); + RTEXITCODE rcExit2 = rtCmdLsProcessDirectory(pOpts, hSubDir, pszPath, + cchPath + 1 + pEntry->cchName, &pEntry->Info); + if (rcExit2 != RTEXITCODE_SUCCESS) + rcExit = rcExit2; + pszPath[cchPath] = '\0'; + } + else + rcExit = RTMsgErrorExitFailure("Too deep recursion: %s%c%s", pszPath, RTPATH_SLASH, pEntry->szName); + RTVfsDirRelease(hSubDir); + } + else + rcExit = RTMsgErrorExitFailure("RTVfsDirOpenDir failed on %s in %s: %Rrc\n", pEntry->szName, pszPath, rc); + } + } + return rcExit; +} + + +/** + * Processes one argument. + * + * @returns Program exit code. + * @param pOpts The options. + * @param pszArg The argument. + */ +static RTEXITCODE rtCmdLsProcessArgument(PRTCMDLSOPTS pOpts, const char *pszArg) +{ + /* + * Query info about the object 'pszArg' indicates. + */ + RTERRINFOSTATIC ErrInfo; + uint32_t offError; + RTFSOBJINFO Info; + uint32_t fPath = pOpts->fFollowSymlinkToAnyArgs ? RTPATH_F_FOLLOW_LINK : RTPATH_F_ON_LINK; + int rc = RTVfsChainQueryInfo(pszArg, &Info, RTFSOBJATTRADD_UNIX, fPath, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return RTVfsChainMsgErrorExitFailure("RTVfsChainQueryInfo", pszArg, rc, offError, &ErrInfo.Core); + + /* Symbolic links requires special handling of course. */ + if (RTFS_IS_SYMLINK(Info.Attr.fMode)) + { + if (pOpts->fFollowSymlinkToDirArgs) + { + RTFSOBJINFO Info2; + rc = RTVfsChainQueryInfo(pszArg, &Info2, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK, + &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_SUCCESS(rc) && !RTFS_IS_DIRECTORY(Info.Attr.fMode)) + Info = Info2; + } + } + + /* + * If it's not a directory or we've been told to process directories + * without going into them, just add it to the default collection. + */ + if ( !pOpts->fFollowDirectoryArgs + || !RTFS_IS_DIRECTORY(Info.Attr.fMode)) + { + if ( pOpts->cCollections > 0 + || rtCmdLsNewCollection(pOpts, "") != NULL) + { + const char *pszOwner = NULL; + RTFSOBJINFO OwnerInfo; + if (Info.Attr.u.Unix.uid != NIL_RTUID && pOpts->fShowOwner) + { + rc = RTVfsChainQueryInfo(pszArg, &OwnerInfo, RTFSOBJATTRADD_UNIX_OWNER, fPath, NULL, NULL); + if (RT_SUCCESS(rc) && OwnerInfo.Attr.u.UnixOwner.szName[0]) + pszOwner = &OwnerInfo.Attr.u.UnixOwner.szName[0]; + } + + const char *pszGroup = NULL; + RTFSOBJINFO GroupInfo; + if (Info.Attr.u.Unix.gid != NIL_RTGID && pOpts->fShowGroup) + { + rc = RTVfsChainQueryInfo(pszArg, &GroupInfo, RTFSOBJATTRADD_UNIX_GROUP, fPath, NULL, NULL); + if (RT_SUCCESS(rc) && GroupInfo.Attr.u.UnixGroup.szName[0]) + pszGroup = &GroupInfo.Attr.u.UnixGroup.szName[0]; + } + + return rtCmdLsAddOne(pOpts->papCollections[0], pszArg, &Info, pszOwner, pszGroup, NULL); + } + return RTEXITCODE_FAILURE; + } + + /* + * Open the directory. + */ + RTVFSDIR hVfsDir; + rc = RTVfsChainOpenDir(pszArg, 0 /*fFlags*/, &hVfsDir, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return RTVfsChainMsgErrorExitFailure("RTVfsChainOpenDir", pszArg, rc, offError, &ErrInfo.Core); + + RTEXITCODE rcExit; + char szPath[RTPATH_MAX]; + size_t cchPath = strlen(pszArg); + if (cchPath < sizeof(szPath)) + { + memcpy(szPath, pszArg, cchPath + 1); + rcExit = rtCmdLsProcessDirectory(pOpts, hVfsDir, szPath, cchPath, &Info); + } + else + rcExit = RTMsgErrorExitFailure("Too long argument: %s", pszArg); + RTVfsDirRelease(hVfsDir); + return rcExit; +} + + +/** + * A /bin/ls clone. + * + * @returns Program exit code. + * + * @param cArgs The number of arguments. + * @param papszArgs The argument vector. (Note that this may be + * reordered, so the memory must be writable.) + */ +RTR3DECL(RTEXITCODE) RTFsCmdLs(unsigned cArgs, char **papszArgs) +{ + + /* + * Parse the command line. + */ +#define OPT_AUTHOR 1000 +#define OPT_BLOCK_SIZE 1001 +#define OPT_COLOR 1002 +#define OPT_FILE_TYPE 1003 +#define OPT_FORMAT 1004 +#define OPT_FULL_TIME 1005 +#define OPT_GROUP_DIRECTORIES_FIRST 1006 +#define OPT_SI 1007 +#define OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR 1008 +#define OPT_HIDE 1009 +#define OPT_INDICATOR_STYLE 1010 +#define OPT_MACHINE_READABLE 1011 +#define OPT_SHOW_CONTROL_CHARS 1012 +#define OPT_QUOTING_STYLE 1013 +#define OPT_SORT 1014 +#define OPT_TIME 1015 +#define OPT_TIME_STYLE 1016 + static const RTGETOPTDEF s_aOptions[] = + { + { "--all", 'a', RTGETOPT_REQ_NOTHING }, + { "--almost-all", 'A', RTGETOPT_REQ_NOTHING }, + //{ "--author", OPT_AUTHOR, RTGETOPT_REQ_NOTHING }, + { "--escape", 'b', RTGETOPT_REQ_NOTHING }, + { "--block-size", OPT_BLOCK_SIZE, RTGETOPT_REQ_UINT32 }, + { "--ctime", 'c', RTGETOPT_REQ_NOTHING }, + //{ "--columns", 'C', RTGETOPT_REQ_NOTHING }, + //{ "--color", OPT_COLOR, RTGETOPT_OPT_STRING }, + { "--directory", 'd', RTGETOPT_REQ_NOTHING }, + //{ "--dired", 'D', RTGETOPT_REQ_NOTHING }, + { "--dash-f", 'f', RTGETOPT_REQ_NOTHING }, + //{ "--classify", 'F', RTGETOPT_REQ_NOTHING }, + //{ "--file-type", OPT_FILE_TYPE, RTGETOPT_REQ_NOTHING }, + { "--format", OPT_FORMAT, RTGETOPT_REQ_STRING }, + { "--full-time", OPT_FULL_TIME, RTGETOPT_REQ_NOTHING }, + { "--dash-g", 'g', RTGETOPT_REQ_NOTHING }, + { "--group-directories-first", OPT_GROUP_DIRECTORIES_FIRST, RTGETOPT_REQ_NOTHING }, + { "--no-group", 'G', RTGETOPT_REQ_NOTHING }, + { "--human-readable", 'h', RTGETOPT_REQ_NOTHING }, + { "--si", OPT_SI, RTGETOPT_REQ_NOTHING }, + { "--dereference-command-line", 'H', RTGETOPT_REQ_NOTHING }, + { "--dereference-command-line-symlink-to-dir", OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR, RTGETOPT_REQ_NOTHING }, + //{ "--hide" OPT_HIDE, RTGETOPT_REQ_STRING }, + //{ "--indicator-style" OPT_INDICATOR_STYLE, RTGETOPT_REQ_STRING }, + { "--inode", 'i', RTGETOPT_REQ_NOTHING }, + { "--block-size-1kib", 'k', RTGETOPT_REQ_NOTHING }, + { "--long", 'l', RTGETOPT_REQ_NOTHING }, + { "--dereference", 'L', RTGETOPT_REQ_NOTHING }, + { "--format-commas", 'm', RTGETOPT_REQ_NOTHING }, + { "--machinereadable", OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING }, + { "--machine-readable", OPT_MACHINE_READABLE, RTGETOPT_REQ_NOTHING }, + { "--numeric-uid-gid", 'n', RTGETOPT_REQ_NOTHING }, + { "--literal", 'N', RTGETOPT_REQ_NOTHING }, + { "--long-without-group-info", 'o', RTGETOPT_REQ_NOTHING }, + //{ "--indicator-style", 'p', RTGETOPT_REQ_STRING }, + { "--hide-control-chars", 'q', RTGETOPT_REQ_NOTHING }, + { "--show-control-chars", OPT_SHOW_CONTROL_CHARS, RTGETOPT_REQ_NOTHING }, + //{ "--quote-name", 'Q', RTGETOPT_REQ_NOTHING }, + //{ "--quoting-style", OPT_QUOTING_STYLE, RTGETOPT_REQ_STRING }, + { "--reverse", 'r', RTGETOPT_REQ_NOTHING }, + { "--recursive", 'R', RTGETOPT_REQ_NOTHING }, + { "--size", 's', RTGETOPT_REQ_NOTHING }, + { "--sort-by-size", 'S', RTGETOPT_REQ_NOTHING }, + { "--sort", OPT_SORT, RTGETOPT_REQ_STRING }, + { "--time", OPT_TIME, RTGETOPT_REQ_STRING }, + { "--time-style", OPT_TIME_STYLE, RTGETOPT_REQ_STRING }, + { "--sort-by-time", 't', RTGETOPT_REQ_NOTHING }, + { "--tabsize", 'T', RTGETOPT_REQ_UINT8 }, + { "--atime", 'u', RTGETOPT_REQ_NOTHING }, + { "--unsorted", 'U', RTGETOPT_REQ_NOTHING }, + { "--version-sort", 'v', RTGETOPT_REQ_NOTHING }, + { "--width", 'w', RTGETOPT_REQ_UINT32 }, + { "--list-by-line", 'x', RTGETOPT_REQ_NOTHING }, + { "--sort-by-extension", 'X', RTGETOPT_REQ_NOTHING }, + { "--one-file-per-line", '1', RTGETOPT_REQ_NOTHING }, + { "--help", '?', RTGETOPT_REQ_NOTHING }, + }; + + RTCMDLSOPTS Opts; + Opts.fFollowSymlinksInDirs = false; + Opts.fFollowSymlinkToAnyArgs = false; + Opts.fFollowSymlinkToDirArgs = false; + Opts.fFollowDirectoryArgs = true; + Opts.fRecursive = false; + Opts.fShowHidden = false; + Opts.fShowDotAndDotDot = false; + Opts.fShowBackups = true; + Opts.enmSort = RTCMDLSSORT_NAME; + Opts.fReverseSort = false; + Opts.fGroupDirectoriesFirst = false; + Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL; + Opts.fEscapeNonGraphicChars = false; + Opts.fEscapeControlChars = true; + Opts.fHideControlChars = false; + Opts.fHumanReadableSizes = false; /**< -h */ + Opts.fSiUnits = false; + Opts.cbBlock = 0; + Opts.fShowOwner = true; + Opts.fShowGroup = true; + Opts.fNumericalIds = false; + Opts.fShowINode = false; + Opts.fShowAllocatedSize = false; + Opts.cchTab = 8; + Opts.cchWidth = 80; + Opts.enmColor = RTCMDLSCOLOR_NONE; + Opts.enmTime = RTCMDLSTIME_MTIME; + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LOCALE; + Opts.pszTimeCustom = NULL; + + Opts.cCollections = 0; + Opts.cCollectionsAllocated = 0; + Opts.papCollections = NULL; + + + RTEXITCODE rcExit = RTEXITCODE_SUCCESS; + unsigned cProcessed = 0; + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, cArgs, papszArgs, s_aOptions, RT_ELEMENTS(s_aOptions), 1, + RTGETOPTINIT_FLAGS_OPTS_FIRST); + if (RT_FAILURE(rc)) + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "RTGetOptInit: %Rrc", rc); + + for (;;) + { + RTGETOPTUNION ValueUnion; + int chOpt = RTGetOpt(&GetState, &ValueUnion); + switch (chOpt) + { + case 0: + /* When reaching the end of arguments without having processed any + files/dirs/whatever yet, we do the current directory. */ + if (cProcessed > 0) + { + RTEXITCODE rcExit2 = rtCmdLsDisplayCollections(&Opts); + if (rcExit2 != RTEXITCODE_SUCCESS) + rcExit = rcExit2; + rtCmdLsFreeCollections(&Opts); + return rcExit; + } + ValueUnion.psz = "."; + RT_FALL_THRU(); + case VINF_GETOPT_NOT_OPTION: + { + RTEXITCODE rcExit2 = rtCmdLsProcessArgument(&Opts, ValueUnion.psz); + if (rcExit2 != RTEXITCODE_SUCCESS) + rcExit = rcExit2; + cProcessed++; + break; + } + + case 'a': + Opts.fShowHidden = true; + Opts.fShowDotAndDotDot = true; + break; + + case 'A': + Opts.fShowHidden = true; + Opts.fShowDotAndDotDot = false; + break; + + case 'b': + Opts.fEscapeNonGraphicChars = true; + break; + + case OPT_BLOCK_SIZE: + if (!ValueUnion.u32) + { + Assert(!Opts.papCollections); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Invalid block size: %u", ValueUnion.u32); + } + Opts.cbBlock = ValueUnion.u32; + Opts.fHumanReadableSizes = false; + Opts.fSiUnits = false; + break; + + case 'c': + Opts.enmTime = RTCMDLSTIME_CTIME; + break; + + case 'C': + Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL; + break; + + case 'd': + Opts.fFollowDirectoryArgs = false; + Opts.fFollowSymlinkToAnyArgs = false; + Opts.fFollowSymlinkToDirArgs = false; + Opts.fRecursive = false; + break; + + case 'f': + Opts.fShowHidden = true; + Opts.fShowDotAndDotDot = true; + if (Opts.enmFormat == RTCMDLSFORMAT_LONG) + Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL; + Opts.enmColor = RTCMDLSCOLOR_NONE; + Opts.enmSort = RTCMDLSSORT_NONE; + break; + + case OPT_FORMAT: + if ( strcmp(ValueUnion.psz, "across") == 0 + || strcmp(ValueUnion.psz, "horizontal") == 0) + Opts.enmFormat = RTCMDLSFORMAT_COLS_HORIZONTAL; + else if (strcmp(ValueUnion.psz, "commas") == 0) + Opts.enmFormat = RTCMDLSFORMAT_COMMAS; + else if ( strcmp(ValueUnion.psz, "long") == 0 + || strcmp(ValueUnion.psz, "verbose") == 0) + Opts.enmFormat = RTCMDLSFORMAT_LONG; + else if (strcmp(ValueUnion.psz, "single-column") == 0) + Opts.enmFormat = RTCMDLSFORMAT_SINGLE; + else if (strcmp(ValueUnion.psz, "vertical") == 0) + Opts.enmFormat = RTCMDLSFORMAT_COLS_VERTICAL; + else if (strcmp(ValueUnion.psz, "machine-readable") == 0) + Opts.enmFormat = RTCMDLSFORMAT_MACHINE_READABLE; + else + { + Assert(!Opts.papCollections); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown format: %s", ValueUnion.psz); + } + break; + + case OPT_FULL_TIME: + Opts.enmFormat = RTCMDLSFORMAT_LONG; + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_FULL_ISO; + break; + + case 'g': + Opts.enmFormat = RTCMDLSFORMAT_LONG; + Opts.fShowOwner = false; + break; + + case OPT_GROUP_DIRECTORIES_FIRST: + Opts.fGroupDirectoriesFirst = true; + break; + + case 'G': + Opts.fShowGroup = false; + break; + + case 'h': + Opts.fHumanReadableSizes = true; + Opts.fSiUnits = false; + break; + + case OPT_SI: + Opts.fHumanReadableSizes = true; + Opts.fSiUnits = true; + break; + + case 'H': + Opts.fFollowSymlinkToAnyArgs = true; + Opts.fFollowSymlinkToDirArgs = true; + break; + + case OPT_DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR: + Opts.fFollowSymlinkToAnyArgs = false; + Opts.fFollowSymlinkToDirArgs = true; + break; + + case 'i': + Opts.fShowINode = true; + break; + + case 'k': + Opts.cbBlock = _1K; + Opts.fHumanReadableSizes = false; + Opts.fSiUnits = false; + break; + + case 'l': + Opts.enmFormat = RTCMDLSFORMAT_LONG; + break; + + case 'L': + Opts.fFollowSymlinksInDirs = true; + Opts.fFollowSymlinkToAnyArgs = true; + Opts.fFollowSymlinkToDirArgs = true; + break; + + case 'm': + Opts.enmFormat = RTCMDLSFORMAT_COMMAS; + break; + + case OPT_MACHINE_READABLE: + Opts.enmFormat = RTCMDLSFORMAT_MACHINE_READABLE; + break; + + case 'n': + Opts.fNumericalIds = true; + break; + + case 'N': + Opts.fEscapeNonGraphicChars = false; + Opts.fEscapeControlChars = false; + Opts.fHideControlChars = false; + break; + + case 'o': + Opts.enmFormat = RTCMDLSFORMAT_LONG; + Opts.fShowGroup = false; + break; + + case 'q': + Opts.fHideControlChars = true; + break; + + case OPT_SHOW_CONTROL_CHARS: + Opts.fHideControlChars = true; + break; + + case 'r': + Opts.fReverseSort = true; + break; + + case 'R': + Opts.fRecursive = true; + break; + + case 's': + Opts.fShowAllocatedSize = true; + break; + + case 'S': + Opts.enmSort = RTCMDLSSORT_SIZE; + break; + + case OPT_SORT: + if (strcmp(ValueUnion.psz, "none") == 0) + Opts.enmSort = RTCMDLSSORT_NONE; + else if (strcmp(ValueUnion.psz, "extension") == 0) + Opts.enmSort = RTCMDLSSORT_EXTENSION; + else if (strcmp(ValueUnion.psz, "size") == 0) + Opts.enmSort = RTCMDLSSORT_SIZE; + else if (strcmp(ValueUnion.psz, "time") == 0) + Opts.enmSort = RTCMDLSSORT_TIME; + else if (strcmp(ValueUnion.psz, "version") == 0) + Opts.enmSort = RTCMDLSSORT_VERSION; + else + { + Assert(!Opts.papCollections); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown sort by: %s", ValueUnion.psz); + } + break; + + case OPT_TIME: + if ( strcmp(ValueUnion.psz, "btime") == 0 + || strcmp(ValueUnion.psz, "birth") == 0) + Opts.enmTime = RTCMDLSTIME_BTIME; + else if ( strcmp(ValueUnion.psz, "ctime") == 0 + || strcmp(ValueUnion.psz, "status") == 0) + Opts.enmTime = RTCMDLSTIME_CTIME; + else if ( strcmp(ValueUnion.psz, "mtime") == 0 + || strcmp(ValueUnion.psz, "write") == 0 + || strcmp(ValueUnion.psz, "modify") == 0) + Opts.enmTime = RTCMDLSTIME_MTIME; + else if ( strcmp(ValueUnion.psz, "atime") == 0 + || strcmp(ValueUnion.psz, "access") == 0 + || strcmp(ValueUnion.psz, "use") == 0) + Opts.enmTime = RTCMDLSTIME_ATIME; + else + { + Assert(!Opts.papCollections); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown time attribute: %s", ValueUnion.psz); + } + break; + + case OPT_TIME_STYLE: + if (strcmp(ValueUnion.psz, "full-iso") == 0) + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_FULL_ISO; + else if (strcmp(ValueUnion.psz, "long-iso") == 0) + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LONG_ISO; + else if (strcmp(ValueUnion.psz, "iso") == 0) + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_ISO; + else if (strcmp(ValueUnion.psz, "locale") == 0) + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_LOCALE; + else if (*ValueUnion.psz == '+') + { + Opts.enmTimeStyle = RTCMDLSTIMESTYLE_CUSTOM; + Opts.pszTimeCustom = ValueUnion.psz; + } + else + { + Assert(!Opts.papCollections); + return RTMsgErrorExit(RTEXITCODE_SYNTAX, "Unknown sort by: %s", ValueUnion.psz); + } + break; + + case 't': + Opts.enmSort = RTCMDLSSORT_TIME; + break; + + case 'T': + Opts.cchTab = ValueUnion.u8; + break; + + case 'u': + Opts.enmTime = RTCMDLSTIME_ATIME; + break; + + case 'U': + Opts.enmSort = RTCMDLSSORT_NONE; + break; + + case 'v': + Opts.enmSort = RTCMDLSSORT_VERSION; + break; + + case 'w': + Opts.cchWidth = ValueUnion.u32; + break; + + case 'x': + Opts.enmFormat = RTCMDLSFORMAT_COLS_HORIZONTAL; + break; + + case 'X': + Opts.enmSort = RTCMDLSSORT_EXTENSION; + break; + + case '1': + Opts.enmFormat = RTCMDLSFORMAT_SINGLE; + break; + + case '?': + RTPrintf("Usage: to be written\nOpts.on dump:\n"); + for (unsigned i = 0; i < RT_ELEMENTS(s_aOptions); i++) + RTPrintf(" -%c,%s\n", s_aOptions[i].iShort, s_aOptions[i].pszLong); + Assert(!Opts.papCollections); + return RTEXITCODE_SUCCESS; + + case 'V': + RTPrintf("%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision()); + Assert(!Opts.papCollections); + return RTEXITCODE_SUCCESS; + + default: + Assert(!Opts.papCollections); + return RTGetOptPrintError(chOpt, &ValueUnion); + } + } +} + diff --git a/src/VBox/Runtime/common/fs/extvfs.cpp b/src/VBox/Runtime/common/fs/extvfs.cpp new file mode 100644 index 00000000..5159db55 --- /dev/null +++ b/src/VBox/Runtime/common/fs/extvfs.cpp @@ -0,0 +1,2853 @@ +/* $Id: extvfs.cpp $ */ +/** @file + * IPRT - Ext2/3/4 Virtual Filesystem. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include <iprt/fsvfs.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/avl.h> +#include <iprt/file.h> +#include <iprt/err.h> +#include <iprt/list.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/formats/ext.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The maximum block group cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSEXT_MAX_BLOCK_GROUP_CACHE_SIZE _512K +#else +# define RTFSEXT_MAX_BLOCK_GROUP_CACHE_SIZE _128K +#endif +/** The maximum inode cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSEXT_MAX_INODE_CACHE_SIZE _512K +#else +# define RTFSEXT_MAX_INODE_CACHE_SIZE _128K +#endif +/** The maximum extent/block map cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSEXT_MAX_BLOCK_CACHE_SIZE _512K +#else +# define RTFSEXT_MAX_BLOCK_CACHE_SIZE _128K +#endif + +/** All supported incompatible features. */ +#define RTFSEXT_INCOMPAT_FEATURES_SUPP ( EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE | EXT_SB_FEAT_INCOMPAT_EXTENTS | EXT_SB_FEAT_INCOMPAT_64BIT \ + | EXT_SB_FEAT_INCOMPAT_FLEX_BG) + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to the ext filesystem data. */ +typedef struct RTFSEXTVOL *PRTFSEXTVOL; + + +/** + * Cached block group descriptor data. + */ +typedef struct RTFSEXTBLKGRP +{ + /** AVL tree node, indexed by the block group number. */ + AVLU32NODECORE Core; + /** List node for the LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** Block number where the inode table is store. */ + uint64_t iBlockInodeTbl; + /** Pointer to the inode bitmap. */ + uint8_t *pabInodeBitmap; + /** Block bitmap - variable in size (depends on the block size + * and number of blocks per group). */ + uint8_t abBlockBitmap[1]; +} RTFSEXTBLKGRP; +/** Pointer to block group descriptor data. */ +typedef RTFSEXTBLKGRP *PRTFSEXTBLKGRP; + + +/** + * In-memory inode. + */ +typedef struct RTFSEXTINODE +{ + /** AVL tree node, indexed by the inode number. */ + AVLU32NODECORE Core; + /** List node for the inode LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** Byte offset in the backing file where the inode is stored.. */ + uint64_t offInode; + /** Inode data. */ + RTFSOBJINFO ObjInfo; + /** Inode flags (copied from the on disk inode). */ + uint32_t fFlags; + /** Copy of the block map/extent tree. */ + uint32_t aiBlocks[EXT_INODE_BLOCK_ENTRIES]; +} RTFSEXTINODE; +/** Pointer to an in-memory inode. */ +typedef RTFSEXTINODE *PRTFSEXTINODE; + + +/** + * Block cache entry. + */ +typedef struct RTFSEXTBLOCKENTRY +{ + /** AVL tree node, indexed by the filesystem block number. */ + AVLU64NODECORE Core; + /** List node for the inode LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** The block data. */ + uint8_t abData[1]; +} RTFSEXTBLOCKENTRY; +/** Pointer to a block cache entry. */ +typedef RTFSEXTBLOCKENTRY *PRTFSEXTBLOCKENTRY; + + +/** + * Open directory instance. + */ +typedef struct RTFSEXTDIR +{ + /** Volume this directory belongs to. */ + PRTFSEXTVOL pVol; + /** The underlying inode structure. */ + PRTFSEXTINODE pInode; + /** Set if we've reached the end of the directory enumeration. */ + bool fNoMoreFiles; + /** Current offset into the directory where the next entry should be read. */ + uint64_t offEntry; + /** Next entry index (for logging purposes). */ + uint32_t idxEntry; +} RTFSEXTDIR; +/** Pointer to an open directory instance. */ +typedef RTFSEXTDIR *PRTFSEXTDIR; + + +/** + * Open file instance. + */ +typedef struct RTFSEXTFILE +{ + /** Volume this directory belongs to. */ + PRTFSEXTVOL pVol; + /** The underlying inode structure. */ + PRTFSEXTINODE pInode; + /** Current offset into the file for I/O. */ + RTFOFF offFile; +} RTFSEXTFILE; +/** Pointer to an open file instance. */ +typedef RTFSEXTFILE *PRTFSEXTFILE; + + +/** + * Ext2/3/4 filesystem volume. + */ +typedef struct RTFSEXTVOL +{ + /** Handle to itself. */ + RTVFS hVfsSelf; + /** The file, partition, or whatever backing the ext volume. */ + RTVFSFILE hVfsBacking; + /** The size of the backing thingy. */ + uint64_t cbBacking; + + /** RTVFSMNT_F_XXX. */ + uint32_t fMntFlags; + /** RTFSEXTVFS_F_XXX (currently none defined). */ + uint32_t fExtFlags; + + /** Flag whether the filesystem is 64bit. */ + bool f64Bit; + /** Size of one block. */ + size_t cbBlock; + /** Number of bits to shift left for fast conversion of block numbers to offsets. */ + uint32_t cBlockShift; + /** Number of blocks in one group. */ + uint32_t cBlocksPerGroup; + /** Number of inodes in each block group. */ + uint32_t cInodesPerGroup; + /** Number of blocks groups in the volume. */ + uint32_t cBlockGroups; + /** Size of the block bitmap. */ + size_t cbBlockBitmap; + /** Size of the inode bitmap. */ + size_t cbInodeBitmap; + /** Size of block group descriptor. */ + size_t cbBlkGrpDesc; + /** Size of an inode. */ + size_t cbInode; + + /** Incompatible features selected for this filesystem. */ + uint32_t fFeaturesIncompat; + + /** @name Block group cache. + * @{ */ + /** LRU list anchor. */ + RTLISTANCHOR LstBlockGroupLru; + /** Root of the cached block group tree. */ + AVLU32TREE BlockGroupRoot; + /** Size of the cached block groups. */ + size_t cbBlockGroups; + /** @} */ + + /** @name Inode cache. + * @{ */ + /** LRU list anchor for the inode cache. */ + RTLISTANCHOR LstInodeLru; + /** Root of the cached inode tree. */ + AVLU32TREE InodeRoot; + /** Size of the cached inodes. */ + size_t cbInodes; + /** @} */ + + /** @name Block cache. + * @{ */ + /** LRU list anchor for the block cache. */ + RTLISTANCHOR LstBlockLru; + /** Root of the cached block tree. */ + AVLU64TREE BlockRoot; + /** Size of cached blocks. */ + size_t cbBlocks; + /** @} */ +} RTFSEXTVOL; + + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtFsExtVol_OpenDirByInode(PRTFSEXTVOL pThis, uint32_t iInode, PRTVFSDIR phVfsDir); + +#ifdef LOG_ENABLED +/** + * Logs the ext filesystem superblock. + * + * @returns nothing. + * @param pSb Pointer to the superblock. + */ +static void rtFsExtSb_Log(PCEXTSUPERBLOCK pSb) +{ + if (LogIs2Enabled()) + { + RTTIMESPEC Spec; + char sz[80]; + + Log2(("EXT: Superblock:\n")); + Log2(("EXT: cInodesTotal %RU32\n", RT_LE2H_U32(pSb->cInodesTotal))); + Log2(("EXT: cBlocksTotalLow %RU32\n", RT_LE2H_U32(pSb->cBlocksTotalLow))); + Log2(("EXT: cBlocksRsvdForSuperUserLow %RU32\n", RT_LE2H_U32(pSb->cBlocksRsvdForSuperUserLow))); + Log2(("EXT: cBlocksFreeLow %RU32\n", RT_LE2H_U32(pSb->cBlocksFreeLow))); + Log2(("EXT: cInodesFree %RU32\n", RT_LE2H_U32(pSb->cInodesFree))); + Log2(("EXT: iBlockOfSuperblock %RU32\n", RT_LE2H_U32(pSb->iBlockOfSuperblock))); + Log2(("EXT: cLogBlockSize %RU32\n", RT_LE2H_U32(pSb->cLogBlockSize))); + Log2(("EXT: cLogClusterSize %RU32\n", RT_LE2H_U32(pSb->cLogClusterSize))); + Log2(("EXT: cBlocksPerGroup %RU32\n", RT_LE2H_U32(pSb->cBlocksPerGroup))); + Log2(("EXT: cClustersPerBlockGroup %RU32\n", RT_LE2H_U32(pSb->cClustersPerBlockGroup))); + Log2(("EXT: cInodesPerBlockGroup %RU32\n", RT_LE2H_U32(pSb->cInodesPerBlockGroup))); + Log2(("EXT: u32LastMountTime %#RX32 %s\n", RT_LE2H_U32(pSb->u32LastMountTime), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pSb->u32LastMountTime)), sz, sizeof(sz)))); + Log2(("EXT: u32LastWrittenTime %#RX32 %s\n", RT_LE2H_U32(pSb->u32LastWrittenTime), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pSb->u32LastWrittenTime)), sz, sizeof(sz)))); + Log2(("EXT: cMountsSinceLastCheck %RU16\n", RT_LE2H_U32(pSb->cMountsSinceLastCheck))); + Log2(("EXT: cMaxMountsUntilCheck %RU16\n", RT_LE2H_U32(pSb->cMaxMountsUntilCheck))); + Log2(("EXT: u16Signature %#RX16\n", RT_LE2H_U32(pSb->u16Signature))); + Log2(("EXT: u16FilesystemState %#RX16\n", RT_LE2H_U32(pSb->u16FilesystemState))); + Log2(("EXT: u16ActionOnError %#RX16\n", RT_LE2H_U32(pSb->u16ActionOnError))); + Log2(("EXT: u16RevLvlMinor %#RX16\n", RT_LE2H_U32(pSb->u16RevLvlMinor))); + Log2(("EXT: u32LastCheckTime %#RX32 %s\n", RT_LE2H_U32(pSb->u32LastCheckTime), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pSb->u32LastCheckTime)), sz, sizeof(sz)))); + Log2(("EXT: u32CheckInterval %RU32\n", RT_LE2H_U32(pSb->u32CheckInterval))); + Log2(("EXT: u32OsIdCreator %#RX32\n", RT_LE2H_U32(pSb->u32OsIdCreator))); + Log2(("EXT: u32RevLvl %#RX32\n", RT_LE2H_U32(pSb->u32RevLvl))); + Log2(("EXT: u16UidReservedBlocks %#RX16\n", RT_LE2H_U32(pSb->u16UidReservedBlocks))); + Log2(("EXT: u16GidReservedBlocks %#RX16\n", RT_LE2H_U32(pSb->u16GidReservedBlocks))); + if (RT_LE2H_U32(pSb->u32RevLvl) == EXT_SB_REV_V2_DYN_INODE_SZ) + { + Log2(("EXT: iFirstInodeNonRsvd %#RX32\n", RT_LE2H_U32(pSb->iFirstInodeNonRsvd))); + Log2(("EXT: cbInode %#RX16\n", RT_LE2H_U32(pSb->cbInode))); + Log2(("EXT: iBlkGrpSb %#RX16\n", RT_LE2H_U32(pSb->iBlkGrpSb))); + Log2(("EXT: fFeaturesCompat %#RX32%s%s%s%s%s%s%s%s%s%s\n", RT_LE2H_U32(pSb->fFeaturesCompat), + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_DIR_PREALLOC ? " dir-prealloc" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_IMAGIC_INODES ? " imagic-inode" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_HAS_JOURNAL ? " has-journal" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_EXT_ATTR ? " ext-attrs" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_RESIZE_INODE ? " resize-inode" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_DIR_INDEX ? " dir-index" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_LAZY_BG ? " lazy-bg" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_EXCLUDE_INODE ? " excl-inode" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_EXCLUDE_BITMAP ? " excl-bitmap" : "", + RT_LE2H_U32(pSb->fFeaturesCompat) & EXT_SB_FEAT_COMPAT_SPARSE_SUPER2 ? " sparse-super2" : "")); + Log2(("EXT: fFeaturesIncompat %#RX32%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", RT_LE2H_U32(pSb->fFeaturesIncompat), + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_COMPRESSION ? " compression" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE ? " dir-filetype" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_RECOVER ? " recovery" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_JOURNAL_DEV ? " journal-dev" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_META_BG ? " meta-bg" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_EXTENTS ? " extents" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_64BIT ? " 64bit" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_MMP ? " mmp" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_FLEX_BG ? " flex-bg" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_EXT_ATTR_INODE ? " extattr-inode" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_DIRDATA ? " dir-data" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_CSUM_SEED ? " csum-seed" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_LARGE_DIR ? " large-dir" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_INLINE_DATA ? " inline-data" : "", + RT_LE2H_U32(pSb->fFeaturesIncompat) & EXT_SB_FEAT_INCOMPAT_ENCRYPT ? " encrypt" : "")); + Log2(("EXT: fFeaturesCompatRo %#RX32%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", RT_LE2H_U32(pSb->fFeaturesCompatRo), + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_SPARSE_SUPER ? " sparse-super" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_LARGE_FILE ? " large-file" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_BTREE_DIR ? " btree-dir" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_HUGE_FILE ? " huge-file" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_GDT_CHSKUM ? " gdt-chksum" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_DIR_NLINK ? " dir-nlink" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_EXTRA_INODE_SZ ? " extra-inode" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_HAS_SNAPSHOTS ? " snapshots" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_QUOTA ? " quota" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_BIGALLOC ? " big-alloc" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_METADATA_CHKSUM ? " meta-chksum" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_REPLICA ? " replica" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_READONLY ? " ro" : "", + RT_LE2H_U32(pSb->fFeaturesCompatRo) & EXT_SB_FEAT_COMPAT_RO_PROJECT ? " project" : "")); + Log2(("EXT: au8Uuid <todo>\n")); + Log2(("EXT: achVolumeName %16s\n", &pSb->achVolumeName[0])); + Log2(("EXT: achLastMounted %64s\n", &pSb->achLastMounted[0])); + Log2(("EXT: u32AlgoUsageBitmap %#RX32\n", RT_LE2H_U32(pSb->u32AlgoUsageBitmap))); + Log2(("EXT: cBlocksPrealloc %RU8\n", pSb->cBlocksPrealloc)); + Log2(("EXT: cBlocksPreallocDirectory %RU8\n", pSb->cBlocksPreallocDirectory)); + Log2(("EXT: cGdtEntriesRsvd %RU16\n", pSb->cGdtEntriesRsvd)); + Log2(("EXT: au8JournalUuid <todo>\n")); + Log2(("EXT: iJournalInode %#RX32\n", RT_LE2H_U32(pSb->iJournalInode))); + Log2(("EXT: u32JournalDev %#RX32\n", RT_LE2H_U32(pSb->u32JournalDev))); + Log2(("EXT: u32LastOrphan %#RX32\n", RT_LE2H_U32(pSb->u32LastOrphan))); + Log2(("EXT: au32HashSeedHtree[0] %#RX32\n", RT_LE2H_U32(pSb->au32HashSeedHtree[0]))); + Log2(("EXT: au32HashSeedHtree[1] %#RX32\n", RT_LE2H_U32(pSb->au32HashSeedHtree[1]))); + Log2(("EXT: au32HashSeedHtree[2] %#RX32\n", RT_LE2H_U32(pSb->au32HashSeedHtree[2]))); + Log2(("EXT: au32HashSeedHtree[3] %#RX32\n", RT_LE2H_U32(pSb->au32HashSeedHtree[3]))); + Log2(("EXT: u8HashVersionDef %#RX8\n", pSb->u8HashVersionDef)); + Log2(("EXT: u8JnlBackupType %#RX8\n", pSb->u8JnlBackupType)); + Log2(("EXT: cbGroupDesc %RU16\n", RT_LE2H_U16(pSb->cbGroupDesc))); + Log2(("EXT: fMntOptsDef %#RX32\n", RT_LE2H_U32(pSb->fMntOptsDef))); + Log2(("EXT: iFirstMetaBg %#RX32\n", RT_LE2H_U32(pSb->iFirstMetaBg))); + Log2(("EXT: u32TimeFsCreation %#RX32 %s\n", RT_LE2H_U32(pSb->u32TimeFsCreation), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pSb->u32TimeFsCreation)), sz, sizeof(sz)))); + for (unsigned i = 0; i < RT_ELEMENTS(pSb->au32JnlBlocks); i++) + Log2(("EXT: au32JnlBlocks[%u] %#RX32\n", i, RT_LE2H_U32(pSb->au32JnlBlocks[i]))); + Log2(("EXT: cBlocksTotalHigh %#RX32\n", RT_LE2H_U32(pSb->cBlocksTotalHigh))); + Log2(("EXT: cBlocksRsvdForSuperUserHigh %#RX32\n", RT_LE2H_U32(pSb->cBlocksRsvdForSuperUserHigh))); + Log2(("EXT: cBlocksFreeHigh %#RX32\n", RT_LE2H_U32(pSb->cBlocksFreeHigh))); + Log2(("EXT: cbInodesExtraMin %#RX16\n", RT_LE2H_U16(pSb->cbInodesExtraMin))); + Log2(("EXT: cbNewInodesRsv %#RX16\n", RT_LE2H_U16(pSb->cbInodesExtraMin))); + Log2(("EXT: fFlags %#RX32\n", RT_LE2H_U32(pSb->fFlags))); + Log2(("EXT: cRaidStride %RU16\n", RT_LE2H_U16(pSb->cRaidStride))); + Log2(("EXT: cSecMmpInterval %RU16\n", RT_LE2H_U16(pSb->cSecMmpInterval))); + Log2(("EXT: iMmpBlock %#RX64\n", RT_LE2H_U64(pSb->iMmpBlock))); + Log2(("EXT: cRaidStrideWidth %#RX32\n", RT_LE2H_U32(pSb->cRaidStrideWidth))); + Log2(("EXT: cLogGroupsPerFlex %RU8\n", pSb->cLogGroupsPerFlex)); + Log2(("EXT: u8ChksumType %RX8\n", pSb->u8ChksumType)); + Log2(("EXT: cKbWritten %#RX64\n", RT_LE2H_U64(pSb->cKbWritten))); + Log2(("EXT: iSnapshotInode %#RX32\n", RT_LE2H_U32(pSb->iSnapshotInode))); + Log2(("EXT: iSnapshotId %#RX32\n", RT_LE2H_U32(pSb->iSnapshotId))); + Log2(("EXT: cSnapshotRsvdBlocks %#RX64\n", RT_LE2H_U64(pSb->cSnapshotRsvdBlocks))); + Log2(("EXT: iSnapshotListInode %#RX32\n", RT_LE2H_U32(pSb->iSnapshotListInode))); + Log2(("EXT: cErrorsSeen %#RX32\n", RT_LE2H_U32(pSb->cErrorsSeen))); + Log2(("EXT: [...]\n")); /** @todo Missing fields if becoming interesting. */ + Log2(("EXT: iInodeLostFound %#RX32\n", RT_LE2H_U32(pSb->iInodeLostFound))); + Log2(("EXT: iInodeProjQuota %#RX32\n", RT_LE2H_U32(pSb->iInodeProjQuota))); + Log2(("EXT: u32ChksumSeed %#RX32\n", RT_LE2H_U32(pSb->u32ChksumSeed))); + Log2(("EXT: [...]\n")); /** @todo Missing fields if becoming interesting. */ + Log2(("EXT: u32Chksum %#RX32\n", RT_LE2H_U32(pSb->u32Chksum))); + } + } +} + + +/** + * Logs a ext filesystem block group descriptor. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param iBlockGroup Block group number. + * @param pBlockGroup Pointer to the block group. + */ +static void rtFsExtBlockGroup_Log(PRTFSEXTVOL pThis, uint32_t iBlockGroup, PCEXTBLOCKGROUPDESC pBlockGroup) +{ + if (LogIs2Enabled()) + { + uint64_t iBlockStart = (uint64_t)iBlockGroup * pThis->cBlocksPerGroup; + Log2(("EXT: Block group %#RX32 (blocks %#RX64 to %#RX64):\n", + iBlockGroup, iBlockStart, iBlockStart + pThis->cBlocksPerGroup - 1)); + Log2(("EXT: offBlockBitmapLow %#RX32\n", RT_LE2H_U32(pBlockGroup->v32.offBlockBitmapLow))); + Log2(("EXT: offInodeBitmapLow %#RX32\n", RT_LE2H_U32(pBlockGroup->v32.offInodeBitmapLow))); + Log2(("EXT: offInodeTableLow %#RX32\n", RT_LE2H_U32(pBlockGroup->v32.offInodeTableLow))); + Log2(("EXT: cBlocksFreeLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.cBlocksFreeLow))); + Log2(("EXT: cInodesFreeLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.cInodesFreeLow))); + Log2(("EXT: cDirectoriesLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.cDirectoriesLow))); + Log2(("EXT: fFlags %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.fFlags))); + Log2(("EXT: offSnapshotExclBitmapLow %#RX32\n", RT_LE2H_U32(pBlockGroup->v32.offSnapshotExclBitmapLow))); + Log2(("EXT: u16ChksumBlockBitmapLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.u16ChksumBlockBitmapLow))); + Log2(("EXT: u16ChksumInodeBitmapLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.u16ChksumInodeBitmapLow))); + Log2(("EXT: cInodeTblUnusedLow %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.cInodeTblUnusedLow))); + Log2(("EXT: u16Chksum %#RX16\n", RT_LE2H_U16(pBlockGroup->v32.u16Chksum))); + if (pThis->cbBlkGrpDesc == sizeof(EXTBLOCKGROUPDESC64)) + { + Log2(("EXT: offBlockBitmapHigh %#RX32\n", RT_LE2H_U32(pBlockGroup->v64.offBlockBitmapHigh))); + Log2(("EXT: offInodeBitmapHigh %#RX32\n", RT_LE2H_U32(pBlockGroup->v64.offInodeBitmapHigh))); + Log2(("EXT: offInodeTableHigh %#RX32\n", RT_LE2H_U32(pBlockGroup->v64.offInodeTableHigh))); + Log2(("EXT: cBlocksFreeHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.cBlocksFreeHigh))); + Log2(("EXT: cInodesFreeHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.cInodesFreeHigh))); + Log2(("EXT: cDirectoriesHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.cDirectoriesHigh))); + Log2(("EXT: cInodeTblUnusedHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.cInodeTblUnusedHigh))); + Log2(("EXT: offSnapshotExclBitmapHigh %#RX32\n", RT_LE2H_U32(pBlockGroup->v64.offSnapshotExclBitmapHigh))); + Log2(("EXT: u16ChksumBlockBitmapHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.u16ChksumBlockBitmapHigh))); + Log2(("EXT: u16ChksumInodeBitmapHigh %#RX16\n", RT_LE2H_U16(pBlockGroup->v64.u16ChksumInodeBitmapHigh))); + } + } +} + + +/** + * Logs a ext filesystem inode. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param iInode Inode number. + * @param pInode Pointer to the inode. + */ +static void rtFsExtInode_Log(PRTFSEXTVOL pThis, uint32_t iInode, PCEXTINODECOMB pInode) +{ + if (LogIs2Enabled()) + { + RTTIMESPEC Spec; + char sz[80]; + + Log2(("EXT: Inode %#RX32:\n", iInode)); + Log2(("EXT: fMode %#RX16\n", RT_LE2H_U16(pInode->Core.fMode))); + Log2(("EXT: uUidLow %#RX16\n", RT_LE2H_U16(pInode->Core.uUidLow))); + Log2(("EXT: cbSizeLow %#RX32\n", RT_LE2H_U32(pInode->Core.cbSizeLow))); + Log2(("EXT: u32TimeLastAccess %#RX32 %s\n", RT_LE2H_U32(pInode->Core.u32TimeLastAccess), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pInode->Core.u32TimeLastAccess)), sz, sizeof(sz)))); + Log2(("EXT: u32TimeLastChange %#RX32 %s\n", RT_LE2H_U32(pInode->Core.u32TimeLastChange), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pInode->Core.u32TimeLastChange)), sz, sizeof(sz)))); + Log2(("EXT: u32TimeLastModification %#RX32 %s\n", RT_LE2H_U32(pInode->Core.u32TimeLastModification), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pInode->Core.u32TimeLastModification)), sz, sizeof(sz)))); + Log2(("EXT: u32TimeDeletion %#RX32 %s\n", RT_LE2H_U32(pInode->Core.u32TimeDeletion), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pInode->Core.u32TimeDeletion)), sz, sizeof(sz)))); + Log2(("EXT: uGidLow %#RX16\n", RT_LE2H_U16(pInode->Core.uGidLow))); + Log2(("EXT: cHardLinks %#RU16\n", RT_LE2H_U16(pInode->Core.cHardLinks))); + Log2(("EXT: cBlocksLow %#RX32\n", RT_LE2H_U32(pInode->Core.cBlocksLow))); + Log2(("EXT: fFlags %#RX32\n", RT_LE2H_U32(pInode->Core.fFlags))); + Log2(("EXT: Osd1.u32LnxVersion %#RX32\n", RT_LE2H_U32(pInode->Core.Osd1.u32LnxVersion))); + for (unsigned i = 0; i < RT_ELEMENTS(pInode->Core.au32Block); i++) + Log2(("EXT: au32Block[%u] %#RX32\n", i, RT_LE2H_U32(pInode->Core.au32Block[i]))); + Log2(("EXT: u32Version %#RX32\n", RT_LE2H_U32(pInode->Core.u32Version))); + Log2(("EXT: offExtAttrLow %#RX32\n", RT_LE2H_U32(pInode->Core.offExtAttrLow))); + Log2(("EXT: cbSizeHigh %#RX32\n", RT_LE2H_U32(pInode->Core.cbSizeHigh))); + Log2(("EXT: u32FragmentAddrObs %#RX32\n", RT_LE2H_U32(pInode->Core.u32FragmentAddrObs))); + Log2(("EXT: Osd2.Lnx.cBlocksHigh %#RX32\n", RT_LE2H_U32(pInode->Core.Osd2.Lnx.cBlocksHigh))); + Log2(("EXT: Osd2.Lnx.offExtAttrHigh %#RX32\n", RT_LE2H_U32(pInode->Core.Osd2.Lnx.offExtAttrHigh))); + Log2(("EXT: Osd2.Lnx.uUidHigh %#RX16\n", RT_LE2H_U16(pInode->Core.Osd2.Lnx.uUidHigh))); + Log2(("EXT: Osd2.Lnx.uGidHigh %#RX16\n", RT_LE2H_U16(pInode->Core.Osd2.Lnx.uGidHigh))); + Log2(("EXT: Osd2.Lnx.u16ChksumLow %#RX16\n", RT_LE2H_U16(pInode->Core.Osd2.Lnx.u16ChksumLow))); + + if (pThis->cbInode >= sizeof(EXTINODECOMB)) + { + Log2(("EXT: cbInodeExtra %#RU16\n", RT_LE2H_U16(pInode->Extra.cbInodeExtra))); + Log2(("EXT: u16ChksumHigh %#RX16\n", RT_LE2H_U16(pInode->Extra.u16ChksumHigh))); + Log2(("EXT: u32ExtraTimeLastChange %#RX32\n", RT_LE2H_U16(pInode->Extra.u32ExtraTimeLastChange))); + Log2(("EXT: u32ExtraTimeLastModification %#RX32\n", RT_LE2H_U16(pInode->Extra.u32ExtraTimeLastModification))); + Log2(("EXT: u32ExtraTimeLastAccess %#RX32\n", RT_LE2H_U16(pInode->Extra.u32ExtraTimeLastAccess))); + Log2(("EXT: u32TimeCreation %#RX32 %s\n", RT_LE2H_U32(pInode->Extra.u32TimeCreation), + RTTimeSpecToString(RTTimeSpecSetSeconds(&Spec, RT_LE2H_U32(pInode->Extra.u32TimeCreation)), sz, sizeof(sz)))); + Log2(("EXT: u32ExtraTimeCreation %#RX32\n", RT_LE2H_U16(pInode->Extra.u32ExtraTimeCreation))); + Log2(("EXT: u32VersionHigh %#RX32\n", RT_LE2H_U16(pInode->Extra.u32VersionHigh))); + Log2(("EXT: u32ProjectId %#RX32\n", RT_LE2H_U16(pInode->Extra.u32ProjectId))); + } + } +} + + +/** + * Logs a ext filesystem directory entry. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param idxDirEntry Directory entry index number. + * @param pDirEntry The directory entry. + */ +static void rtFsExtDirEntry_Log(PRTFSEXTVOL pThis, uint32_t idxDirEntry, PCEXTDIRENTRYEX pDirEntry) +{ + if (LogIs2Enabled()) + { + int cbName = 0; + + Log2(("EXT: Directory entry %#RX32:\n", idxDirEntry)); + Log2(("EXT: iInodeRef %#RX32\n", RT_LE2H_U32(pDirEntry->Core.iInodeRef))); + Log2(("EXT: cbRecord %#RX32\n", RT_LE2H_U32(pDirEntry->Core.cbRecord))); + if (pThis->fFeaturesIncompat & EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE) + { + Log2(("EXT: cbName %#RU8\n", pDirEntry->Core.u.v2.cbName)); + Log2(("EXT: uType %#RX8\n", pDirEntry->Core.u.v2.uType)); + cbName = pDirEntry->Core.u.v2.cbName; + } + else + { + Log2(("EXT: cbName %#RU16\n", RT_LE2H_U16(pDirEntry->Core.u.v1.cbName))); + cbName = RT_LE2H_U16(pDirEntry->Core.u.v1.cbName); + } + Log2(("EXT: achName %*s\n", cbName, &pDirEntry->Core.achName[0])); + } +} + + +/** + * Logs an extent header. + * + * @returns nothing. + * @param pExtentHdr The extent header node. + */ +static void rtFsExtExtentHdr_Log(PCEXTEXTENTHDR pExtentHdr) +{ + if (LogIs2Enabled()) + { + Log2(("EXT: Extent header:\n")); + Log2(("EXT: u16Magic %#RX16\n", RT_LE2H_U32(pExtentHdr->u16Magic))); + Log2(("EXT: cEntries %#RX16\n", RT_LE2H_U32(pExtentHdr->cEntries))); + Log2(("EXT: cMax %#RX16\n", RT_LE2H_U32(pExtentHdr->cMax))); + Log2(("EXT: uDepth %#RX16\n", RT_LE2H_U32(pExtentHdr->uDepth))); + Log2(("EXT: cGeneration %#RX32\n", RT_LE2H_U32(pExtentHdr->cGeneration))); + } +} + + +/** + * Logs an extent index node. + * + * @returns nothing. + * @param pExtentIdx The extent index node. + */ +static void rtFsExtExtentIdx_Log(PCEXTEXTENTIDX pExtentIdx) +{ + if (LogIs2Enabled()) + { + Log2(("EXT: Extent index node:\n")); + Log2(("EXT: iBlock %#RX32\n", RT_LE2H_U32(pExtentIdx->iBlock))); + Log2(("EXT: offChildLow %#RX32\n", RT_LE2H_U32(pExtentIdx->offChildLow))); + Log2(("EXT: offChildHigh %#RX16\n", RT_LE2H_U16(pExtentIdx->offChildHigh))); + } +} + + +/** + * Logs an extent. + * + * @returns nothing. + * @param pExtent The extent. + */ +static void rtFsExtExtent_Log(PCEXTEXTENT pExtent) +{ + if (LogIs2Enabled()) + { + Log2(("EXT: Extent:\n")); + Log2(("EXT: iBlock %#RX32\n", RT_LE2H_U32(pExtent->iBlock))); + Log2(("EXT: cBlocks %#RX16\n", RT_LE2H_U16(pExtent->cBlocks))); + Log2(("EXT: offStartHigh %#RX16\n", RT_LE2H_U32(pExtent->offStartHigh))); + Log2(("EXT: offStartLow %#RX16\n", RT_LE2H_U16(pExtent->offStartLow))); + } +} +#endif + + +/** + * Converts a block number to a byte offset. + * + * @returns Offset in bytes for the given block number. + * @param pThis The ext volume instance. + * @param iBlock The block number to convert. + */ +DECLINLINE(uint64_t) rtFsExtBlockIdxToDiskOffset(PRTFSEXTVOL pThis, uint64_t iBlock) +{ + return iBlock << pThis->cBlockShift; +} + + +/** + * Converts a byte offset to a block number. + * + * @returns Block number. + * @param pThis The ext volume instance. + * @param iBlock The offset to convert. + */ +DECLINLINE(uint64_t) rtFsExtDiskOffsetToBlockIdx(PRTFSEXTVOL pThis, uint64_t off) +{ + return off >> pThis->cBlockShift; +} + + +/** + * Creates the proper block number from the given low and high parts in case a 64bit + * filesystem is used. + * + * @returns 64bit block number. + * @param pThis The ext volume instance. + * @param uLow The lower 32bit part. + * @param uHigh The upper 32bit part. + */ +DECLINLINE(uint64_t) rtFsExtBlockFromLowHigh(PRTFSEXTVOL pThis, uint32_t uLow, uint32_t uHigh) +{ + return pThis->f64Bit ? RT_MAKE_U64(uLow, uHigh): uLow; +} + + +/** + * Converts the given high and low parts of the block number to a byte offset. + * + * @returns Offset in bytes for the given block number. + * @param uLow The lower 32bit part of the block number. + * @param uHigh The upper 32bit part of the block number. + */ +DECLINLINE(uint64_t) rtFsExtBlockIdxLowHighToDiskOffset(PRTFSEXTVOL pThis, uint32_t uLow, uint32_t uHigh) +{ + uint64_t iBlock = rtFsExtBlockFromLowHigh(pThis, uLow, uHigh); + return rtFsExtBlockIdxToDiskOffset(pThis, iBlock); +} + + +/** + * Allocates a new block group. + * + * @returns Pointer to the new block group descriptor or NULL if out of memory. + * @param pThis The ext volume instance. + * @param cbAlloc How much to allocate. + * @param iBlockGroup Block group number. + */ +static PRTFSEXTBLOCKENTRY rtFsExtVol_BlockAlloc(PRTFSEXTVOL pThis, size_t cbAlloc, uint64_t iBlock) +{ + PRTFSEXTBLOCKENTRY pBlock = (PRTFSEXTBLOCKENTRY)RTMemAllocZ(cbAlloc); + if (RT_LIKELY(pBlock)) + { + pBlock->Core.Key = iBlock; + pBlock->cRefs = 0; + pThis->cbBlocks += cbAlloc; + } + + return pBlock; +} + + +/** + * Returns a new block entry utilizing the cache if possible. + * + * @returns Pointer to the new block entry or NULL if out of memory. + * @param pThis The ext volume instance. + * @param iBlock Block number. + */ +static PRTFSEXTBLOCKENTRY rtFsExtVol_BlockGetNew(PRTFSEXTVOL pThis, uint64_t iBlock) +{ + PRTFSEXTBLOCKENTRY pBlock = NULL; + size_t cbAlloc = RT_UOFFSETOF_DYN(RTFSEXTBLOCKENTRY, abData[pThis->cbBlock]); + if (pThis->cbBlocks + cbAlloc <= RTFSEXT_MAX_BLOCK_CACHE_SIZE) + pBlock = rtFsExtVol_BlockAlloc(pThis, cbAlloc, iBlock); + else + { + pBlock = RTListRemoveLast(&pThis->LstBlockLru, RTFSEXTBLOCKENTRY, NdLru); + if (!pBlock) + pBlock = rtFsExtVol_BlockAlloc(pThis, cbAlloc, iBlock); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->BlockRoot, pBlock->Core.Key); + Assert(pCore == &pBlock->Core); RT_NOREF(pCore); + } + } + + Assert(!pBlock->cRefs); + pBlock->Core.Key = iBlock; + pBlock->cRefs = 1; + + return pBlock; +} + + +/** + * Frees the given block. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pBlock The block to free. + */ +static void rtFsExtVol_BlockFree(PRTFSEXTVOL pThis, PRTFSEXTBLOCKENTRY pBlock) +{ + Assert(!pBlock->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the block group + * is freed right away. + */ + if (pThis->cbBlocks <= RTFSEXT_MAX_BLOCK_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstBlockLru, &pBlock->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->BlockRoot, pBlock->Core.Key); + Assert(pCore == &pBlock->Core); RT_NOREF(pCore); + RTMemFree(pBlock); + pThis->cbBlocks -= RT_UOFFSETOF_DYN(RTFSEXTBLOCKENTRY, abData[pThis->cbBlock]); + } +} + + +/** + * Gets the specified block data from the volume. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param iBlock The filesystem block to load. + * @param ppBlock Where to return the pointer to the block entry on success. + * @param ppvData Where to return the pointer to the block data on success. + */ +static int rtFsExtVol_BlockLoad(PRTFSEXTVOL pThis, uint64_t iBlock, PRTFSEXTBLOCKENTRY *ppBlock, void **ppvData) +{ + int rc = VINF_SUCCESS; + + /* Try to fetch the block group from the cache first. */ + PRTFSEXTBLOCKENTRY pBlock = (PRTFSEXTBLOCKENTRY)RTAvlU64Get(&pThis->BlockRoot, iBlock); + if (!pBlock) + { + /* Slow path, load from disk. */ + pBlock = rtFsExtVol_BlockGetNew(pThis, iBlock); + if (RT_LIKELY(pBlock)) + { + uint64_t offRead = rtFsExtBlockIdxToDiskOffset(pThis, iBlock); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &pBlock->abData[0], pThis->cbBlock, NULL); + if (RT_SUCCESS(rc)) + { + bool fIns = RTAvlU64Insert(&pThis->BlockRoot, &pBlock->Core); + Assert(fIns); RT_NOREF(fIns); + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pBlock->cRefs); + if (cRefs == 1) /* Blocks get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pBlock->NdLru); + } + + if (RT_SUCCESS(rc)) + { + *ppBlock = pBlock; + *ppvData = &pBlock->abData[0]; + } + else if (pBlock) + { + ASMAtomicDecU32(&pBlock->cRefs); + rtFsExtVol_BlockFree(pThis, pBlock); /* Free the block. */ + } + + return rc; +} + + +/** + * Releases a reference of the given block. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pBlock The block to release. + */ +static void rtFsExtVol_BlockRelease(PRTFSEXTVOL pThis, PRTFSEXTBLOCKENTRY pBlock) +{ + uint32_t cRefs = ASMAtomicDecU32(&pBlock->cRefs); + if (!cRefs) + rtFsExtVol_BlockFree(pThis, pBlock); +} + + +/** + * Allocates a new block group. + * + * @returns Pointer to the new block group descriptor or NULL if out of memory. + * @param pThis The ext volume instance. + * @param cbAlloc How much to allocate. + * @param iBlockGroup Block group number. + */ +static PRTFSEXTBLKGRP rtFsExtBlockGroupAlloc(PRTFSEXTVOL pThis, size_t cbAlloc, uint32_t iBlockGroup) +{ + PRTFSEXTBLKGRP pBlockGroup = (PRTFSEXTBLKGRP)RTMemAllocZ(cbAlloc); + if (RT_LIKELY(pBlockGroup)) + { + pBlockGroup->Core.Key = iBlockGroup; + pBlockGroup->cRefs = 0; + pBlockGroup->pabInodeBitmap = &pBlockGroup->abBlockBitmap[pThis->cbBlockBitmap]; + pThis->cbBlockGroups += cbAlloc; + } + + return pBlockGroup; +} + + +/** + * Frees the given block group. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pBlockGroup The block group to free. + */ +static void rtFsExtBlockGroupFree(PRTFSEXTVOL pThis, PRTFSEXTBLKGRP pBlockGroup) +{ + Assert(!pBlockGroup->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the block group + * is freed right away. + */ + if (pThis->cbBlockGroups <= RTFSEXT_MAX_BLOCK_GROUP_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstBlockGroupLru, &pBlockGroup->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->BlockGroupRoot, pBlockGroup->Core.Key); + Assert(pCore == &pBlockGroup->Core); RT_NOREF(pCore); + RTMemFree(pBlockGroup); + pThis->cbBlockGroups -= sizeof(RTFSEXTBLKGRP) + pThis->cbBlockBitmap + pThis->cbInodeBitmap; + } +} + + +/** + * Returns a new block group utilizing the cache if possible. + * + * @returns Pointer to the new block group descriptor or NULL if out of memory. + * @param pThis The ext volume instance. + * @param iBlockGroup Block group number. + */ +static PRTFSEXTBLKGRP rtFsExtBlockGroupGetNew(PRTFSEXTVOL pThis, uint32_t iBlockGroup) +{ + PRTFSEXTBLKGRP pBlockGroup = NULL; + size_t cbAlloc = sizeof(RTFSEXTBLKGRP) + pThis->cbBlockBitmap + pThis->cbInodeBitmap; + if (pThis->cbBlockGroups + cbAlloc <= RTFSEXT_MAX_BLOCK_GROUP_CACHE_SIZE) + pBlockGroup = rtFsExtBlockGroupAlloc(pThis, cbAlloc, iBlockGroup); + else + { + pBlockGroup = RTListRemoveLast(&pThis->LstBlockGroupLru, RTFSEXTBLKGRP, NdLru); + if (!pBlockGroup) + pBlockGroup = rtFsExtBlockGroupAlloc(pThis, cbAlloc, iBlockGroup); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->BlockGroupRoot, pBlockGroup->Core.Key); + Assert(pCore == &pBlockGroup->Core); RT_NOREF(pCore); + } + } + + Assert(!pBlockGroup->cRefs); + pBlockGroup->Core.Key = iBlockGroup; + pBlockGroup->cRefs = 1; + + return pBlockGroup; +} + + +/** + * Loads the given block group number and returns it on success. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param iBlockGroup The block group to load. + * @param ppBlockGroup Where to store the block group on success. + */ +static int rtFsExtBlockGroupLoad(PRTFSEXTVOL pThis, uint32_t iBlockGroup, PRTFSEXTBLKGRP *ppBlockGroup) +{ + int rc = VINF_SUCCESS; + + /* Try to fetch the block group from the cache first. */ + PRTFSEXTBLKGRP pBlockGroup = (PRTFSEXTBLKGRP)RTAvlU32Get(&pThis->BlockGroupRoot, iBlockGroup); + if (!pBlockGroup) + { + /* Slow path, load from disk. */ + pBlockGroup = rtFsExtBlockGroupGetNew(pThis, iBlockGroup); + if (RT_LIKELY(pBlockGroup)) + { + uint64_t offRead = rtFsExtBlockIdxToDiskOffset(pThis, pThis->cbBlock == _1K ? 2 : 1) + + (uint64_t)iBlockGroup * pThis->cbBlkGrpDesc; + EXTBLOCKGROUPDESC BlockGroupDesc; + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &BlockGroupDesc, pThis->cbBlkGrpDesc, NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsExtBlockGroup_Log(pThis, iBlockGroup, &BlockGroupDesc); +#endif + pBlockGroup->iBlockInodeTbl = RT_LE2H_U32(BlockGroupDesc.v32.offInodeTableLow) + | ((pThis->cbBlkGrpDesc == sizeof(EXTBLOCKGROUPDESC64)) + ? (uint64_t)RT_LE2H_U32(BlockGroupDesc.v64.offInodeTableHigh) << 32 + : 0); + + offRead = rtFsExtBlockIdxLowHighToDiskOffset(pThis, RT_LE2H_U32(BlockGroupDesc.v32.offBlockBitmapLow), + RT_LE2H_U32(BlockGroupDesc.v64.offBlockBitmapHigh)); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &pBlockGroup->abBlockBitmap[0], pThis->cbBlockBitmap, NULL); + if (RT_SUCCESS(rc)) + { + offRead = rtFsExtBlockIdxLowHighToDiskOffset(pThis, RT_LE2H_U32(BlockGroupDesc.v32.offInodeBitmapLow), + RT_LE2H_U32(BlockGroupDesc.v64.offInodeBitmapHigh)); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &pBlockGroup->pabInodeBitmap[0], pThis->cbInodeBitmap, NULL); + if (RT_SUCCESS(rc)) + { + bool fIns = RTAvlU32Insert(&pThis->BlockGroupRoot, &pBlockGroup->Core); + Assert(fIns); RT_NOREF(fIns); + } + } + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pBlockGroup->cRefs); + if (cRefs == 1) /* Block groups get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pBlockGroup->NdLru); + } + + if (RT_SUCCESS(rc)) + *ppBlockGroup = pBlockGroup; + else if (pBlockGroup) + { + ASMAtomicDecU32(&pBlockGroup->cRefs); + rtFsExtBlockGroupFree(pThis, pBlockGroup); /* Free the block group. */ + } + + return rc; +} + + +/** + * Releases a reference of the given block group. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pBlockGroup The block group to release. + */ +static void rtFsExtBlockGroupRelease(PRTFSEXTVOL pThis, PRTFSEXTBLKGRP pBlockGroup) +{ + uint32_t cRefs = ASMAtomicDecU32(&pBlockGroup->cRefs); + if (!cRefs) + rtFsExtBlockGroupFree(pThis, pBlockGroup); +} + + +/** + * Allocates a new inode. + * + * @returns Pointer to the new inode or NULL if out of memory. + * @param pThis The ext volume instance. + * @param iInode Inode number. + */ +static PRTFSEXTINODE rtFsExtInodeAlloc(PRTFSEXTVOL pThis, uint32_t iInode) +{ + PRTFSEXTINODE pInode = (PRTFSEXTINODE)RTMemAllocZ(sizeof(RTFSEXTINODE)); + if (RT_LIKELY(pInode)) + { + pInode->Core.Key = iInode; + pInode->cRefs = 0; + pThis->cbInodes += sizeof(RTFSEXTINODE); + } + + return pInode; +} + + +/** + * Frees the given inode. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pInode The inode to free. + */ +static void rtFsExtInodeFree(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode) +{ + Assert(!pInode->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the inode + * is freed right away. + */ + if (pThis->cbInodes <= RTFSEXT_MAX_INODE_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstInodeLru, &pInode->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->InodeRoot, pInode->Core.Key); + Assert(pCore == &pInode->Core); RT_NOREF(pCore); + RTMemFree(pInode); + pThis->cbInodes -= sizeof(RTFSEXTINODE); + } +} + + +/** + * Returns a new inodep utilizing the cache if possible. + * + * @returns Pointer to the new inode or NULL if out of memory. + * @param pThis The ext volume instance. + * @param iInode Inode number. + */ +static PRTFSEXTINODE rtFsExtInodeGetNew(PRTFSEXTVOL pThis, uint32_t iInode) +{ + PRTFSEXTINODE pInode = NULL; + if (pThis->cbInodes + sizeof(RTFSEXTINODE) <= RTFSEXT_MAX_INODE_CACHE_SIZE) + pInode = rtFsExtInodeAlloc(pThis, iInode); + else + { + pInode = RTListRemoveLast(&pThis->LstInodeLru, RTFSEXTINODE, NdLru); + if (!pInode) + pInode = rtFsExtInodeAlloc(pThis, iInode); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->InodeRoot, pInode->Core.Key); + Assert(pCore == &pInode->Core); RT_NOREF(pCore); + } + } + + Assert(!pInode->cRefs); + pInode->Core.Key = iInode; + pInode->cRefs = 1; + + return pInode; +} + + +/** + * Loads the given inode number and returns it on success. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param iInode The inode to load. + * @param ppInode Where to store the inode on success. + */ +static int rtFsExtInodeLoad(PRTFSEXTVOL pThis, uint32_t iInode, PRTFSEXTINODE *ppInode) +{ + int rc = VINF_SUCCESS; + + /* Try to fetch the inode from the cache first. */ + PRTFSEXTINODE pInode = (PRTFSEXTINODE)RTAvlU32Get(&pThis->InodeRoot, iInode); + if (!pInode) + { + /* Slow path, load from disk. */ + pInode = rtFsExtInodeGetNew(pThis, iInode); + if (RT_LIKELY(pInode)) + { + /* Calculate the block group and load that one first to get at the inode table location. */ + PRTFSEXTBLKGRP pBlockGroup = NULL; + rc = rtFsExtBlockGroupLoad(pThis, (iInode - 1) / pThis->cInodesPerGroup, &pBlockGroup); + if (RT_SUCCESS(rc)) + { + uint32_t idxInodeInTbl = (iInode - 1) % pThis->cInodesPerGroup; + uint64_t offRead = rtFsExtBlockIdxToDiskOffset(pThis, pBlockGroup->iBlockInodeTbl) + + idxInodeInTbl * pThis->cbInode; + + /* Release block group here already as it is not required. */ + rtFsExtBlockGroupRelease(pThis, pBlockGroup); + + EXTINODECOMB Inode; + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &Inode, RT_MIN(sizeof(Inode), pThis->cbInode), NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsExtInode_Log(pThis, iInode, &Inode); +#endif + pInode->offInode = offRead; + pInode->fFlags = RT_LE2H_U32(Inode.Core.fFlags); + pInode->ObjInfo.cbObject = (uint64_t)RT_LE2H_U32(Inode.Core.cbSizeHigh) << 32 + | (uint64_t)RT_LE2H_U32(Inode.Core.cbSizeLow); + pInode->ObjInfo.cbAllocated = ( (uint64_t)RT_LE2H_U16(Inode.Core.Osd2.Lnx.cBlocksHigh) << 32 + | (uint64_t)RT_LE2H_U32(Inode.Core.cBlocksLow)) * pThis->cbBlock; + RTTimeSpecSetSeconds(&pInode->ObjInfo.AccessTime, RT_LE2H_U32(Inode.Core.u32TimeLastAccess)); + RTTimeSpecSetSeconds(&pInode->ObjInfo.ModificationTime, RT_LE2H_U32(Inode.Core.u32TimeLastModification)); + RTTimeSpecSetSeconds(&pInode->ObjInfo.ChangeTime, RT_LE2H_U32(Inode.Core.u32TimeLastChange)); + pInode->ObjInfo.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + pInode->ObjInfo.Attr.u.Unix.uid = (uint32_t)RT_LE2H_U16(Inode.Core.Osd2.Lnx.uUidHigh) << 16 + | (uint32_t)RT_LE2H_U16(Inode.Core.uUidLow); + pInode->ObjInfo.Attr.u.Unix.gid = (uint32_t)RT_LE2H_U16(Inode.Core.Osd2.Lnx.uGidHigh) << 16 + | (uint32_t)RT_LE2H_U16(Inode.Core.uGidLow); + pInode->ObjInfo.Attr.u.Unix.cHardlinks = RT_LE2H_U16(Inode.Core.cHardLinks); + pInode->ObjInfo.Attr.u.Unix.INodeIdDevice = 0; + pInode->ObjInfo.Attr.u.Unix.INodeId = iInode; + pInode->ObjInfo.Attr.u.Unix.fFlags = 0; + pInode->ObjInfo.Attr.u.Unix.GenerationId = RT_LE2H_U32(Inode.Core.u32Version); + pInode->ObjInfo.Attr.u.Unix.Device = 0; + if (pThis->cbInode >= sizeof(EXTINODECOMB)) + RTTimeSpecSetSeconds(&pInode->ObjInfo.BirthTime, RT_LE2H_U32(Inode.Extra.u32TimeCreation)); + else + RTTimeSpecSetSeconds(&pInode->ObjInfo.BirthTime, RT_LE2H_U32(Inode.Core.u32TimeLastChange)); + for (unsigned i = 0; i < RT_ELEMENTS(pInode->aiBlocks); i++) + pInode->aiBlocks[i] = RT_LE2H_U32(Inode.Core.au32Block[i]); + + /* Fill in the mode. */ + pInode->ObjInfo.Attr.fMode = 0; + uint32_t fInodeMode = RT_LE2H_U32(Inode.Core.fMode); + switch (EXT_INODE_MODE_TYPE_GET_TYPE(fInodeMode)) + { + case EXT_INODE_MODE_TYPE_FIFO: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_FIFO; + break; + case EXT_INODE_MODE_TYPE_CHAR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DEV_CHAR; + break; + case EXT_INODE_MODE_TYPE_DIR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DIRECTORY; + break; + case EXT_INODE_MODE_TYPE_BLOCK: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DEV_BLOCK; + break; + case EXT_INODE_MODE_TYPE_REGULAR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_FILE; + break; + case EXT_INODE_MODE_TYPE_SYMLINK: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_SYMLINK; + break; + case EXT_INODE_MODE_TYPE_SOCKET: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_SOCKET; + break; + default: + rc = VERR_VFS_BOGUS_FORMAT; + } + if (fInodeMode & EXT_INODE_MODE_EXEC_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXOTH; + if (fInodeMode & EXT_INODE_MODE_WRITE_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWOTH; + if (fInodeMode & EXT_INODE_MODE_READ_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IROTH; + if (fInodeMode & EXT_INODE_MODE_EXEC_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXGRP; + if (fInodeMode & EXT_INODE_MODE_WRITE_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWGRP; + if (fInodeMode & EXT_INODE_MODE_READ_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IRGRP; + if (fInodeMode & EXT_INODE_MODE_EXEC_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXUSR; + if (fInodeMode & EXT_INODE_MODE_WRITE_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWUSR; + if (fInodeMode & EXT_INODE_MODE_READ_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IRUSR; + if (fInodeMode & EXT_INODE_MODE_STICKY) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISTXT; + if (fInodeMode & EXT_INODE_MODE_SET_GROUP_ID) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISGID; + if (fInodeMode & EXT_INODE_MODE_SET_USER_ID) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISUID; + } + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pInode->cRefs); + if (cRefs == 1) /* Inodes get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pInode->NdLru); + } + + if (RT_SUCCESS(rc)) + *ppInode = pInode; + else if (pInode) + { + ASMAtomicDecU32(&pInode->cRefs); + rtFsExtInodeFree(pThis, pInode); /* Free the inode. */ + } + + return rc; +} + + +/** + * Releases a reference of the given inode. + * + * @returns nothing. + * @param pThis The ext volume instance. + * @param pInode The inode to release. + */ +static void rtFsExtInodeRelease(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode) +{ + uint32_t cRefs = ASMAtomicDecU32(&pInode->cRefs); + if (!cRefs) + rtFsExtInodeFree(pThis, pInode); +} + + +/** + * Worker for various QueryInfo methods. + * + * @returns IPRT status code. + * @param pInode The inode structure to return info for. + * @param pObjInfo Where to return object info. + * @param enmAddAttr What additional info to return. + */ +static int rtFsExtInode_QueryInfo(PRTFSEXTINODE pInode, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_ZERO(*pObjInfo); + + pObjInfo->cbObject = pInode->ObjInfo.cbObject; + pObjInfo->cbAllocated = pInode->ObjInfo.cbAllocated; + pObjInfo->AccessTime = pInode->ObjInfo.AccessTime; + pObjInfo->ModificationTime = pInode->ObjInfo.ModificationTime; + pObjInfo->ChangeTime = pInode->ObjInfo.ChangeTime; + pObjInfo->BirthTime = pInode->ObjInfo.BirthTime; + pObjInfo->Attr.fMode = pInode->ObjInfo.Attr.fMode; + pObjInfo->Attr.enmAdditional = enmAddAttr; + switch (enmAddAttr) + { + case RTFSOBJATTRADD_UNIX: + memcpy(&pObjInfo->Attr.u.Unix, &pInode->ObjInfo.Attr.u.Unix, sizeof(pInode->ObjInfo.Attr.u.Unix)); + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = pInode->ObjInfo.Attr.u.Unix.uid; + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = pInode->ObjInfo.Attr.u.Unix.gid; + break; + + default: + break; + } + + return VINF_SUCCESS; +} + + +/** + * Validates a given extent header. + * + * @returns Flag whether the extent header appears to be valid. + * @param pExtentHdr The extent header to validate. + */ +DECLINLINE(bool) rtFsExtInode_ExtentHdrValidate(PCEXTEXTENTHDR pExtentHdr) +{ + return RT_LE2H_U16(pExtentHdr->u16Magic) == EXT_EXTENT_HDR_MAGIC + && RT_LE2H_U16(pExtentHdr->cEntries) <= RT_LE2H_U16(pExtentHdr->cMax) + && RT_LE2H_U16(pExtentHdr->uDepth) <= EXT_EXTENT_HDR_DEPTH_MAX; +} + + +/** + * Parses the given extent, checking whether it intersects with the given block. + * + * @returns Flag whether the extent maps the given range (at least partly). + * @param pExtent The extent to parse. + * @param iBlock The starting inode block to map. + * @param cBlocks Number of blocks requested. + * @param piBlockFs Where to store the filesystem block on success. + * @param pcBlocks Where to store the number of contiguous blocks on success. + * @param pfSparse Where to store the sparse flag on success. + */ +DECLINLINE(bool) rtFsExtInode_ExtentParse(PCEXTEXTENT pExtent, uint64_t iBlock, size_t cBlocks, + uint64_t *piBlockFs, size_t *pcBlocks, bool *pfSparse) +{ +#ifdef LOG_ENABLED + rtFsExtExtent_Log(pExtent); +#endif + + uint32_t iExtentBlock = RT_LE2H_U32(pExtent->iBlock); + uint16_t cExtentLength = RT_LE2H_U16(pExtent->cBlocks); + + /* Length over EXT_EXTENT_LENGTH_LIMIT blocks indicate a sparse extent. */ + if (cExtentLength > EXT_EXTENT_LENGTH_LIMIT) + { + *pfSparse = true; + cExtentLength -= EXT_EXTENT_LENGTH_LIMIT; + } + else + *pfSparse = false; + + if ( iExtentBlock <= iBlock + && iExtentBlock + cExtentLength > iBlock) + { + uint32_t iBlockRel = iBlock - iExtentBlock; + *pcBlocks = RT_MIN(cBlocks, cExtentLength - iBlockRel); + *piBlockFs = ( ((uint64_t)RT_LE2H_U16(pExtent->offStartHigh)) << 32 + | ((uint64_t)RT_LE2H_U32(pExtent->offStartLow))) + iBlockRel; + return true; + } + + return false; +} + + +/** + * Locates the location of the next level in the extent tree mapping the given block. + * + * @returns Filesystem block number where the next level of the extent is stored. + * @param paExtentIdx Pointer to the array of extent index nodes. + * @param cEntries Number of entries in the extent index node array. + * @param iBlock The block to resolve. + */ +DECLINLINE(uint64_t) rtFsExtInode_ExtentIndexLocateNextLvl(PCEXTEXTENTIDX paExtentIdx, uint16_t cEntries, uint64_t iBlock) +{ + for (uint32_t i = 1; i < cEntries; i++) + { + PCEXTEXTENTIDX pPrev = &paExtentIdx[i - 1]; + PCEXTEXTENTIDX pCur = &paExtentIdx[i]; + +#ifdef LOG_ENABLED + rtFsExtExtentIdx_Log(pPrev); +#endif + + if ( RT_LE2H_U32(pPrev->iBlock) <= iBlock + && RT_LE2H_U32(pCur->iBlock) > iBlock) + return (uint64_t)RT_LE2H_U16(pPrev->offChildHigh) << 32 + | (uint64_t)RT_LE2H_U32(pPrev->offChildLow); + } + + /* Nothing found so far, the blast extent index must cover the block as the array is sorted. */ + PCEXTEXTENTIDX pLast = &paExtentIdx[cEntries - 1]; +#ifdef LOG_ENABLED + rtFsExtExtentIdx_Log(pLast); +#endif + + return (uint64_t)RT_LE2H_U16(pLast->offChildHigh) << 32 + | (uint64_t)RT_LE2H_U32(pLast->offChildLow); +} + + +/** + * Maps the given inode block to the destination filesystem block using the embedded extent tree. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pInode The inode structure to read from. + * @param iBlock The starting inode block to map. + * @param cBlocks Number of blocks requested. + * @param piBlockFs Where to store the filesystem block on success. + * @param pcBlocks Where to store the number of contiguous blocks on success. + * @param pfSparse Where to store the sparse flag on success. + * + * @todo Optimize + */ +static int rtFsExtInode_MapBlockToFsViaExtent(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode, uint64_t iBlock, size_t cBlocks, + uint64_t *piBlockFs, size_t *pcBlocks, bool *pfSparse) +{ + int rc = VINF_SUCCESS; + + /* The root of the extent tree is located in the block data of the inode. */ + PCEXTEXTENTHDR pExtentHdr = (PCEXTEXTENTHDR)&pInode->aiBlocks[0]; + +#ifdef LOG_ENABLED + rtFsExtExtentHdr_Log(pExtentHdr); +#endif + + /* + * Some validation, the top level is located inside the inode block data + * and has a maxmimum of 4 entries. + */ + if ( rtFsExtInode_ExtentHdrValidate(pExtentHdr) + && RT_LE2H_U16(pExtentHdr->cMax) <= 4) + { + uint16_t uDepthCur = RT_LE2H_U16(pExtentHdr->uDepth); + if (!uDepthCur) + { + PCEXTEXTENT pExtent = (PCEXTEXTENT)(pExtentHdr + 1); + + rc = VERR_VFS_BOGUS_FORMAT; + for (uint32_t i = 0; i < RT_LE2H_U16(pExtentHdr->cEntries); i++) + { + /* Check whether the extent intersects with the block. */ + if (rtFsExtInode_ExtentParse(pExtent, iBlock, cBlocks, piBlockFs, pcBlocks, pfSparse)) + { + rc = VINF_SUCCESS; + break; + } + pExtent++; + } + } + else + { + uint8_t *pbExtent = NULL; + PRTFSEXTBLOCKENTRY pBlock = NULL; + uint64_t iBlockNext = 0; + PCEXTEXTENTIDX paExtentIdx = (PCEXTEXTENTIDX)(pExtentHdr + 1); + uint16_t cEntries = RT_LE2H_U16(pExtentHdr->cEntries); + + /* Descend the tree until we reached the leaf nodes. */ + do + { + iBlockNext = rtFsExtInode_ExtentIndexLocateNextLvl(paExtentIdx, cEntries, iBlock); + /* Read in the full block. */ + rc = rtFsExtVol_BlockLoad(pThis, iBlockNext, &pBlock, (void **)&pbExtent); + if (RT_SUCCESS(rc)) + { + pExtentHdr = (PCEXTEXTENTHDR)pbExtent; + +#ifdef LOG_ENABLED + rtFsExtExtentHdr_Log(pExtentHdr); +#endif + + if ( rtFsExtInode_ExtentHdrValidate(pExtentHdr) + && RT_LE2H_U16(pExtentHdr->cMax) <= (pThis->cbBlock - sizeof(EXTEXTENTHDR)) / sizeof(EXTEXTENTIDX) + && RT_LE2H_U16(pExtentHdr->uDepth) == uDepthCur - 1) + { + uDepthCur--; + cEntries = RT_LE2H_U16(pExtentHdr->cEntries); + paExtentIdx = (PCEXTEXTENTIDX)(pExtentHdr + 1); + if (uDepthCur) + rtFsExtVol_BlockRelease(pThis, pBlock); + } + else + rc = VERR_VFS_BOGUS_FORMAT; + } + } + while ( uDepthCur > 0 + && RT_SUCCESS(rc)); + + if (RT_SUCCESS(rc)) + { + Assert(!uDepthCur); + + /* We reached the leaf nodes. */ + PCEXTEXTENT pExtent = (PCEXTEXTENT)(pExtentHdr + 1); + for (uint32_t i = 0; i < RT_LE2H_U16(pExtentHdr->cEntries); i++) + { + /* Check whether the extent intersects with the block. */ + if (rtFsExtInode_ExtentParse(pExtent, iBlock, cBlocks, piBlockFs, pcBlocks, pfSparse)) + { + rc = VINF_SUCCESS; + break; + } + pExtent++; + } + } + + if (pBlock) + rtFsExtVol_BlockRelease(pThis, pBlock); + } + } + else + rc = VERR_VFS_BOGUS_FORMAT; + + return rc; +} + + +/** + * Maps the given inode block to the destination filesystem block using the original block mapping scheme. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pInode The inode structure to read from. + * @param iBlock The inode block to map. + * @param cBlocks Number of blocks requested. + * @param piBlockFs Where to store the filesystem block on success. + * @param pcBlocks Where to store the number of contiguous blocks on success. + * @param pfSparse Where to store the sparse flag on success. + * + * @todo Optimize and handle sparse files. + */ +static int rtFsExtInode_MapBlockToFsViaBlockMap(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode, uint64_t iBlock, size_t cBlocks, + uint64_t *piBlockFs, size_t *pcBlocks, bool *pfSparse) +{ + int rc = VINF_SUCCESS; + RT_NOREF(cBlocks); + + *pfSparse = false; + *pcBlocks = 1; + + /* The first 12 inode blocks are directly mapped from the inode. */ + if (iBlock <= 11) + *piBlockFs = pInode->aiBlocks[iBlock]; + else + { + uint32_t cEntriesPerBlockMap = (uint32_t)(pThis->cbBlock >> sizeof(uint32_t)); + + if (iBlock <= cEntriesPerBlockMap + 11) + { + /* Indirect block. */ + PRTFSEXTBLOCKENTRY pBlock = NULL; + uint32_t *paBlockMap = NULL; + rc = rtFsExtVol_BlockLoad(pThis, pInode->aiBlocks[12], &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + *piBlockFs = RT_LE2H_U32(paBlockMap[iBlock - 12]); + rtFsExtVol_BlockRelease(pThis, pBlock); + } + } + else if (iBlock <= cEntriesPerBlockMap * cEntriesPerBlockMap + cEntriesPerBlockMap + 11) + { + /* Double indirect block. */ + PRTFSEXTBLOCKENTRY pBlock = NULL; + uint32_t *paBlockMap = NULL; + + iBlock -= 12 + cEntriesPerBlockMap; + rc = rtFsExtVol_BlockLoad(pThis, pInode->aiBlocks[13], &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + uint32_t idxBlockL2 = iBlock / cEntriesPerBlockMap; + uint32_t idxBlockL1 = iBlock % cEntriesPerBlockMap; + uint32_t iBlockNext = RT_LE2H_U32(paBlockMap[idxBlockL2]); + + rtFsExtVol_BlockRelease(pThis, pBlock); + rc = rtFsExtVol_BlockLoad(pThis, iBlockNext, &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + *piBlockFs = RT_LE2H_U32(paBlockMap[idxBlockL1]); + rtFsExtVol_BlockRelease(pThis, pBlock); + } + } + } + else + { + /* Triple indirect block. */ + PRTFSEXTBLOCKENTRY pBlock = NULL; + uint32_t *paBlockMap = NULL; + + iBlock -= 12 + cEntriesPerBlockMap * cEntriesPerBlockMap + cEntriesPerBlockMap; + rc = rtFsExtVol_BlockLoad(pThis, pInode->aiBlocks[14], &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + uint32_t idxBlockL3 = iBlock / (cEntriesPerBlockMap * cEntriesPerBlockMap); + uint32_t iBlockNext = RT_LE2H_U32(paBlockMap[idxBlockL3]); + + rtFsExtVol_BlockRelease(pThis, pBlock); + rc = rtFsExtVol_BlockLoad(pThis, iBlockNext, &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + uint32_t idxBlockL2 = (iBlock % (cEntriesPerBlockMap * cEntriesPerBlockMap)) / cEntriesPerBlockMap; + uint32_t idxBlockL1 = iBlock % cEntriesPerBlockMap; + iBlockNext = RT_LE2H_U32(paBlockMap[idxBlockL2]); + + rtFsExtVol_BlockRelease(pThis, pBlock); + rc = rtFsExtVol_BlockLoad(pThis, iBlockNext, &pBlock, (void **)&paBlockMap); + if (RT_SUCCESS(rc)) + { + *piBlockFs = RT_LE2H_U32(paBlockMap[idxBlockL1]); + rtFsExtVol_BlockRelease(pThis, pBlock); + } + } + } + } + } + + return rc; +} + + +/** + * Maps the given inode block to the destination filesystem block. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pInode The inode structure to read from. + * @param iBlock The inode block to map. + * @param cBlocks Number of blocks requested. + * @param piBlockFs Where to store the filesystem block on success. + * @param pcBlocks Where to store the number of contiguous blocks on success. + * @param pfSparse Where to store the sparse flag on success. + * + * @todo Optimize + */ +static int rtFsExtInode_MapBlockToFs(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode, uint64_t iBlock, size_t cBlocks, + uint64_t *piBlockFs, size_t *pcBlocks, bool *pfSparse) +{ + if (pInode->fFlags & EXT_INODE_F_EXTENTS) + return rtFsExtInode_MapBlockToFsViaExtent(pThis, pInode, iBlock, cBlocks, piBlockFs, pcBlocks, pfSparse); + else + return rtFsExtInode_MapBlockToFsViaBlockMap(pThis, pInode, iBlock, cBlocks, piBlockFs, pcBlocks, pfSparse); +} + + +/** + * Reads data from the given inode at the given byte offset. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pInode The inode structure to read from. + * @param off The byte offset to start reading from. + * @param pvBuf Where to store the read data to. + * @param pcbRead Where to return the amount of data read. + */ +static int rtFsExtInode_Read(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode, uint64_t off, void *pvBuf, size_t cbRead, size_t *pcbRead) +{ + int rc = VINF_SUCCESS; + uint8_t *pbBuf = (uint8_t *)pvBuf; + + if (((uint64_t)pInode->ObjInfo.cbObject < off + cbRead)) + { + if (!pcbRead) + return VERR_EOF; + else + cbRead = (uint64_t)pInode->ObjInfo.cbObject - off; + } + + while ( cbRead + && RT_SUCCESS(rc)) + { + uint64_t iBlockStart = rtFsExtDiskOffsetToBlockIdx(pThis, off); + uint32_t offBlockStart = off % pThis->cbBlock; + + /* Resolve the inode block to the proper filesystem block. */ + uint64_t iBlockFs = 0; + size_t cBlocks = 0; + bool fSparse = false; + rc = rtFsExtInode_MapBlockToFs(pThis, pInode, iBlockStart, 1, &iBlockFs, &cBlocks, &fSparse); + if (RT_SUCCESS(rc)) + { + Assert(cBlocks == 1); + + size_t cbThisRead = RT_MIN(cbRead, pThis->cbBlock - offBlockStart); + + if (!fSparse) + { + uint64_t offRead = rtFsExtBlockIdxToDiskOffset(pThis, iBlockFs); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead + offBlockStart, pbBuf, cbThisRead, NULL); + } + else + memset(pbBuf, 0, cbThisRead); + + if (RT_SUCCESS(rc)) + { + pbBuf += cbThisRead; + cbRead -= cbThisRead; + off += cbThisRead; + if (pcbRead) + *pcbRead += cbThisRead; + } + } + } + + return rc; +} + + + +/* + * + * File operations. + * File operations. + * File operations. + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsExtFile_Close(void *pvThis) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + LogFlow(("rtFsExtFile_Close(%p/%p)\n", pThis, pThis->pInode)); + + rtFsExtInodeRelease(pThis->pVol, pThis->pInode); + pThis->pInode = NULL; + pThis->pVol = NULL; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsExtFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + return rtFsExtInode_QueryInfo(pThis->pInode, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsExtFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + if (off == -1) + off = pThis->offFile; + else + AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3); + + int rc; + size_t cbRead = pSgBuf->paSegs[0].cbSeg; + if (!pcbRead) + { + rc = rtFsExtInode_Read(pThis->pVol, pThis->pInode, (uint64_t)off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + if (RT_SUCCESS(rc)) + pThis->offFile = off + cbRead; + Log6(("rtFsExtFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc\n", off, pSgBuf->paSegs[0].cbSeg, rc)); + } + else + { + PRTFSEXTINODE pInode = pThis->pInode; + if (off >= pInode->ObjInfo.cbObject) + { + *pcbRead = 0; + rc = VINF_EOF; + } + else + { + if ((uint64_t)off + cbRead <= (uint64_t)pInode->ObjInfo.cbObject) + rc = rtFsExtInode_Read(pThis->pVol, pThis->pInode, (uint64_t)off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + else + { + /* Return VINF_EOF if beyond end-of-file. */ + cbRead = (size_t)(pInode->ObjInfo.cbObject - off); + rc = rtFsExtInode_Read(pThis->pVol, pThis->pInode, off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + if (RT_SUCCESS(rc)) + rc = VINF_EOF; + } + if (RT_SUCCESS(rc)) + { + pThis->offFile = off + cbRead; + *pcbRead = cbRead; + } + else + *pcbRead = 0; + } + Log6(("rtFsExtFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc *pcbRead=%#x\n", off, pSgBuf->paSegs[0].cbSeg, rc, *pcbRead)); + } + + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite} + */ +static DECLCALLBACK(int) rtFsExtFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten) +{ + RT_NOREF(pvThis, off, pSgBuf, fBlocking, pcbWritten); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsExtFile_Flush(void *pvThis) +{ + RT_NOREF(pvThis); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsExtFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + *poffActual = pThis->offFile; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsExtFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsExtFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsExtFile_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsExtFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + RTFOFF offNew; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offNew = offSeek; + break; + case RTFILE_SEEK_END: + offNew = pThis->pInode->ObjInfo.cbObject + offSeek; + break; + case RTFILE_SEEK_CURRENT: + offNew = (RTFOFF)pThis->offFile + offSeek; + break; + default: + return VERR_INVALID_PARAMETER; + } + if (offNew >= 0) + { + pThis->offFile = offNew; + *poffActual = offNew; + return VINF_SUCCESS; + } + return VERR_NEGATIVE_SEEK; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsExtFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSEXTFILE pThis = (PRTFSEXTFILE)pvThis; + *pcbFile = (uint64_t)pThis->pInode->ObjInfo.cbObject; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSetSize} + */ +static DECLCALLBACK(int) rtFsExtFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags) +{ + RT_NOREF(pvThis, cbFile, fFlags); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize} + */ +static DECLCALLBACK(int) rtFsExtFile_QueryMaxSize(void *pvThis, uint64_t *pcbMax) +{ + RT_NOREF(pvThis); + *pcbMax = INT64_MAX; /** @todo */ + return VINF_SUCCESS; +} + + +/** + * EXT file operations. + */ +static const RTVFSFILEOPS g_rtFsExtFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "EXT File", + rtFsExtFile_Close, + rtFsExtFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsExtFile_Read, + rtFsExtFile_Write, + rtFsExtFile_Flush, + NULL /*PollOne*/, + rtFsExtFile_Tell, + NULL /*pfnSkip*/, + NULL /*pfnZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + rtFsExtFile_SetMode, + rtFsExtFile_SetTimes, + rtFsExtFile_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsExtFile_Seek, + rtFsExtFile_QuerySize, + rtFsExtFile_SetSize, + rtFsExtFile_QueryMaxSize, + RTVFSFILEOPS_VERSION +}; + + +/** + * Creates a new VFS file from the given regular file inode. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param fOpen Open flags passed. + * @param iInode The inode for the file. + * @param phVfsFile Where to store the VFS file handle on success. + * @param pErrInfo Where to record additional error information on error, optional. + * @param pszWhat Logging prefix. + */ +static int rtFsExtVol_NewFile(PRTFSEXTVOL pThis, uint64_t fOpen, uint32_t iInode, + PRTVFSFILE phVfsFile, PRTERRINFO pErrInfo, const char *pszWhat) +{ + /* + * Load the inode and check that it really is a file. + */ + PRTFSEXTINODE pInode = NULL; + int rc = rtFsExtInodeLoad(pThis, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_FILE(pInode->ObjInfo.Attr.fMode)) + { + PRTFSEXTFILE pNewFile; + rc = RTVfsNewFile(&g_rtFsExtFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + pNewFile->pVol = pThis; + pNewFile->pInode = pInode; + pNewFile->offFile = 0; + } + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_A_FILE, "%s: fMode=%#RX32", pszWhat, pInode->ObjInfo.Attr.fMode); + + if (RT_FAILURE(rc)) + rtFsExtInodeRelease(pThis, pInode); + } + + return rc; +} + + + +/* + * + * EXT directory code. + * EXT directory code. + * EXT directory code. + * + */ + +/** + * Looks up an entry in the given directory inode. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pInode The directory inode structure to. + * @param pszEntry The entry to lookup. + * @param piInode Where to store the inode number if the entry was found. + */ +static int rtFsExtDir_Lookup(PRTFSEXTVOL pThis, PRTFSEXTINODE pInode, const char *pszEntry, uint32_t *piInode) +{ + uint64_t offEntry = 0; + int rc = VERR_FILE_NOT_FOUND; + uint32_t idxDirEntry = 0; + size_t cchEntry = strlen(pszEntry); + + if (cchEntry > 255) + return VERR_FILENAME_TOO_LONG; + + while (offEntry < (uint64_t)pInode->ObjInfo.cbObject) + { + EXTDIRENTRYEX DirEntry; + size_t cbThis = RT_MIN(sizeof(DirEntry), (uint64_t)pInode->ObjInfo.cbObject - offEntry); + int rc2 = rtFsExtInode_Read(pThis, pInode, offEntry, &DirEntry, cbThis, NULL); + if (RT_SUCCESS(rc2)) + { +#ifdef LOG_ENABLED + rtFsExtDirEntry_Log(pThis, idxDirEntry, &DirEntry); +#endif + + uint16_t cbName = pThis->fFeaturesIncompat & EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE + ? DirEntry.Core.u.v2.cbName + : RT_LE2H_U16(DirEntry.Core.u.v1.cbName); + if ( cchEntry == cbName + && !memcmp(pszEntry, &DirEntry.Core.achName[0], cchEntry)) + { + *piInode = RT_LE2H_U32(DirEntry.Core.iInodeRef); + rc = VINF_SUCCESS; + break; + } + + offEntry += RT_LE2H_U16(DirEntry.Core.cbRecord); + idxDirEntry++; + } + else + { + rc = rc2; + break; + } + } + + return rc; +} + + + +/* + * + * Directory instance methods + * Directory instance methods + * Directory instance methods + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsExtDir_Close(void *pvThis) +{ + PRTFSEXTDIR pThis = (PRTFSEXTDIR)pvThis; + LogFlowFunc(("pThis=%p\n", pThis)); + rtFsExtInodeRelease(pThis->pVol, pThis->pInode); + pThis->pInode = NULL; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsExtDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSEXTDIR pThis = (PRTFSEXTDIR)pvThis; + LogFlowFunc(("\n")); + return rtFsExtInode_QueryInfo(pThis->pInode, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsExtDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsExtDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsExtDir_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpen} + */ +static DECLCALLBACK(int) rtFsExtDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen, + uint32_t fFlags, PRTVFSOBJ phVfsObj) +{ + LogFlowFunc(("pszEntry='%s' fOpen=%#RX64 fFlags=%#x\n", pszEntry, fOpen, fFlags)); + PRTFSEXTDIR pThis = (PRTFSEXTDIR)pvThis; + PRTFSEXTVOL pVol = pThis->pVol; + int rc = VINF_SUCCESS; + + RT_NOREF(fFlags); + + /* + * We cannot create or replace anything, just open stuff. + */ + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { /* likely */ } + else + return VERR_WRITE_PROTECT; + + /* + * Lookup the entry. + */ + uint32_t iInode = 0; + rc = rtFsExtDir_Lookup(pVol, pThis->pInode, pszEntry, &iInode); + if (RT_SUCCESS(rc)) + { + PRTFSEXTINODE pInode = NULL; + rc = rtFsExtInodeLoad(pVol, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(pInode->ObjInfo.Attr.fMode)) + { + RTVFSDIR hVfsDir; + rc = rtFsExtVol_OpenDirByInode(pVol, iInode, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else if (RTFS_IS_FILE(pInode->ObjInfo.Attr.fMode)) + { + RTVFSFILE hVfsFile; + rc = rtFsExtVol_NewFile(pVol, fOpen, iInode, &hVfsFile, NULL, pszEntry); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_NOT_SUPPORTED; + } + } + + LogFlow(("rtFsExtDir_Open(%s): returns %Rrc\n", pszEntry, rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateDir} + */ +static DECLCALLBACK(int) rtFsExtDir_CreateDir(void *pvThis, const char *pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir) +{ + RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink} + */ +static DECLCALLBACK(int) rtFsExtDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, phVfsSymlink); + LogFlowFunc(("\n")); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink} + */ +static DECLCALLBACK(int) rtFsExtDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget, + RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry} + */ +static DECLCALLBACK(int) rtFsExtDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType) +{ + RT_NOREF(pvThis, pszEntry, fType); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry} + */ +static DECLCALLBACK(int) rtFsExtDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName) +{ + RT_NOREF(pvThis, pszEntry, fType, pszNewName); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRewindDir} + */ +static DECLCALLBACK(int) rtFsExtDir_RewindDir(void *pvThis) +{ + PRTFSEXTDIR pThis = (PRTFSEXTDIR)pvThis; + LogFlowFunc(("\n")); + + pThis->fNoMoreFiles = false; + pThis->offEntry = 0; + pThis->idxEntry = 0; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnReadDir} + */ +static DECLCALLBACK(int) rtFsExtDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + PRTFSEXTDIR pThis = (PRTFSEXTDIR)pvThis; + PRTFSEXTINODE pInode = pThis->pInode; + LogFlowFunc(("\n")); + + if (pThis->fNoMoreFiles) + return VERR_NO_MORE_FILES; + + EXTDIRENTRYEX DirEntry; + size_t cbThis = RT_MIN(sizeof(DirEntry), (uint64_t)pInode->ObjInfo.cbObject - pThis->offEntry); + int rc = rtFsExtInode_Read(pThis->pVol, pInode, pThis->offEntry, &DirEntry, cbThis, NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsExtDirEntry_Log(pThis->pVol, pThis->idxEntry, &DirEntry); +#endif + + /* 0 inode entry means unused entry. */ + /** @todo Can there be unused entries somewhere in the middle? */ + uint32_t iInodeRef = RT_LE2H_U32(DirEntry.Core.iInodeRef); + if (iInodeRef != 0) + { + uint16_t cbName = pThis->pVol->fFeaturesIncompat & EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE + ? DirEntry.Core.u.v2.cbName + : RT_LE2H_U16(DirEntry.Core.u.v1.cbName); + + if (cbName <= 255) + { + size_t const cbDirEntry = *pcbDirEntry; + + *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cbName + 2]); + if (*pcbDirEntry <= cbDirEntry) + { + /* Load the referenced inode. */ + PRTFSEXTINODE pInodeRef; + rc = rtFsExtInodeLoad(pThis->pVol, iInodeRef, &pInodeRef); + if (RT_SUCCESS(rc)) + { + memcpy(&pDirEntry->szName[0], &DirEntry.Core.achName[0], cbName); + pDirEntry->szName[cbName] = '\0'; + pDirEntry->cbName = cbName; + rc = rtFsExtInode_QueryInfo(pInode, &pDirEntry->Info, enmAddAttr); + if (RT_SUCCESS(rc)) + { + pThis->offEntry += RT_LE2H_U16(DirEntry.Core.cbRecord); + pThis->idxEntry++; + rtFsExtInodeRelease(pThis->pVol, pInode); + return VINF_SUCCESS; + } + rtFsExtInodeRelease(pThis->pVol, pInode); + } + } + else + rc = VERR_BUFFER_OVERFLOW; + } + else + rc = VERR_FILENAME_TOO_LONG; + } + else + { + rc = VERR_NO_MORE_FILES; + LogFlowFunc(("no more files\n")); + pThis->fNoMoreFiles = true; + } + } + + return rc; +} + + +/** + * EXT directory operations. + */ +static const RTVFSDIROPS g_rtFsExtDirOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_DIR, + "EXT Dir", + rtFsExtDir_Close, + rtFsExtDir_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSDIROPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj), + rtFsExtDir_SetMode, + rtFsExtDir_SetTimes, + rtFsExtDir_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsExtDir_Open, + NULL /* pfnFollowAbsoluteSymlink */, + NULL /* pfnOpenFile */, + NULL /* pfnOpenDir */, + rtFsExtDir_CreateDir, + rtFsExtDir_OpenSymlink, + rtFsExtDir_CreateSymlink, + NULL /* pfnQueryEntryInfo */, + rtFsExtDir_UnlinkEntry, + rtFsExtDir_RenameEntry, + rtFsExtDir_RewindDir, + rtFsExtDir_ReadDir, + RTVFSDIROPS_VERSION, +}; + + +/** + * Opens a directory by the given inode. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param iInode The inode to open. + * @param phVfsDir Where to store the handle to the VFS directory on success. + */ +static int rtFsExtVol_OpenDirByInode(PRTFSEXTVOL pThis, uint32_t iInode, PRTVFSDIR phVfsDir) +{ + PRTFSEXTINODE pInode = NULL; + int rc = rtFsExtInodeLoad(pThis, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(pInode->ObjInfo.Attr.fMode)) + { + PRTFSEXTDIR pNewDir; + rc = RTVfsNewDir(&g_rtFsExtDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsDir, (void **)&pNewDir); + if (RT_SUCCESS(rc)) + { + pNewDir->fNoMoreFiles = false; + pNewDir->pVol = pThis; + pNewDir->pInode = pInode; + } + } + else + rc = VERR_VFS_BOGUS_FORMAT; + + if (RT_FAILURE(rc)) + rtFsExtInodeRelease(pThis, pInode); + } + + return rc; +} + + + +/* + * + * Volume level code. + * Volume level code. + * Volume level code. + * + */ + +/** + * Checks whether the block range in the given block group is in use by checking the + * block bitmap. + * + * @returns Flag whether the range is in use. + * @param pBlkGrpDesc The block group to check for. + * @param iBlockStart The starting block to check relative from the beginning of the block group. + * @param cBlocks How many blocks to check. + */ +static bool rtFsExtIsBlockRangeInUse(PRTFSEXTBLKGRP pBlkGrpDesc, uint64_t iBlockStart, size_t cBlocks) +{ + /** @todo Optimize with ASMBitFirstSet(). */ + while (cBlocks) + { + uint32_t idxByte = iBlockStart / 8; + uint32_t iBit = iBlockStart % 8; + + if (pBlkGrpDesc->abBlockBitmap[idxByte] & RT_BIT(iBit)) + return true; + + cBlocks--; + iBlockStart++; + } + + return false; +} + + +static DECLCALLBACK(int) rtFsExtVolBlockGroupTreeDestroy(PAVLU32NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSEXTBLKGRP pBlockGroup = (PRTFSEXTBLKGRP)pCore; + Assert(!pBlockGroup->cRefs); + RTMemFree(pBlockGroup); + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtFsExtVolInodeTreeDestroy(PAVLU32NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSEXTINODE pInode = (PRTFSEXTINODE)pCore; + Assert(!pInode->cRefs); + RTMemFree(pInode); + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtFsExtVolBlockTreeDestroy(PAVLU64NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSEXTBLOCKENTRY pBlock = (PRTFSEXTBLOCKENTRY)pCore; + Assert(!pBlock->cRefs); + RTMemFree(pBlock); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose} + */ +static DECLCALLBACK(int) rtFsExtVol_Close(void *pvThis) +{ + PRTFSEXTVOL pThis = (PRTFSEXTVOL)pvThis; + + /* Destroy the block group tree. */ + RTAvlU32Destroy(&pThis->BlockGroupRoot, rtFsExtVolBlockGroupTreeDestroy, pThis); + pThis->BlockGroupRoot = NULL; + RTListInit(&pThis->LstBlockGroupLru); + + /* Destroy the inode tree. */ + RTAvlU32Destroy(&pThis->InodeRoot, rtFsExtVolInodeTreeDestroy, pThis); + pThis->InodeRoot = NULL; + RTListInit(&pThis->LstInodeLru); + + /* Destroy the block cache tree. */ + RTAvlU64Destroy(&pThis->BlockRoot, rtFsExtVolBlockTreeDestroy, pThis); + pThis->BlockRoot = NULL; + RTListInit(&pThis->LstBlockLru); + + /* + * Backing file and handles. + */ + RTVfsFileRelease(pThis->hVfsBacking); + pThis->hVfsBacking = NIL_RTVFSFILE; + pThis->hVfsSelf = NIL_RTVFS; + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsExtVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_NOREF(pvThis, pObjInfo, enmAddAttr); + return VERR_WRONG_TYPE; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnOpenRoot} + */ +static DECLCALLBACK(int) rtFsExtVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir) +{ + PRTFSEXTVOL pThis = (PRTFSEXTVOL)pvThis; + int rc = rtFsExtVol_OpenDirByInode(pThis, EXT_INODE_NR_ROOT_DIR, phVfsDir); + LogFlowFunc(("returns %Rrc\n", rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryRangeState} + */ +static DECLCALLBACK(int) rtFsExtVol_QueryRangeState(void *pvThis, uint64_t off, size_t cb, bool *pfUsed) +{ + int rc = VINF_SUCCESS; + PRTFSEXTVOL pThis = (PRTFSEXTVOL)pvThis; + + *pfUsed = false; + + uint64_t iBlock = rtFsExtDiskOffsetToBlockIdx(pThis, off); + uint64_t cBlocks = rtFsExtDiskOffsetToBlockIdx(pThis, cb) + (cb % pThis->cbBlock ? 1 : 0); + while (cBlocks > 0) + { + uint32_t const iBlockGroup = iBlock / pThis->cBlocksPerGroup; + uint32_t const iBlockRelStart = iBlock - iBlockGroup * pThis->cBlocksPerGroup; + PRTFSEXTBLKGRP pBlockGroup = NULL; + + rc = rtFsExtBlockGroupLoad(pThis, iBlockGroup, &pBlockGroup); + if (RT_FAILURE(rc)) + break; + + uint64_t cBlocksThis = RT_MIN(cBlocks, iBlockRelStart - pThis->cBlocksPerGroup); + if (rtFsExtIsBlockRangeInUse(pBlockGroup, iBlockRelStart, cBlocksThis)) + { + *pfUsed = true; + break; + } + + rtFsExtBlockGroupRelease(pThis, pBlockGroup); + cBlocks -= cBlocksThis; + iBlock += cBlocksThis; + } + + return rc; +} + + +DECL_HIDDEN_CONST(const RTVFSOPS) g_rtFsExtVolOps = +{ + /* .Obj = */ + { + /* .uVersion = */ RTVFSOBJOPS_VERSION, + /* .enmType = */ RTVFSOBJTYPE_VFS, + /* .pszName = */ "ExtVol", + /* .pfnClose = */ rtFsExtVol_Close, + /* .pfnQueryInfo = */ rtFsExtVol_QueryInfo, + /* .uEndMarker = */ RTVFSOBJOPS_VERSION + }, + /* .uVersion = */ RTVFSOPS_VERSION, + /* .fFeatures = */ 0, + /* .pfnOpenRoot = */ rtFsExtVol_OpenRoot, + /* .pfnQueryRangeState = */ rtFsExtVol_QueryRangeState, + /* .uEndMarker = */ RTVFSOPS_VERSION +}; + + + +/** + * Loads the parameters from the given original ext2 format superblock (EXT_SB_REV_ORIG). + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pSb The superblock to load. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsExtVolLoadAndParseSuperBlockV0(PRTFSEXTVOL pThis, PCEXTSUPERBLOCK pSb, PRTERRINFO pErrInfo) +{ + RT_NOREF(pErrInfo); + + /* + * Linux never supported a differing cluster (also called fragment) size for + * the original ext2 layout so we reject such filesystems as it is not clear what + * the purpose is really. + */ + if (RT_LE2H_U32(pSb->cLogBlockSize) != RT_LE2H_U32(pSb->cLogClusterSize)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "EXT filesystem cluster and block size differ"); + + pThis->f64Bit = false; + pThis->cBlockShift = 10 + RT_LE2H_U32(pSb->cLogBlockSize); + pThis->cbBlock = UINT64_C(1) << pThis->cBlockShift; + pThis->cbInode = sizeof(EXTINODE); + pThis->cbBlkGrpDesc = sizeof(EXTBLOCKGROUPDESC32); + pThis->cBlocksPerGroup = RT_LE2H_U32(pSb->cBlocksPerGroup); + pThis->cInodesPerGroup = RT_LE2H_U32(pSb->cInodesPerBlockGroup); + pThis->cBlockGroups = RT_LE2H_U32(pSb->cBlocksTotalLow) / pThis->cBlocksPerGroup; + pThis->cbBlockBitmap = pThis->cBlocksPerGroup / 8; + if (pThis->cBlocksPerGroup % 8) + pThis->cbBlockBitmap++; + pThis->cbInodeBitmap = pThis->cInodesPerGroup / 8; + if (pThis->cInodesPerGroup % 8) + pThis->cbInodeBitmap++; + + return VINF_SUCCESS; +} + + +/** + * Loads the parameters from the given ext superblock (EXT_SB_REV_V2_DYN_INODE_SZ). + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pSb The superblock to load. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsExtVolLoadAndParseSuperBlockV1(PRTFSEXTVOL pThis, PCEXTSUPERBLOCK pSb, PRTERRINFO pErrInfo) +{ + if ((RT_LE2H_U32(pSb->fFeaturesIncompat) & ~RTFSEXT_INCOMPAT_FEATURES_SUPP) != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "EXT filesystem contains unsupported incompatible features: %RX32", + RT_LE2H_U32(pSb->fFeaturesIncompat) & ~RTFSEXT_INCOMPAT_FEATURES_SUPP); + if ( RT_LE2H_U32(pSb->fFeaturesCompatRo) != 0 + && !(pThis->fMntFlags & RTVFSMNT_F_READ_ONLY)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "EXT filesystem contains unsupported readonly features: %RX32", + RT_LE2H_U32(pSb->fFeaturesCompatRo)); + + pThis->fFeaturesIncompat = RT_LE2H_U32(pSb->fFeaturesIncompat); + pThis->f64Bit = RT_BOOL(pThis->fFeaturesIncompat & EXT_SB_FEAT_INCOMPAT_64BIT); + pThis->cBlockShift = 10 + RT_LE2H_U32(pSb->cLogBlockSize); + pThis->cbBlock = UINT64_C(1) << pThis->cBlockShift; + pThis->cbInode = RT_LE2H_U16(pSb->cbInode); + pThis->cbBlkGrpDesc = pThis->f64Bit ? RT_LE2H_U16(pSb->cbGroupDesc) : sizeof(EXTBLOCKGROUPDESC32); + pThis->cBlocksPerGroup = RT_LE2H_U32(pSb->cBlocksPerGroup); + pThis->cInodesPerGroup = RT_LE2H_U32(pSb->cInodesPerBlockGroup); + pThis->cBlockGroups = RT_LE2H_U32(pSb->cBlocksTotalLow) / pThis->cBlocksPerGroup; + pThis->cbBlockBitmap = pThis->cBlocksPerGroup / 8; + if (pThis->cBlocksPerGroup % 8) + pThis->cbBlockBitmap++; + pThis->cbInodeBitmap = pThis->cInodesPerGroup / 8; + if (pThis->cInodesPerGroup % 8) + pThis->cbInodeBitmap++; + + return VINF_SUCCESS; +} + + +/** + * Loads and parses the superblock of the filesystem. + * + * @returns IPRT status code. + * @param pThis The ext volume instance. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsExtVolLoadAndParseSuperblock(PRTFSEXTVOL pThis, PRTERRINFO pErrInfo) +{ + int rc = VINF_SUCCESS; + EXTSUPERBLOCK Sb; + rc = RTVfsFileReadAt(pThis->hVfsBacking, EXT_SB_OFFSET, &Sb, sizeof(EXTSUPERBLOCK), NULL); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading super block"); + + /* Validate the superblock. */ + if (RT_LE2H_U16(Sb.u16Signature) != EXT_SB_SIGNATURE) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not EXT - Signature mismatch: %RX16", RT_LE2H_U16(Sb.u16Signature)); + +#ifdef LOG_ENABLED + rtFsExtSb_Log(&Sb); +#endif + + if (RT_LE2H_U16(Sb.u16FilesystemState) == EXT_SB_STATE_ERRORS) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "EXT filesystem contains errors"); + + if (RT_LE2H_U32(Sb.u32RevLvl) == EXT_SB_REV_ORIG) + rc = rtFsExtVolLoadAndParseSuperBlockV0(pThis, &Sb, pErrInfo); + else + rc = rtFsExtVolLoadAndParseSuperBlockV1(pThis, &Sb, pErrInfo); + + return rc; +} + + +RTDECL(int) RTFsExtVolOpen(RTVFSFILE hVfsFileIn, uint32_t fMntFlags, uint32_t fExtFlags, PRTVFS phVfs, PRTERRINFO pErrInfo) +{ + AssertPtrReturn(phVfs, VERR_INVALID_POINTER); + AssertReturn(!(fMntFlags & ~RTVFSMNT_F_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(!fExtFlags, VERR_INVALID_FLAGS); + + uint32_t cRefs = RTVfsFileRetain(hVfsFileIn); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a VFS instance and initialize the data so rtFsExtVol_Close works. + */ + RTVFS hVfs; + PRTFSEXTVOL pThis; + int rc = RTVfsNew(&g_rtFsExtVolOps, sizeof(*pThis), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis); + if (RT_SUCCESS(rc)) + { + pThis->hVfsBacking = hVfsFileIn; + pThis->hVfsSelf = hVfs; + pThis->fMntFlags = fMntFlags; + pThis->fExtFlags = fExtFlags; + pThis->BlockGroupRoot = NULL; + pThis->InodeRoot = NULL; + pThis->BlockRoot = NULL; + pThis->cbBlockGroups = 0; + pThis->cbInodes = 0; + pThis->cbBlocks = 0; + RTListInit(&pThis->LstBlockGroupLru); + RTListInit(&pThis->LstInodeLru); + RTListInit(&pThis->LstBlockLru); + + rc = RTVfsFileGetSize(pThis->hVfsBacking, &pThis->cbBacking); + if (RT_SUCCESS(rc)) + { + rc = rtFsExtVolLoadAndParseSuperblock(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + { + *phVfs = hVfs; + return VINF_SUCCESS; + } + } + + RTVfsRelease(hVfs); + *phVfs = NIL_RTVFS; + } + else + RTVfsFileRelease(hVfsFileIn); + + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate} + */ +static DECLCALLBACK(int) rtVfsChainExtVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec, + PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg); + + /* + * Basic checks. + */ + if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE) + return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE; + if ( pElement->enmType != RTVFSOBJTYPE_VFS + && pElement->enmType != RTVFSOBJTYPE_DIR) + return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS; + if (pElement->cArgs > 1) + return VERR_VFS_CHAIN_AT_MOST_ONE_ARG; + + /* + * Parse the flag if present, save in pElement->uProvider. + */ + bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ; + if (pElement->cArgs > 0) + { + const char *psz = pElement->paArgs[0].psz; + if (*psz) + { + if (!strcmp(psz, "ro")) + fReadOnly = true; + else if (!strcmp(psz, "rw")) + fReadOnly = false; + else + { + *poffError = pElement->paArgs[0].offSpec; + return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument"); + } + } + } + + pElement->uProvider = fReadOnly ? RTVFSMNT_F_READ_ONLY : 0; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate} + */ +static DECLCALLBACK(int) rtVfsChainExtVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec, + PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj, + PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec, poffError); + + int rc; + RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj); + if (hVfsFileIn != NIL_RTVFSFILE) + { + RTVFS hVfs; + rc = RTFsExtVolOpen(hVfsFileIn, (uint32_t)pElement->uProvider, (uint32_t)(pElement->uProvider >> 32), &hVfs, pErrInfo); + RTVfsFileRelease(hVfsFileIn); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromVfs(hVfs); + RTVfsRelease(hVfs); + if (*phVfsObj != NIL_RTVFSOBJ) + return VINF_SUCCESS; + rc = VERR_VFS_CHAIN_CAST_FAILED; + } + } + else + rc = VERR_VFS_CHAIN_CAST_FAILED; + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement} + */ +static DECLCALLBACK(bool) rtVfsChainExtVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg, + PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement, + PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement) +{ + RT_NOREF(pProviderReg, pSpec, pReuseSpec); + if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider + || !pReuseElement->paArgs[0].uProvider) + return true; + return false; +} + + +/** VFS chain element 'ext'. */ +static RTVFSCHAINELEMENTREG g_rtVfsChainExtVolReg = +{ + /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION, + /* fReserved = */ 0, + /* pszName = */ "ext", + /* ListEntry = */ { NULL, NULL }, + /* pszHelp = */ "Open a EXT file system, requires a file object on the left side.\n" + "First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n", + /* pfnValidate = */ rtVfsChainExtVol_Validate, + /* pfnInstantiate = */ rtVfsChainExtVol_Instantiate, + /* pfnCanReuseElement = */ rtVfsChainExtVol_CanReuseElement, + /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION +}; + +RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainExtVolReg, rtVfsChainExtVolReg); + diff --git a/src/VBox/Runtime/common/fs/fatvfs.cpp b/src/VBox/Runtime/common/fs/fatvfs.cpp new file mode 100644 index 00000000..bb08ae0c --- /dev/null +++ b/src/VBox/Runtime/common/fs/fatvfs.cpp @@ -0,0 +1,6345 @@ +/* $Id: fatvfs.cpp $ */ +/** @file + * IPRT - FAT Virtual Filesystem. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include "internal/iprt.h" +#include <iprt/fsvfs.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/err.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/path.h> +#include <iprt/poll.h> +#include <iprt/rand.h> +#include <iprt/string.h> +#include <iprt/sg.h> +#include <iprt/thread.h> +#include <iprt/uni.h> +#include <iprt/utf16.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/zero.h> +#include <iprt/formats/fat.h> + +#include "internal/fs.h" + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** + * Gets the cluster from a directory entry. + * + * @param a_pDirEntry Pointer to the directory entry. + * @param a_pVol Pointer to the volume. + */ +#define RTFSFAT_GET_CLUSTER(a_pDirEntry, a_pVol) \ + ( (a_pVol)->enmFatType >= RTFSFATTYPE_FAT32 \ + ? RT_MAKE_U32((a_pDirEntry)->idxCluster, (a_pDirEntry)->u.idxClusterHigh) \ + : (a_pDirEntry)->idxCluster ) + +/** + * Rotates a unsigned 8-bit value one bit to the right. + * + * @returns Rotated 8-bit value. + * @param a_bValue The value to rotate. + */ +#define RTFSFAT_ROT_R1_U8(a_bValue) (((a_bValue) >> 1) | (uint8_t)((a_bValue) << 7)) + + +/** Maximum number of characters we will create in a long file name. */ +#define RTFSFAT_MAX_LFN_CHARS 255 + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to a FAT directory instance. */ +typedef struct RTFSFATDIRSHRD *PRTFSFATDIRSHRD; +/** Pointer to a FAT volume (VFS instance data). */ +typedef struct RTFSFATVOL *PRTFSFATVOL; + + +/** The number of entire in a chain part. */ +#define RTFSFATCHAINPART_ENTRIES (256U - 4U) + +/** + * A part of the cluster chain covering up to 252 clusters. + */ +typedef struct RTFSFATCHAINPART +{ + /** List entry. */ + RTLISTNODE ListEntry; + /** Chain entries. */ + uint32_t aEntries[RTFSFATCHAINPART_ENTRIES]; +} RTFSFATCHAINPART; +AssertCompile(sizeof(RTFSFATCHAINPART) <= _1K); +typedef RTFSFATCHAINPART *PRTFSFATCHAINPART; +typedef RTFSFATCHAINPART const *PCRTFSFATCHAINPART; + + +/** + * A FAT cluster chain. + */ +typedef struct RTFSFATCHAIN +{ + /** The chain size in bytes. */ + uint32_t cbChain; + /** The chain size in entries. */ + uint32_t cClusters; + /** The cluster size. */ + uint32_t cbCluster; + /** The shift count for converting between clusters and bytes. */ + uint8_t cClusterByteShift; + /** List of chain parts (RTFSFATCHAINPART). */ + RTLISTANCHOR ListParts; +} RTFSFATCHAIN; +/** Pointer to a FAT chain. */ +typedef RTFSFATCHAIN *PRTFSFATCHAIN; +/** Pointer to a const FAT chain. */ +typedef RTFSFATCHAIN const *PCRTFSFATCHAIN; + + +/** + * FAT file system object (common part to files and dirs (shared)). + */ +typedef struct RTFSFATOBJ +{ + /** The parent directory keeps a list of open objects (RTFSFATOBJ). */ + RTLISTNODE Entry; + /** Reference counter. */ + uint32_t volatile cRefs; + /** The parent directory (not released till all children are close). */ + PRTFSFATDIRSHRD pParentDir; + /** The byte offset of the directory entry in the parent dir. + * This is set to UINT32_MAX for the root directory. */ + uint32_t offEntryInDir; + /** Attributes. */ + RTFMODE fAttrib; + /** The object size. */ + uint32_t cbObject; + /** The access time. */ + RTTIMESPEC AccessTime; + /** The modificaton time. */ + RTTIMESPEC ModificationTime; + /** The birth time. */ + RTTIMESPEC BirthTime; + /** Cluster chain. */ + RTFSFATCHAIN Clusters; + /** Pointer to the volume. */ + struct RTFSFATVOL *pVol; + /** Set if we've maybe dirtied the FAT. */ + bool fMaybeDirtyFat; + /** Set if we've maybe dirtied the directory entry. */ + bool fMaybeDirtyDirEnt; +} RTFSFATOBJ; +/** Poitner to a FAT file system object. */ +typedef RTFSFATOBJ *PRTFSFATOBJ; + +/** + * Shared FAT file data. + */ +typedef struct RTFSFATFILESHRD +{ + /** Core FAT object info. */ + RTFSFATOBJ Core; +} RTFSFATFILESHRD; +/** Pointer to shared FAT file data. */ +typedef RTFSFATFILESHRD *PRTFSFATFILESHRD; + + +/** + * Per handle data for a FAT file. + */ +typedef struct RTFSFATFILE +{ + /** Pointer to the shared data. */ + PRTFSFATFILESHRD pShared; + /** The current file offset. */ + uint32_t offFile; +} RTFSFATFILE; +/** Pointer to the per handle data of a FAT file. */ +typedef RTFSFATFILE *PRTFSFATFILE; + + +/** + * FAT shared directory structure. + * + * We work directories in one of two buffering modes. If there are few entries + * or if it's the FAT12/16 root directory, we map the whole thing into memory. + * If it's too large, we use an inefficient sector buffer for now. + * + * Directory entry updates happens exclusively via the directory, so any open + * files or subdirs have a parent reference for doing that. The parent OTOH, + * keeps a list of open children. + */ +typedef struct RTFSFATDIRSHRD +{ + /** Core FAT object info. */ + RTFSFATOBJ Core; + /** Open child objects (RTFSFATOBJ). */ + RTLISTNODE OpenChildren; + + /** Number of directory entries. */ + uint32_t cEntries; + + /** If fully buffered. */ + bool fFullyBuffered; + /** Set if this is a linear root directory. */ + bool fIsLinearRootDir; + /** The size of the memory paEntries points at. */ + uint32_t cbAllocatedForEntries; + + /** Pointer to the directory buffer. + * In fully buffering mode, this is the whole of the directory. Otherwise it's + * just a sector worth of buffers. */ + PFATDIRENTRYUNION paEntries; + /** The disk offset corresponding to what paEntries points to. + * UINT64_MAX if notthing read into paEntries yet. */ + uint64_t offEntriesOnDisk; + union + { + /** Data for the full buffered mode. + * No need to messing around with clusters here, as we only uses this for + * directories with a contiguous mapping on the disk. + * So, if we grow a directory in a non-contiguous manner, we have to switch + * to sector buffering on the fly. */ + struct + { + /** Number of sectors mapped by paEntries and pbDirtySectors. */ + uint32_t cSectors; + /** Number of dirty sectors. */ + uint32_t cDirtySectors; + /** Dirty sector bitmap (one bit per sector). */ + uint8_t *pbDirtySectors; + } Full; + /** The simple sector buffering. + * This only works for clusters, so no FAT12/16 root directory fun. */ + struct + { + /** The directory offset, UINT32_MAX if invalid. */ + uint32_t offInDir; + /** Dirty flag. */ + bool fDirty; + } Simple; + } u; +} RTFSFATDIRSHRD; +/** Pointer to a shared FAT directory instance. */ +typedef RTFSFATDIRSHRD *PRTFSFATDIRSHRD; + + +/** + * The per handle FAT directory data. + */ +typedef struct RTFSFATDIR +{ + /** Core FAT object info. */ + PRTFSFATDIRSHRD pShared; + /** The current directory offset. */ + uint32_t offDir; +} RTFSFATDIR; +/** Pointer to a per handle FAT directory data. */ +typedef RTFSFATDIR *PRTFSFATDIR; + + +/** + * File allocation table cache entry. + */ +typedef struct RTFSFATCLUSTERMAPENTRY +{ + /** The byte offset into the fat, UINT32_MAX if invalid entry. */ + uint32_t offFat; + /** Pointer to the data. */ + uint8_t *pbData; + /** Dirty bitmap. Indexed by byte offset right shifted by + * RTFSFATCLUSTERMAPCACHE::cDirtyShift. */ + uint64_t bmDirty; +} RTFSFATCLUSTERMAPENTRY; +/** Pointer to a file allocation table cache entry. */ +typedef RTFSFATCLUSTERMAPENTRY *PRTFSFATCLUSTERMAPENTRY; + +/** + * File allocation table cache. + */ +typedef struct RTFSFATCLUSTERMAPCACHE +{ + /** Number of cache entries (power of two). */ + uint32_t cEntries; + /** This shift count to use in the first step of the index calculation. */ + uint32_t cEntryIndexShift; + /** The AND mask to use in the second step of the index calculation. */ + uint32_t fEntryIndexMask; + /** The max size of data in a cache entry (power of two). */ + uint32_t cbEntry; + /** The AND mask to use to get the entry offset. */ + uint32_t fEntryOffsetMask; + /** Dirty bitmap shift count. */ + uint32_t cDirtyShift; + /** The dirty cache line size (multiple of two). */ + uint32_t cbDirtyLine; + /** The FAT size. */ + uint32_t cbFat; + /** The Number of clusters in the FAT. */ + uint32_t cClusters; + /** Cluster allocation search hint. */ + uint32_t idxAllocHint; + /** Pointer to the volume (for disk access). */ + PRTFSFATVOL pVol; + /** The cache name. */ + const char *pszName; + /** Cache entries. */ + RTFSFATCLUSTERMAPENTRY aEntries[RT_FLEXIBLE_ARRAY]; +} RTFSFATCLUSTERMAPCACHE; +/** Pointer to a FAT linear metadata cache. */ +typedef RTFSFATCLUSTERMAPCACHE *PRTFSFATCLUSTERMAPCACHE; + + +/** + * BPB version. + */ +typedef enum RTFSFATBPBVER +{ + RTFSFATBPBVER_INVALID = 0, + RTFSFATBPBVER_NO_BPB, + RTFSFATBPBVER_DOS_2_0, + //RTFSFATBPBVER_DOS_3_2, - we don't try identify this one. + RTFSFATBPBVER_DOS_3_31, + RTFSFATBPBVER_EXT_28, + RTFSFATBPBVER_EXT_29, + RTFSFATBPBVER_FAT32_28, + RTFSFATBPBVER_FAT32_29, + RTFSFATBPBVER_END +} RTFSFATBPBVER; + + +/** + * A FAT volume. + */ +typedef struct RTFSFATVOL +{ + /** Handle to itself. */ + RTVFS hVfsSelf; + /** The file, partition, or whatever backing the FAT volume. */ + RTVFSFILE hVfsBacking; + /** The size of the backing thingy. */ + uint64_t cbBacking; + /** Byte offset of the bootsector relative to the start of the file. */ + uint64_t offBootSector; + /** The UTC offset in nanoseconds to use for this file system (FAT traditionally + * stores timestamps in local time). + * @remarks This may need improving later. */ + int64_t offNanoUTC; + /** The UTC offset in minutes to use for this file system (FAT traditionally + * stores timestamps in local time). + * @remarks This may need improving later. */ + int32_t offMinUTC; + /** Set if read-only mode. */ + bool fReadOnly; + /** Media byte. */ + uint8_t bMedia; + /** Reserved sectors. */ + uint32_t cReservedSectors; + /** The BPB version. Gives us an idea of the FAT file system version. */ + RTFSFATBPBVER enmBpbVersion; + + /** Logical sector size. */ + uint32_t cbSector; + /** The shift count for converting between sectors and bytes. */ + uint8_t cSectorByteShift; + /** The shift count for converting between clusters and bytes. */ + uint8_t cClusterByteShift; + /** The cluster size in bytes. */ + uint32_t cbCluster; + /** The number of data clusters, including the two reserved ones. */ + uint32_t cClusters; + /** The offset of the first cluster. */ + uint64_t offFirstCluster; + /** The total size from the BPB, in bytes. */ + uint64_t cbTotalSize; + + /** The FAT type. */ + RTFSFATTYPE enmFatType; + + /** Number of FAT entries (clusters). */ + uint32_t cFatEntries; + /** The size of a FAT, in bytes. */ + uint32_t cbFat; + /** Number of FATs. */ + uint32_t cFats; + /** The end of chain marker used by the formatter (FAT entry \#2). */ + uint32_t idxEndOfChain; + /** The maximum last cluster supported by the FAT format. */ + uint32_t idxMaxLastCluster; + /** FAT byte offsets. */ + uint64_t aoffFats[8]; + /** Pointer to the FAT (cluster map) cache. */ + PRTFSFATCLUSTERMAPCACHE pFatCache; + + /** The root directory byte offset. */ + uint64_t offRootDir; + /** Root directory cluster, UINT32_MAX if not FAT32. */ + uint32_t idxRootDirCluster; + /** Number of root directory entries, if fixed. UINT32_MAX for FAT32. */ + uint32_t cRootDirEntries; + /** The size of the root directory, rounded up to the nearest sector size. */ + uint32_t cbRootDir; + /** The root directory data (shared). */ + PRTFSFATDIRSHRD pRootDir; + + /** Serial number. */ + uint32_t uSerialNo; + /** The stripped volume label, if included in EBPB. */ + char szLabel[12]; + /** The file system type from the EBPB (also stripped). */ + char szType[9]; + /** Number of FAT32 boot sector copies. */ + uint8_t cBootSectorCopies; + /** FAT32 flags. */ + uint16_t fFat32Flags; + /** Offset of the FAT32 boot sector copies, UINT64_MAX if none. */ + uint64_t offBootSectorCopies; + + /** The FAT32 info sector byte offset, UINT64_MAX if not present. */ + uint64_t offFat32InfoSector; + /** The FAT32 info sector if offFat32InfoSector isn't UINT64_MAX. */ + FAT32INFOSECTOR Fat32InfoSector; +} RTFSFATVOL; +/** Pointer to a const FAT volume (VFS instance data). */ +typedef RTFSFATVOL const *PCRTFSFATVOL; + + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** + * Codepage 437 translation table with invalid 8.3 characters marked as 0xffff or 0xfffe. + * + * The 0xfffe notation is used for characters that are valid in long file names but not short. + * + * @remarks The valid first 128 entries are 1:1 with unicode. + * @remarks Lower case characters are all marked invalid. + */ +static RTUTF16 g_awchFatCp437ValidChars[] = +{ /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, + 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0xffff, 0xfffe, 0xfffe, 0x002d, 0xfffe, 0xffff, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0xffff, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xffff, + 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, + 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0xfffe, 0xffff, 0xfffe, 0x005e, 0x005f, + 0x0060, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, + 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xfffe, 0xffff, 0xffff, 0xffff, 0x007e, 0xffff, + 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, + 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, + 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, + 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, + 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, + 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, + 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0 +}; +AssertCompileSize(g_awchFatCp437ValidChars, 256*2); + +/** + * Codepage 437 translation table without invalid 8.3. character markings. + */ +static RTUTF16 g_awchFatCp437Chars[] = +{ /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */ + 0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, 0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c, + 0x25ba, 0x25c4, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25ac, 0x21a8, 0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc, + 0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, + 0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, + 0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, + 0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, + 0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x2302, + 0x00c7, 0x00fc, 0x00e9, 0x00e2, 0x00e4, 0x00e0, 0x00e5, 0x00e7, 0x00ea, 0x00eb, 0x00e8, 0x00ef, 0x00ee, 0x00ec, 0x00c4, 0x00c5, + 0x00c9, 0x00e6, 0x00c6, 0x00f4, 0x00f6, 0x00f2, 0x00fb, 0x00f9, 0x00ff, 0x00d6, 0x00dc, 0x00a2, 0x00a3, 0x00a5, 0x20a7, 0x0192, + 0x00e1, 0x00ed, 0x00f3, 0x00fa, 0x00f1, 0x00d1, 0x00aa, 0x00ba, 0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb, + 0x2591, 0x2592, 0x2593, 0x2502, 0x2524, 0x2561, 0x2562, 0x2556, 0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510, + 0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f, 0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567, + 0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b, 0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580, + 0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, 0x03a6, 0x0398, 0x03a9, 0x03b4, 0x221e, 0x03c6, 0x03b5, 0x2229, + 0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248, 0x00b0, 0x2219, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x25a0, 0x00a0 +}; +AssertCompileSize(g_awchFatCp437Chars, 256*2); + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static PRTFSFATOBJ rtFsFatDirShrd_LookupShared(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir); +static void rtFsFatDirShrd_AddOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild); +static void rtFsFatDirShrd_RemoveOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild); +static int rtFsFatDirShrd_GetEntryForUpdate(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, + PFATDIRENTRY *ppDirEntry, uint32_t *puWriteLock); +static int rtFsFatDirShrd_PutEntryAfterUpdate(PRTFSFATDIRSHRD pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock); +static int rtFsFatDirShrd_Flush(PRTFSFATDIRSHRD pThis); +static int rtFsFatDir_NewWithShared(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pShared, PRTVFSDIR phVfsDir); +static int rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir, + uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir); + + +/** + * Convers a cluster to a disk offset. + * + * @returns Disk byte offset, UINT64_MAX on invalid cluster. + * @param pThis The FAT volume instance. + * @param idxCluster The cluster number. + */ +DECLINLINE(uint64_t) rtFsFatClusterToDiskOffset(PRTFSFATVOL pThis, uint32_t idxCluster) +{ + AssertReturn(idxCluster >= FAT_FIRST_DATA_CLUSTER, UINT64_MAX); + AssertReturn(idxCluster < pThis->cClusters, UINT64_MAX); + return (idxCluster - FAT_FIRST_DATA_CLUSTER) * (uint64_t)pThis->cbCluster + + pThis->offFirstCluster; +} + + +#ifdef RT_STRICT +/** + * Assert chain consistency. + */ +static bool rtFsFatChain_AssertValid(PCRTFSFATCHAIN pChain) +{ + bool fRc = true; + uint32_t cParts = 0; + PRTFSFATCHAINPART pPart; + RTListForEach(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry) + cParts++; + + uint32_t cExpected = (pChain->cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES; + AssertMsgStmt(cExpected == cParts, ("cExpected=%#x cParts=%#x\n", cExpected, cParts), fRc = false); + AssertMsgStmt(pChain->cbChain == (pChain->cClusters << pChain->cClusterByteShift), + ("cExpected=%#x cParts=%#x\n", cExpected, cParts), fRc = false); + return fRc; +} +#endif /* RT_STRICT */ + + +/** + * Initializes an empty cluster chain. + * + * @param pChain The chain. + * @param pVol The volume. + */ +static void rtFsFatChain_InitEmpty(PRTFSFATCHAIN pChain, PRTFSFATVOL pVol) +{ + pChain->cbCluster = pVol->cbCluster; + pChain->cClusterByteShift = pVol->cClusterByteShift; + pChain->cbChain = 0; + pChain->cClusters = 0; + RTListInit(&pChain->ListParts); +} + + +/** + * Deletes a chain, freeing it's resources. + * + * @param pChain The chain. + */ +static void rtFsFatChain_Delete(PRTFSFATCHAIN pChain) +{ + Assert(RT_IS_POWER_OF_TWO(pChain->cbCluster)); + Assert(RT_BIT_32(pChain->cClusterByteShift) == pChain->cbCluster); + + PRTFSFATCHAINPART pPart = RTListRemoveLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + while (pPart) + { + RTMemFree(pPart); + pPart = RTListRemoveLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + } + + pChain->cbChain = 0; + pChain->cClusters = 0; +} + + +/** + * Appends a cluster to a cluster chain. + * + * @returns IPRT status code. + * @param pChain The chain. + * @param idxCluster The cluster to append. + */ +static int rtFsFatChain_Append(PRTFSFATCHAIN pChain, uint32_t idxCluster) +{ + PRTFSFATCHAINPART pPart; + uint32_t idxLast = pChain->cClusters % RTFSFATCHAINPART_ENTRIES; + if (idxLast != 0) + pPart = RTListGetLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + else + { + pPart = (PRTFSFATCHAINPART)RTMemAllocZ(sizeof(*pPart)); + if (!pPart) + return VERR_NO_MEMORY; + RTListAppend(&pChain->ListParts, &pPart->ListEntry); + } + pPart->aEntries[idxLast] = idxCluster; + pChain->cClusters++; + pChain->cbChain += pChain->cbCluster; + return VINF_SUCCESS; +} + + +/** + * Reduces the number of clusters in the chain to @a cClusters. + * + * @param pChain The chain. + * @param cClustersNew The new cluster count. Must be equal or smaller to + * the current number of clusters. + */ +static void rtFsFatChain_Shrink(PRTFSFATCHAIN pChain, uint32_t cClustersNew) +{ + uint32_t cOldParts = (pChain->cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES; + uint32_t cNewParts = (cClustersNew + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES; + Assert(cOldParts >= cNewParts); + while (cOldParts-- > cNewParts) + RTMemFree(RTListRemoveLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry)); + pChain->cClusters = cClustersNew; + pChain->cbChain = cClustersNew << pChain->cClusterByteShift; + Assert(rtFsFatChain_AssertValid(pChain)); +} + + + +/** + * Converts a file offset to a disk offset. + * + * The disk offset is only valid until the end of the cluster it is within. + * + * @returns Disk offset. UINT64_MAX if invalid file offset. + * @param pChain The chain. + * @param offFile The file offset. + * @param pVol The volume. + */ +static uint64_t rtFsFatChain_FileOffsetToDiskOff(PCRTFSFATCHAIN pChain, uint32_t offFile, PCRTFSFATVOL pVol) +{ + uint32_t idxCluster = offFile >> pChain->cClusterByteShift; + if (idxCluster < pChain->cClusters) + { + PRTFSFATCHAINPART pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + while (idxCluster >= RTFSFATCHAINPART_ENTRIES) + { + idxCluster -= RTFSFATCHAINPART_ENTRIES; + pPart = RTListGetNext(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry); + } + return pVol->offFirstCluster + + ((uint64_t)(pPart->aEntries[idxCluster] - FAT_FIRST_DATA_CLUSTER) << pChain->cClusterByteShift) + + (offFile & (pChain->cbCluster - 1)); + } + return UINT64_MAX; +} + + +/** + * Checks if the cluster chain is contiguous on the disk. + * + * @returns true / false. + * @param pChain The chain. + */ +static bool rtFsFatChain_IsContiguous(PCRTFSFATCHAIN pChain) +{ + if (pChain->cClusters <= 1) + return true; + + PRTFSFATCHAINPART pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + uint32_t idxNext = pPart->aEntries[0]; + uint32_t cLeft = pChain->cClusters; + for (;;) + { + uint32_t const cInPart = RT_MIN(cLeft, RTFSFATCHAINPART_ENTRIES); + for (uint32_t iPart = 0; iPart < cInPart; iPart++) + if (pPart->aEntries[iPart] == idxNext) + idxNext++; + else + return false; + cLeft -= cInPart; + if (!cLeft) + return true; + pPart = RTListGetNext(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry); + } +} + + +/** + * Gets a cluster array index. + * + * This works the chain thing as an indexed array. + * + * @returns The cluster number, UINT32_MAX if out of bounds. + * @param pChain The chain. + * @param idx The index. + */ +static uint32_t rtFsFatChain_GetClusterByIndex(PCRTFSFATCHAIN pChain, uint32_t idx) +{ + if (idx < pChain->cClusters) + { + /* + * In the first part? + */ + PRTFSFATCHAINPART pPart; + if (idx < RTFSFATCHAINPART_ENTRIES) + { + pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + return pPart->aEntries[idx]; + } + + /* + * In the last part? + */ + uint32_t cParts = (pChain->cClusters + RTFSFATCHAINPART_ENTRIES - 1) / RTFSFATCHAINPART_ENTRIES; + uint32_t idxPart = idx / RTFSFATCHAINPART_ENTRIES; + uint32_t idxInPart = idx % RTFSFATCHAINPART_ENTRIES; + if (idxPart + 1 == cParts) + pPart = RTListGetLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + else + { + /* + * No, do linear search from the start, skipping the first part. + */ + pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + while (idxPart-- > 0) + pPart = RTListGetNext(&pChain->ListParts, pPart, RTFSFATCHAINPART, ListEntry); + } + + return pPart->aEntries[idxInPart]; + } + return UINT32_MAX; +} + + +/** + * Gets the first cluster. + * + * @returns The cluster number, UINT32_MAX if empty + * @param pChain The chain. + */ +static uint32_t rtFsFatChain_GetFirstCluster(PCRTFSFATCHAIN pChain) +{ + if (pChain->cClusters > 0) + { + PRTFSFATCHAINPART pPart = RTListGetFirst(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + return pPart->aEntries[0]; + } + return UINT32_MAX; +} + + + +/** + * Gets the last cluster. + * + * @returns The cluster number, UINT32_MAX if empty + * @param pChain The chain. + */ +static uint32_t rtFsFatChain_GetLastCluster(PCRTFSFATCHAIN pChain) +{ + if (pChain->cClusters > 0) + { + PRTFSFATCHAINPART pPart = RTListGetLast(&pChain->ListParts, RTFSFATCHAINPART, ListEntry); + return pPart->aEntries[(pChain->cClusters - 1) % RTFSFATCHAINPART_ENTRIES]; + } + return UINT32_MAX; +} + + +/** + * Creates a cache for the file allocation table (cluster map). + * + * @returns Pointer to the cache. + * @param pThis The FAT volume instance. + * @param pbFirst512FatBytes The first 512 bytes of the first FAT. + */ +static int rtFsFatClusterMap_Create(PRTFSFATVOL pThis, uint8_t const *pbFirst512FatBytes, PRTERRINFO pErrInfo) +{ + Assert(RT_ALIGN_32(pThis->cbFat, pThis->cbSector) == pThis->cbFat); + Assert(pThis->cbFat != 0); + + /* + * Figure the cache size. Keeping it _very_ simple for now as we just need + * something that works, not anything the performs like crazy. + * + * Note! Lowering the max cache size below 128KB will break ASSUMPTIONS in the FAT16 + * and eventually FAT12 code. + */ + uint32_t cEntries; + uint32_t cEntryIndexShift; + uint32_t fEntryIndexMask; + uint32_t cbEntry = pThis->cbFat; + uint32_t fEntryOffsetMask; + if (cbEntry <= _512K) + { + cEntries = 1; + cEntryIndexShift = 0; + fEntryIndexMask = 0; + fEntryOffsetMask = UINT32_MAX; + } + else + { + Assert(pThis->cbSector < _512K / 8); + cEntries = 8; + cEntryIndexShift = 9; + fEntryIndexMask = cEntries - 1; + AssertReturn(RT_IS_POWER_OF_TWO(cEntries), VERR_INTERNAL_ERROR_4); + + cbEntry = pThis->cbSector; + fEntryOffsetMask = pThis->cbSector - 1; + AssertReturn(RT_IS_POWER_OF_TWO(cbEntry), VERR_INTERNAL_ERROR_5); + } + + /* + * Allocate and initialize it all. + */ + PRTFSFATCLUSTERMAPCACHE pFatCache; + pFatCache = (PRTFSFATCLUSTERMAPCACHE)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFSFATCLUSTERMAPCACHE, aEntries[cEntries])); + pThis->pFatCache = pFatCache; + if (!pFatCache) + return RTErrInfoSet(pErrInfo, VERR_NO_MEMORY, "Failed to allocate FAT cache"); + pFatCache->cEntries = cEntries; + pFatCache->fEntryIndexMask = fEntryIndexMask; + pFatCache->cEntryIndexShift = cEntryIndexShift; + pFatCache->cbEntry = cbEntry; + pFatCache->fEntryOffsetMask = fEntryOffsetMask; + pFatCache->pVol = pThis; + pFatCache->cbFat = pThis->cbFat; + pFatCache->cClusters = pThis->cClusters; + + unsigned i = cEntries; + while (i-- > 0) + { + pFatCache->aEntries[i].pbData = (uint8_t *)RTMemAlloc(cbEntry); + if (pFatCache->aEntries[i].pbData == NULL) + { + for (i++; i < cEntries; i++) + RTMemFree(pFatCache->aEntries[i].pbData); + RTMemFree(pFatCache); + return RTErrInfoSetF(pErrInfo, VERR_NO_MEMORY, "Failed to allocate FAT cache entry (%#x bytes)", cbEntry); + } + + pFatCache->aEntries[i].offFat = UINT32_MAX; + pFatCache->aEntries[i].bmDirty = 0; + } + Log3(("rtFsFatClusterMap_Create: cbFat=%#RX32 cEntries=%RU32 cEntryIndexShift=%RU32 fEntryIndexMask=%#RX32\n", + pFatCache->cbFat, pFatCache->cEntries, pFatCache->cEntryIndexShift, pFatCache->fEntryIndexMask)); + Log3(("rtFsFatClusterMap_Create: cbEntries=%#RX32 fEntryOffsetMask=%#RX32\n", pFatCache->cbEntry, pFatCache->fEntryOffsetMask)); + + /* + * Calc the dirty shift factor. + */ + cbEntry /= 64; + if (cbEntry < pThis->cbSector) + cbEntry = pThis->cbSector; + + pFatCache->cDirtyShift = 1; + pFatCache->cbDirtyLine = 1; + while (pFatCache->cbDirtyLine < cbEntry) + { + pFatCache->cDirtyShift++; + pFatCache->cbDirtyLine <<= 1; + } + Assert(pFatCache->cEntries == 1 || pFatCache->cbDirtyLine == pThis->cbSector); + Log3(("rtFsFatClusterMap_Create: cbDirtyLine=%#RX32 cDirtyShift=%u\n", pFatCache->cbDirtyLine, pFatCache->cDirtyShift)); + + /* + * Fill the cache if single entry or entry size is 512. + */ + if (pFatCache->cEntries == 1 || pFatCache->cbEntry == 512) + { + memcpy(pFatCache->aEntries[0].pbData, pbFirst512FatBytes, RT_MIN(512, pFatCache->cbEntry)); + if (pFatCache->cbEntry > 512) + { + int rc = RTVfsFileReadAt(pThis->hVfsBacking, pThis->aoffFats[0] + 512, + &pFatCache->aEntries[0].pbData[512], pFatCache->cbEntry - 512, NULL); + if (RT_FAILURE(rc)) + return RTErrInfoSet(pErrInfo, rc, "Error reading FAT into memory"); + } + pFatCache->aEntries[0].offFat = 0; + pFatCache->aEntries[0].bmDirty = 0; + } + + return VINF_SUCCESS; +} + + +/** + * Worker for rtFsFatClusterMap_Flush and rtFsFatClusterMap_FlushEntry. + * + * @returns IPRT status code. On failure, we're currently kind of screwed. + * @param pThis The FAT volume instance. + * @param iFirstEntry Entry to start flushing at. + * @param iLastEntry Last entry to flush. + */ +static int rtFsFatClusterMap_FlushWorker(PRTFSFATVOL pThis, uint32_t const iFirstEntry, uint32_t const iLastEntry) +{ + PRTFSFATCLUSTERMAPCACHE pFatCache = pThis->pFatCache; + Log3(("rtFsFatClusterMap_FlushWorker: %p %#x %#x\n", pThis, iFirstEntry, iLastEntry)); + + /* + * Walk the cache entries, accumulating segments to flush. + */ + int rc = VINF_SUCCESS; + uint64_t off = UINT64_MAX; + uint64_t offEdge = UINT64_MAX; + RTSGSEG aSgSegs[8]; + RTSGBUF SgBuf; + RTSgBufInit(&SgBuf, aSgSegs, RT_ELEMENTS(aSgSegs)); + SgBuf.cSegs = 0; /** @todo RTSgBuf API is stupid, make it smarter. */ + + for (uint32_t iFatCopy = 0; iFatCopy < pThis->cFats; iFatCopy++) + { + for (uint32_t iEntry = iFirstEntry; iEntry <= iLastEntry; iEntry++) + { + uint64_t bmDirty = pFatCache->aEntries[iEntry].bmDirty; + if ( bmDirty != 0 + && pFatCache->aEntries[iEntry].offFat != UINT32_MAX) + { + uint32_t offEntry = 0; + uint64_t iDirtyLine = 1; + while (offEntry < pFatCache->cbEntry) + { + if (pFatCache->aEntries[iEntry].bmDirty & iDirtyLine) + { + /* + * Found dirty cache line. + */ + uint64_t offDirtyLine = pThis->aoffFats[iFatCopy] + pFatCache->aEntries[iEntry].offFat + offEntry; + + /* Can we simply extend the last segment? */ + if ( offDirtyLine == offEdge + && offEntry) + { + Assert(SgBuf.cSegs > 0); + Assert( (uintptr_t)aSgSegs[SgBuf.cSegs - 1].pvSeg + aSgSegs[SgBuf.cSegs - 1].cbSeg + == (uintptr_t)&pFatCache->aEntries[iEntry].pbData[offEntry]); + aSgSegs[SgBuf.cSegs - 1].cbSeg += pFatCache->cbDirtyLine; + offEdge += pFatCache->cbDirtyLine; + } + else + { + /* Starting new job? */ + if (off == UINT64_MAX) + { + off = offDirtyLine; + Assert(SgBuf.cSegs == 0); + } + /* flush if not adjacent or if we're out of segments. */ + else if ( offDirtyLine != offEdge + || SgBuf.cSegs >= RT_ELEMENTS(aSgSegs)) + { + int rc2 = RTVfsFileSgWrite(pThis->hVfsBacking, off, &SgBuf, true /*fBlocking*/, NULL); + if (RT_FAILURE(rc2) && RT_SUCCESS(rc)) + rc = rc2; + RTSgBufReset(&SgBuf); + SgBuf.cSegs = 0; + off = offDirtyLine; + } + + /* Append segment. */ + aSgSegs[SgBuf.cSegs].cbSeg = pFatCache->cbDirtyLine; + aSgSegs[SgBuf.cSegs].pvSeg = &pFatCache->aEntries[iEntry].pbData[offEntry]; + SgBuf.cSegs++; + offEdge = offDirtyLine + pFatCache->cbDirtyLine; + } + + bmDirty &= ~iDirtyLine; + if (!bmDirty) + break; + } + iDirtyLine <<= 1; + offEntry += pFatCache->cbDirtyLine; + } + Assert(!bmDirty); + } + } + } + + /* + * Final flush job. + */ + if (SgBuf.cSegs > 0) + { + int rc2 = RTVfsFileSgWrite(pThis->hVfsBacking, off, &SgBuf, true /*fBlocking*/, NULL); + if (RT_FAILURE(rc2) && RT_SUCCESS(rc)) + rc = rc2; + } + + /* + * Clear the dirty flags on success. + */ + if (RT_SUCCESS(rc)) + for (uint32_t iEntry = iFirstEntry; iEntry <= iLastEntry; iEntry++) + pFatCache->aEntries[iEntry].bmDirty = 0; + + return rc; +} + + +/** + * Flushes out all dirty lines in the entire file allocation table cache. + * + * @returns IPRT status code. On failure, we're currently kind of screwed. + * @param pThis The FAT volume instance. + */ +static int rtFsFatClusterMap_Flush(PRTFSFATVOL pThis) +{ + return rtFsFatClusterMap_FlushWorker(pThis, 0, pThis->pFatCache->cEntries - 1); +} + + +/** + * Flushes out all dirty lines in the file allocation table (cluster map) cache + * entry. + * + * This is typically called prior to reusing the cache entry. + * + * @returns IPRT status code. On failure, we're currently kind of screwed. + * @param pFatCache The FAT cache + * @param iEntry The cache entry to flush. + */ +static int rtFsFatClusterMap_FlushEntry(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t iEntry) +{ + return rtFsFatClusterMap_FlushWorker(pFatCache->pVol, iEntry, iEntry); +} + + +/** + * Gets a pointer to a FAT entry. + * + * @returns IPRT status code. On failure, we're currently kind of screwed. + * @param pFatCache The FAT cache. + * @param offFat The FAT byte offset to get the entry off. + * @param ppbEntry Where to return the pointer to the entry. + */ +static int rtFsFatClusterMap_GetEntry(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t offFat, uint8_t **ppbEntry) +{ + int rc; + if (offFat < pFatCache->cbFat) + { + uint32_t const iEntry = (offFat >> pFatCache->cEntryIndexShift) & pFatCache->fEntryIndexMask; + uint32_t const offInEntry = offFat & pFatCache->fEntryOffsetMask; + uint32_t const offFatEntry = offFat - offInEntry; + + *ppbEntry = pFatCache->aEntries[iEntry].pbData + offInEntry; + + /* If it's already ready, return immediately. */ + if (pFatCache->aEntries[iEntry].offFat == offFatEntry) + { + Log3(("rtFsFatClusterMap_GetEntry: Hit entry %u for offFat=%#RX32\n", iEntry, offFat)); + return VINF_SUCCESS; + } + + /* Do we need to flush it? */ + rc = VINF_SUCCESS; + if ( pFatCache->aEntries[iEntry].bmDirty != 0 + && pFatCache->aEntries[iEntry].offFat != UINT32_MAX) + { + Log3(("rtFsFatClusterMap_GetEntry: Flushing entry %u for offFat=%#RX32\n", iEntry, offFat)); + rc = rtFsFatClusterMap_FlushEntry(pFatCache, iEntry); + } + if (RT_SUCCESS(rc)) + { + pFatCache->aEntries[iEntry].bmDirty = 0; + + /* Read in the entry from disk */ + rc = RTVfsFileReadAt(pFatCache->pVol->hVfsBacking, pFatCache->pVol->aoffFats[0] + offFatEntry, + pFatCache->aEntries[iEntry].pbData, pFatCache->cbEntry, NULL); + if (RT_SUCCESS(rc)) + { + Log3(("rtFsFatClusterMap_GetEntry: Loaded entry %u for offFat=%#RX32\n", iEntry, offFat)); + pFatCache->aEntries[iEntry].offFat = offFatEntry; + return VINF_SUCCESS; + } + /** @todo We can try other FAT copies here... */ + LogRel(("rtFsFatClusterMap_GetEntry: Error loading entry %u for offFat=%#RX32 (%#64RX32 LB %#x): %Rrc\n", + iEntry, offFat, pFatCache->pVol->aoffFats[0] + offFatEntry, pFatCache->cbEntry, rc)); + pFatCache->aEntries[iEntry].offFat = UINT32_MAX; + } + } + else + rc = VERR_OUT_OF_RANGE; + *ppbEntry = NULL; + return rc; +} + + +/** + * Gets a pointer to a FAT entry, extended version. + * + * @returns IPRT status code. On failure, we're currently kind of screwed. + * @param pFatCache The FAT cache. + * @param offFat The FAT byte offset to get the entry off. + * @param ppbEntry Where to return the pointer to the entry. + * @param pidxEntry Where to return the entry index. + */ +static int rtFsFatClusterMap_GetEntryEx(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t offFat, + uint8_t **ppbEntry, uint32_t *pidxEntry) +{ + int rc; + if (offFat < pFatCache->cbFat) + { + uint32_t const iEntry = (offFat >> pFatCache->cEntryIndexShift) & pFatCache->fEntryIndexMask; + uint32_t const offInEntry = offFat & pFatCache->fEntryOffsetMask; + uint32_t const offFatEntry = offFat - offInEntry; + + *ppbEntry = pFatCache->aEntries[iEntry].pbData + offInEntry; + *pidxEntry = iEntry; + + /* If it's already ready, return immediately. */ + if (pFatCache->aEntries[iEntry].offFat == offFatEntry) + { + Log3(("rtFsFatClusterMap_GetEntryEx: Hit entry %u for offFat=%#RX32\n", iEntry, offFat)); + return VINF_SUCCESS; + } + + /* Do we need to flush it? */ + rc = VINF_SUCCESS; + if ( pFatCache->aEntries[iEntry].bmDirty != 0 + && pFatCache->aEntries[iEntry].offFat != UINT32_MAX) + { + Log3(("rtFsFatClusterMap_GetEntryEx: Flushing entry %u for offFat=%#RX32\n", iEntry, offFat)); + rc = rtFsFatClusterMap_FlushEntry(pFatCache, iEntry); + } + if (RT_SUCCESS(rc)) + { + pFatCache->aEntries[iEntry].bmDirty = 0; + + /* Read in the entry from disk */ + rc = RTVfsFileReadAt(pFatCache->pVol->hVfsBacking, pFatCache->pVol->aoffFats[0] + offFatEntry, + pFatCache->aEntries[iEntry].pbData, pFatCache->cbEntry, NULL); + if (RT_SUCCESS(rc)) + { + Log3(("rtFsFatClusterMap_GetEntryEx: Loaded entry %u for offFat=%#RX32\n", iEntry, offFat)); + pFatCache->aEntries[iEntry].offFat = offFatEntry; + return VINF_SUCCESS; + } + /** @todo We can try other FAT copies here... */ + LogRel(("rtFsFatClusterMap_GetEntryEx: Error loading entry %u for offFat=%#RX32 (%#64RX32 LB %#x): %Rrc\n", + iEntry, offFat, pFatCache->pVol->aoffFats[0] + offFatEntry, pFatCache->cbEntry, rc)); + pFatCache->aEntries[iEntry].offFat = UINT32_MAX; + } + } + else + rc = VERR_OUT_OF_RANGE; + *ppbEntry = NULL; + *pidxEntry = UINT32_MAX; + return rc; +} + + +/** + * Destroys the file allcation table cache, first flushing any dirty lines. + * + * @returns IRPT status code from flush (we've destroyed it regardless of the + * status code). + * @param pThis The FAT volume instance which cluster map shall be + * destroyed. + */ +static int rtFsFatClusterMap_Destroy(PRTFSFATVOL pThis) +{ + int rc = VINF_SUCCESS; + PRTFSFATCLUSTERMAPCACHE pFatCache = pThis->pFatCache; + if (pFatCache) + { + /* flush stuff. */ + rc = rtFsFatClusterMap_Flush(pThis); + + /* free everything. */ + uint32_t i = pFatCache->cEntries; + while (i-- > 0) + { + RTMemFree(pFatCache->aEntries[i].pbData); + pFatCache->aEntries[i].pbData = NULL; + } + pFatCache->cEntries = 0; + RTMemFree(pFatCache); + + pThis->pFatCache = NULL; + } + + return rc; +} + + +/** + * Worker for rtFsFatClusterMap_ReadClusterChain handling FAT12. + */ +static int rtFsFatClusterMap_Fat12_ReadClusterChain(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, PRTFSFATCHAIN pChain) +{ + /* ASSUME that for FAT12 we cache the whole FAT in a single entry. That + way we don't need to deal with entries in different sectors and whatnot. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + + /* Special case for empty files. */ + if (idxCluster == 0) + return VINF_SUCCESS; + + /* Work cluster by cluster. */ + uint8_t const *pbFat = pFatCache->aEntries[0].pbData; + for (;;) + { + /* Validate the cluster, checking for end of file. */ + if ( idxCluster >= pFatCache->cClusters + || idxCluster < FAT_FIRST_DATA_CLUSTER) + { + if (idxCluster >= FAT_FIRST_FAT12_EOC) + return VINF_SUCCESS; + return VERR_VFS_BOGUS_OFFSET; + } + + /* Add cluster to chain. */ + int rc = rtFsFatChain_Append(pChain, idxCluster); + if (RT_FAILURE(rc)) + return rc; + + /* Next cluster. */ +#ifdef LOG_ENABLED + const uint32_t idxPrevCluster = idxCluster; +#endif + bool fOdd = idxCluster & 1; + uint32_t offFat = idxCluster * 3 / 2; + idxCluster = RT_MAKE_U16(pbFat[offFat], pbFat[offFat + 1]); + if (fOdd) + idxCluster >>= 4; + else + idxCluster &= 0x0fff; + Log4(("Fat/ReadChain12: [%#x] %#x (next: %#x)\n", pChain->cClusters - 1, idxPrevCluster, idxCluster)); + } +} + + +/** + * Worker for rtFsFatClusterMap_ReadClusterChain handling FAT16. + */ +static int rtFsFatClusterMap_Fat16_ReadClusterChain(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, PRTFSFATCHAIN pChain) +{ + /* ASSUME that for FAT16 we cache the whole FAT in a single entry. That + way we don't need to deal with entries in different sectors and whatnot. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + + /* Special case for empty files. */ + if (idxCluster == 0) + return VINF_SUCCESS; + + /* Work cluster by cluster. */ + uint8_t const *pbFat = pFatCache->aEntries[0].pbData; + for (;;) + { + /* Validate the cluster, checking for end of file. */ + if ( idxCluster >= pFatCache->cClusters + || idxCluster < FAT_FIRST_DATA_CLUSTER) + { + if (idxCluster >= FAT_FIRST_FAT16_EOC) + return VINF_SUCCESS; + return VERR_VFS_BOGUS_OFFSET; + } + + /* Add cluster to chain. */ + int rc = rtFsFatChain_Append(pChain, idxCluster); + if (RT_FAILURE(rc)) + return rc; + + /* Next cluster. */ + idxCluster = RT_MAKE_U16(pbFat[idxCluster * 2], pbFat[idxCluster * 2 + 1]); + } +} + + +/** + * Worker for rtFsFatClusterMap_ReadClusterChain handling FAT32. + */ +static int rtFsFatClusterMap_Fat32_ReadClusterChain(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, PRTFSFATCHAIN pChain) +{ + /* Special case for empty files. */ + if (idxCluster == 0) + return VINF_SUCCESS; + + /* Work cluster by cluster. */ + for (;;) + { + /* Validate the cluster, checking for end of file. */ + if ( idxCluster >= pFatCache->cClusters + || idxCluster < FAT_FIRST_DATA_CLUSTER) + { + if (idxCluster >= FAT_FIRST_FAT32_EOC) + return VINF_SUCCESS; + return VERR_VFS_BOGUS_OFFSET; + } + + /* Add cluster to chain. */ + int rc = rtFsFatChain_Append(pChain, idxCluster); + if (RT_FAILURE(rc)) + return rc; + + /* Get the next cluster. */ + uint8_t *pbEntry; + rc = rtFsFatClusterMap_GetEntry(pFatCache, idxCluster * 4, &pbEntry); + if (RT_SUCCESS(rc)) + idxCluster = RT_MAKE_U32_FROM_U8(pbEntry[0], pbEntry[1], pbEntry[2], pbEntry[3]); + else + return rc; + } +} + + +/** + * Reads a cluster chain into memory + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param idxFirstCluster The first cluster. + * @param pChain The chain element to read into (and thereby + * initialize). + */ +static int rtFsFatClusterMap_ReadClusterChain(PRTFSFATVOL pThis, uint32_t idxFirstCluster, PRTFSFATCHAIN pChain) +{ + pChain->cbCluster = pThis->cbCluster; + pChain->cClusterByteShift = pThis->cClusterByteShift; + pChain->cClusters = 0; + pChain->cbChain = 0; + RTListInit(&pChain->ListParts); + switch (pThis->enmFatType) + { + case RTFSFATTYPE_FAT12: return rtFsFatClusterMap_Fat12_ReadClusterChain(pThis->pFatCache, idxFirstCluster, pChain); + case RTFSFATTYPE_FAT16: return rtFsFatClusterMap_Fat16_ReadClusterChain(pThis->pFatCache, idxFirstCluster, pChain); + case RTFSFATTYPE_FAT32: return rtFsFatClusterMap_Fat32_ReadClusterChain(pThis->pFatCache, idxFirstCluster, pChain); + default: + AssertFailedReturn(VERR_INTERNAL_ERROR_2); + } +} + + +/** + * Sets bmDirty for entry @a iEntry. + * + * @param pFatCache The FAT cache. + * @param iEntry The cache entry. + * @param offEntry The offset into the cache entry that was dirtied. + */ +DECLINLINE(void) rtFsFatClusterMap_SetDirtyByte(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t iEntry, uint32_t offEntry) +{ + uint8_t iLine = offEntry / pFatCache->cbDirtyLine; + pFatCache->aEntries[iEntry].bmDirty |= RT_BIT_64(iLine); +} + +/** + * Sets bmDirty for entry @a iEntry. + * + * @param pFatCache The FAT cache. + * @param iEntry The cache entry. + * @param pbIntoEntry Pointer into the cache entry that was dirtied. + */ +DECLINLINE(void) rtFsFatClusterMap_SetDirtyByteByPtr(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t iEntry, uint8_t *pbIntoEntry) +{ + uintptr_t offEntry = pbIntoEntry - pFatCache->aEntries[iEntry].pbData; + Assert(offEntry < pFatCache->cbEntry); + rtFsFatClusterMap_SetDirtyByte(pFatCache, iEntry, (uint32_t)offEntry); +} + + +/** Sets a FAT12 cluster value. */ +static int rtFsFatClusterMap_SetCluster12(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, uint32_t uValue) +{ + /* ASSUME that for FAT12 we cache the whole FAT in a single entry. That + way we don't need to deal with entries in different sectors and whatnot. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + AssertReturn(uValue < 0x1000, VERR_INTERNAL_ERROR_2); + + /* Make the change. */ + uint8_t *pbFat = pFatCache->aEntries[0].pbData; + uint32_t offFat = idxCluster * 3 / 2; + if (idxCluster & 1) + { + Log3(("Fat/SetCluster12: [%#x]: %#x -> %#x\n", idxCluster, (((pbFat[offFat]) & 0xf0) >> 4) | ((unsigned)pbFat[offFat + 1] << 4), uValue)); + pbFat[offFat] = ((uint8_t)0x0f & pbFat[offFat]) | ((uint8_t)uValue << 4); + pbFat[offFat + 1] = (uint8_t)(uValue >> 4); + } + else + { + Log3(("Fat/SetCluster12: [%#x]: %#x -> %#x\n", idxCluster, pbFat[offFat] | ((pbFat[offFat + 1] & 0x0f) << 8), uValue)); + pbFat[offFat] = (uint8_t)uValue; + pbFat[offFat + 1] = ((uint8_t)0xf0 & pbFat[offFat + 1]) | (uint8_t)(uValue >> 8); + } + + /* Update the dirty bits. */ + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat); + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat + 1); + + return VINF_SUCCESS; +} + + +/** Sets a FAT16 cluster value. */ +static int rtFsFatClusterMap_SetCluster16(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, uint32_t uValue) +{ + /* ASSUME that for FAT16 we cache the whole FAT in a single entry. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + AssertReturn(uValue < 0x10000, VERR_INTERNAL_ERROR_2); + + /* Make the change. */ + uint8_t *pbFat = pFatCache->aEntries[0].pbData; + uint32_t offFat = idxCluster * 2; + pbFat[offFat] = (uint8_t)idxCluster; + pbFat[offFat + 1] = (uint8_t)(idxCluster >> 8); + + /* Update the dirty bits. */ + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat); + + return VINF_SUCCESS; +} + + +/** Sets a FAT32 cluster value. */ +static int rtFsFatClusterMap_SetCluster32(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxCluster, uint32_t uValue) +{ + AssertReturn(uValue < 0x10000000, VERR_INTERNAL_ERROR_2); + + /* Get the fat cache entry. */ + uint8_t *pbEntry; + uint32_t idxEntry; + int rc = rtFsFatClusterMap_GetEntryEx(pFatCache, idxCluster * 4, &pbEntry, &idxEntry); + if (RT_SUCCESS(rc)) + { + /* Make the change. */ + pbEntry[0] = (uint8_t)idxCluster; + pbEntry[1] = (uint8_t)(idxCluster >> 8); + pbEntry[2] = (uint8_t)(idxCluster >> 16); + pbEntry[3] = (uint8_t)(idxCluster >> 24); + + /* Update the dirty bits. */ + rtFsFatClusterMap_SetDirtyByteByPtr(pFatCache, idxEntry, pbEntry); + } + + return rc; +} + + +/** + * Marks the cluster @a idxCluster as the end of the cluster chain. + * + * @returns IPRT status code + * @param pThis The FAT volume instance. + * @param idxCluster The cluster to end the chain with. + */ +static int rtFsFatClusterMap_SetEndOfChain(PRTFSFATVOL pThis, uint32_t idxCluster) +{ + AssertReturn(idxCluster >= FAT_FIRST_DATA_CLUSTER, VERR_VFS_BOGUS_OFFSET); + AssertMsgReturn(idxCluster < pThis->cClusters, ("idxCluster=%#x cClusters=%#x\n", idxCluster, pThis->cClusters), + VERR_VFS_BOGUS_OFFSET); + switch (pThis->enmFatType) + { + case RTFSFATTYPE_FAT12: return rtFsFatClusterMap_SetCluster12(pThis->pFatCache, idxCluster, FAT_FIRST_FAT12_EOC); + case RTFSFATTYPE_FAT16: return rtFsFatClusterMap_SetCluster16(pThis->pFatCache, idxCluster, FAT_FIRST_FAT16_EOC); + case RTFSFATTYPE_FAT32: return rtFsFatClusterMap_SetCluster32(pThis->pFatCache, idxCluster, FAT_FIRST_FAT32_EOC); + default: AssertFailedReturn(VERR_INTERNAL_ERROR_3); + } +} + + +/** + * Marks the cluster @a idxCluster as free. + * @returns IPRT status code + * @param pThis The FAT volume instance. + * @param idxCluster The cluster to free. + */ +static int rtFsFatClusterMap_FreeCluster(PRTFSFATVOL pThis, uint32_t idxCluster) +{ + AssertReturn(idxCluster >= FAT_FIRST_DATA_CLUSTER, VERR_VFS_BOGUS_OFFSET); + AssertReturn(idxCluster < pThis->cClusters, VERR_VFS_BOGUS_OFFSET); + switch (pThis->enmFatType) + { + case RTFSFATTYPE_FAT12: return rtFsFatClusterMap_SetCluster12(pThis->pFatCache, idxCluster, 0); + case RTFSFATTYPE_FAT16: return rtFsFatClusterMap_SetCluster16(pThis->pFatCache, idxCluster, 0); + case RTFSFATTYPE_FAT32: return rtFsFatClusterMap_SetCluster32(pThis->pFatCache, idxCluster, 0); + default: AssertFailedReturn(VERR_INTERNAL_ERROR_3); + } +} + + +/** + * Worker for rtFsFatClusterMap_AllocateCluster that handles FAT12. + */ +static int rtFsFatClusterMap_AllocateCluster12(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxPrevCluster, uint32_t *pidxCluster) +{ + /* ASSUME that for FAT12 we cache the whole FAT in a single entry. That + way we don't need to deal with entries in different sectors and whatnot. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + + /* + * Check that the previous cluster is a valid chain end. + */ + uint8_t *pbFat = pFatCache->aEntries[0].pbData; + uint32_t offFatPrev; + if (idxPrevCluster != UINT32_MAX) + { + offFatPrev = idxPrevCluster * 3 / 2; + AssertReturn(offFatPrev + 1 < pFatCache->cbFat, VERR_INTERNAL_ERROR_3); + uint32_t idxPrevValue; + if (idxPrevCluster & 1) + idxPrevValue = (pbFat[offFatPrev] >> 4) | ((uint32_t)pbFat[offFatPrev + 1] << 4); + else + idxPrevValue = pbFat[offFatPrev] | ((uint32_t)(pbFat[offFatPrev + 1] & 0x0f) << 8); + AssertReturn(idxPrevValue >= FAT_FIRST_FAT12_EOC, VERR_VFS_BOGUS_OFFSET); + } + else + offFatPrev = UINT32_MAX; + + /* + * Search cluster by cluster from the start (it's small, so easy trumps + * complicated optimizations). + */ + uint32_t idxCluster = FAT_FIRST_DATA_CLUSTER; + uint32_t offFat = 3; + while (idxCluster < pFatCache->cClusters) + { + if (idxCluster & 1) + { + if ( (pbFat[offFat] & 0xf0) != 0 + || pbFat[offFat + 1] != 0) + { + offFat += 2; + idxCluster++; + continue; + } + + /* Set EOC. */ + pbFat[offFat] |= 0xf0; + pbFat[offFat + 1] = 0xff; + } + else + { + if ( pbFat[offFat] + || pbFat[offFat + 1] & 0x0f) + { + offFat += 1; + idxCluster++; + continue; + } + + /* Set EOC. */ + pbFat[offFat] = 0xff; + pbFat[offFat + 1] |= 0x0f; + } + + /* Update the dirty bits. */ + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat); + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat + 1); + + /* Chain it onto the previous cluster. */ + if (idxPrevCluster != UINT32_MAX) + { + if (idxPrevCluster & 1) + { + pbFat[offFatPrev] = (pbFat[offFatPrev] & (uint8_t)0x0f) | (uint8_t)(idxCluster << 4); + pbFat[offFatPrev + 1] = (uint8_t)(idxCluster >> 4); + } + else + { + pbFat[offFatPrev] = (uint8_t)idxCluster; + pbFat[offFatPrev + 1] = (pbFat[offFatPrev + 1] & (uint8_t)0xf0) | ((uint8_t)(idxCluster >> 8) & (uint8_t)0x0f); + } + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFatPrev); + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFatPrev + 1); + } + + *pidxCluster = idxCluster; + return VINF_SUCCESS; + } + + return VERR_DISK_FULL; +} + + +/** + * Worker for rtFsFatClusterMap_AllocateCluster that handles FAT16. + */ +static int rtFsFatClusterMap_AllocateCluster16(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxPrevCluster, uint32_t *pidxCluster) +{ + /* ASSUME that for FAT16 we cache the whole FAT in a single entry. */ + AssertReturn(pFatCache->cEntries == 1, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->cbEntry == pFatCache->cbFat, VERR_INTERNAL_ERROR_4); + AssertReturn(pFatCache->aEntries[0].offFat == 0, VERR_INTERNAL_ERROR_4); + + /* + * Check that the previous cluster is a valid chain end. + */ + uint8_t *pbFat = pFatCache->aEntries[0].pbData; + uint32_t offFatPrev; + if (idxPrevCluster != UINT32_MAX) + { + offFatPrev = idxPrevCluster * 2; + AssertReturn(offFatPrev + 1 < pFatCache->cbFat, VERR_INTERNAL_ERROR_3); + uint32_t idxPrevValue = RT_MAKE_U16(pbFat[offFatPrev], pbFat[offFatPrev + 1]); + AssertReturn(idxPrevValue >= FAT_FIRST_FAT16_EOC, VERR_VFS_BOGUS_OFFSET); + } + else + offFatPrev = UINT32_MAX; + + /* + * We start searching at idxAllocHint and continues to the end. The next + * iteration starts searching from the start and up to idxAllocHint. + */ + uint32_t idxCluster = RT_MIN(pFatCache->idxAllocHint, FAT_FIRST_DATA_CLUSTER); + uint32_t offFat = idxCluster * 2; + uint32_t cClusters = pFatCache->cClusters; + for (uint32_t i = 0; i < 2; i++) + { + while (idxCluster < cClusters) + { + if ( pbFat[offFat + 0] != 0x00 + || pbFat[offFat + 1] != 0x00) + { + /* In use - advance to the next one. */ + offFat += 2; + idxCluster++; + } + else + { + /* + * Found one. Grab it. + */ + /* Set EOC. */ + pbFat[offFat + 0] = 0xff; + pbFat[offFat + 1] = 0xff; + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFat); + + /* Chain it onto the previous cluster (if any). */ + if (idxPrevCluster != UINT32_MAX) + { + pbFat[offFatPrev + 0] = (uint8_t)idxCluster; + pbFat[offFatPrev + 1] = (uint8_t)(idxCluster >> 8); + rtFsFatClusterMap_SetDirtyByte(pFatCache, 0, offFatPrev); + } + + /* Update the allocation hint. */ + pFatCache->idxAllocHint = idxCluster + 1; + + /* Done. */ + *pidxCluster = idxCluster; + return VINF_SUCCESS; + } + } + + /* Wrap around to the start of the map. */ + cClusters = RT_MIN(pFatCache->idxAllocHint, pFatCache->cClusters); + idxCluster = FAT_FIRST_DATA_CLUSTER; + offFat = 4; + } + + return VERR_DISK_FULL; +} + + +/** + * Worker for rtFsFatClusterMap_AllocateCluster that handles FAT32. + */ +static int rtFsFatClusterMap_AllocateCluster32(PRTFSFATCLUSTERMAPCACHE pFatCache, uint32_t idxPrevCluster, uint32_t *pidxCluster) +{ + /* + * Check that the previous cluster is a valid chain end. + */ + int rc; + uint8_t *pbEntry; + if (idxPrevCluster != UINT32_MAX) + { + rc = rtFsFatClusterMap_GetEntry(pFatCache, idxPrevCluster * 4, &pbEntry); + if (RT_SUCCESS(rc)) + { + uint32_t idxPrevValue = RT_MAKE_U32_FROM_U8(pbEntry[0], pbEntry[1], pbEntry[2], pbEntry[3]); + AssertReturn(idxPrevValue >= FAT_FIRST_FAT32_EOC, VERR_VFS_BOGUS_OFFSET); + } + else + return rc; + } + + /* + * We start searching at idxAllocHint and continues to the end. The next + * iteration starts searching from the start and up to idxAllocHint. + */ + uint32_t idxCluster = RT_MIN(pFatCache->idxAllocHint, FAT_FIRST_DATA_CLUSTER); + uint32_t offFat = idxCluster * 4; + uint32_t cClusters = pFatCache->cClusters; + for (uint32_t i = 0; i < 2; i++) + { + while (idxCluster < cClusters) + { + /* Note! This could be done in cache entry chunks. */ + uint32_t idxEntry; + rc = rtFsFatClusterMap_GetEntryEx(pFatCache, offFat, &pbEntry, &idxEntry); + if (RT_SUCCESS(rc)) + { + if ( pbEntry[0] != 0x00 + || pbEntry[1] != 0x00 + || pbEntry[2] != 0x00 + || pbEntry[3] != 0x00) + { + /* In use - advance to the next one. */ + offFat += 4; + idxCluster++; + } + else + { + /* + * Found one. Grab it. + */ + /* Set EOC. */ + pbEntry[0] = 0xff; + pbEntry[1] = 0xff; + pbEntry[2] = 0xff; + pbEntry[3] = 0x0f; + rtFsFatClusterMap_SetDirtyByteByPtr(pFatCache, idxEntry, pbEntry); + + /* Chain it on the previous cluster (if any). */ + if (idxPrevCluster != UINT32_MAX) + { + rc = rtFsFatClusterMap_GetEntryEx(pFatCache, idxPrevCluster * 4, &pbEntry, &idxEntry); + if (RT_SUCCESS(rc)) + { + pbEntry[0] = (uint8_t)idxCluster; + pbEntry[1] = (uint8_t)(idxCluster >> 8); + pbEntry[2] = (uint8_t)(idxCluster >> 16); + pbEntry[3] = (uint8_t)(idxCluster >> 24); + rtFsFatClusterMap_SetDirtyByteByPtr(pFatCache, idxEntry, pbEntry); + } + else + { + /* Try free the cluster. */ + int rc2 = rtFsFatClusterMap_GetEntryEx(pFatCache, offFat, &pbEntry, &idxEntry); + if (RT_SUCCESS(rc2)) + { + pbEntry[0] = 0; + pbEntry[1] = 0; + pbEntry[2] = 0; + pbEntry[3] = 0; + rtFsFatClusterMap_SetDirtyByteByPtr(pFatCache, idxEntry, pbEntry); + } + return rc; + } + } + + /* Update the allocation hint. */ + pFatCache->idxAllocHint = idxCluster + 1; + + /* Done. */ + *pidxCluster = idxCluster; + return VINF_SUCCESS; + } + } + } + + /* Wrap around to the start of the map. */ + cClusters = RT_MIN(pFatCache->idxAllocHint, pFatCache->cClusters); + idxCluster = FAT_FIRST_DATA_CLUSTER; + offFat = 4; + } + + return VERR_DISK_FULL; +} + + +/** + * Allocates a cluster an appends it to the chain given by @a idxPrevCluster. + * + * @returns IPRT status code. + * @retval VERR_DISK_FULL if no more available clusters. + * @param pThis The FAT volume instance. + * @param idxPrevCluster The previous cluster, UINT32_MAX if first. + * @param pidxCluster Where to return the cluster number on success. + */ +static int rtFsFatClusterMap_AllocateCluster(PRTFSFATVOL pThis, uint32_t idxPrevCluster, uint32_t *pidxCluster) +{ + AssertReturn(idxPrevCluster == UINT32_MAX || (idxPrevCluster >= FAT_FIRST_DATA_CLUSTER && idxPrevCluster < pThis->cClusters), + VERR_INTERNAL_ERROR_5); + *pidxCluster = UINT32_MAX; + switch (pThis->enmFatType) + { + case RTFSFATTYPE_FAT12: return rtFsFatClusterMap_AllocateCluster12(pThis->pFatCache, idxPrevCluster, pidxCluster); + case RTFSFATTYPE_FAT16: return rtFsFatClusterMap_AllocateCluster16(pThis->pFatCache, idxPrevCluster, pidxCluster); + case RTFSFATTYPE_FAT32: return rtFsFatClusterMap_AllocateCluster32(pThis->pFatCache, idxPrevCluster, pidxCluster); + default: AssertFailedReturn(VERR_INTERNAL_ERROR_3); + } +} + + +/** + * Allocates clusters. + * + * Will free the clusters if it fails to allocate all of them. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param pChain The chain. + * @param cClusters Number of clusters to add to the chain. + */ +static int rtFsFatClusterMap_AllocateMoreClusters(PRTFSFATVOL pThis, PRTFSFATCHAIN pChain, uint32_t cClusters) +{ + int rc = VINF_SUCCESS; + uint32_t const cOldClustersInChain = pChain->cClusters; + uint32_t const idxOldLastCluster = rtFsFatChain_GetLastCluster(pChain); + uint32_t idxPrevCluster = idxOldLastCluster; + uint32_t iCluster = 0; + while (iCluster < cClusters) + { + uint32_t idxCluster; + rc = rtFsFatClusterMap_AllocateCluster(pThis, idxPrevCluster, &idxCluster); + if (RT_SUCCESS(rc)) + { + rc = rtFsFatChain_Append(pChain, idxCluster); + if (RT_SUCCESS(rc)) + { + /* next */ + iCluster++; + continue; + } + + /* Bail out, freeing any clusters we've managed to allocate by now. */ + rtFsFatClusterMap_FreeCluster(pThis, idxCluster); + } + if (idxOldLastCluster != UINT32_MAX) + rtFsFatClusterMap_SetEndOfChain(pThis, idxOldLastCluster); + while (iCluster-- > 0) + rtFsFatClusterMap_FreeCluster(pThis, rtFsFatChain_GetClusterByIndex(pChain, cOldClustersInChain + iCluster)); + rtFsFatChain_Shrink(pChain, iCluster); + break; + } + return rc; +} + + + +/** + * Converts a FAT timestamp into an IPRT timesspec. + * + * @param pTimeSpec Where to return the IRPT time. + * @param uDate The date part of the FAT timestamp. + * @param uTime The time part of the FAT timestamp. + * @param cCentiseconds Centiseconds part if applicable (0 otherwise). + * @param pVol The volume. + */ +static void rtFsFatDateTime2TimeSpec(PRTTIMESPEC pTimeSpec, uint16_t uDate, uint16_t uTime, + uint8_t cCentiseconds, PCRTFSFATVOL pVol) +{ + RTTIME Time; + Time.fFlags = RTTIME_FLAGS_TYPE_UTC; + Time.offUTC = 0; + Time.i32Year = 1980 + (uDate >> 9); + Time.u8Month = RT_MAX((uDate >> 5) & 0xf, 1); + Time.u8MonthDay = RT_MAX(uDate & 0x1f, 1); + Time.u8WeekDay = UINT8_MAX; + Time.u16YearDay = 0; + Time.u8Hour = uTime >> 11; + Time.u8Minute = (uTime >> 5) & 0x3f; + Time.u8Second = (uTime & 0x1f) << 1; + Time.u32Nanosecond = 0; + if (cCentiseconds > 0 && cCentiseconds < 200) /* screw complicated stuff for now. */ + { + if (cCentiseconds >= 100) + { + cCentiseconds -= 100; + Time.u8Second++; + } + Time.u32Nanosecond = cCentiseconds * UINT64_C(100000000); + } + + RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time)); + RTTimeSpecSubNano(pTimeSpec, pVol->offNanoUTC); +} + + +/** + * Converts an IPRT timespec to a FAT timestamp. + * + * @returns The centiseconds part. + * @param pVol The volume. + * @param pTimeSpec The IPRT timespec to convert (UTC). + * @param puDate Where to return the date part of the FAT timestamp. + * @param puTime Where to return the time part of the FAT timestamp. + */ +static uint8_t rtFsFatTimeSpec2FatDateTime(PCRTFSFATVOL pVol, PCRTTIMESPEC pTimeSpec, uint16_t *puDate, uint16_t *puTime) +{ + RTTIMESPEC TimeSpec = *pTimeSpec; + RTTIME Time; + RTTimeExplode(&Time, RTTimeSpecSubNano(&TimeSpec, pVol->offNanoUTC)); + + if (puDate) + *puDate = ((uint16_t)(RT_MAX(Time.i32Year, 1980) - 1980) << 9) + | (Time.u8Month << 5) + | Time.u8MonthDay; + if (puTime) + *puTime = ((uint16_t)Time.u8Hour << 11) + | (Time.u8Minute << 5) + | (Time.u8Second >> 1); + return (Time.u8Second & 1) * 100 + Time.u32Nanosecond / 10000000; + +} + + +/** + * Gets the current FAT timestamp. + * + * @returns The centiseconds part. + * @param pVol The volume. + * @param puDate Where to return the date part of the FAT timestamp. + * @param puTime Where to return the time part of the FAT timestamp. + */ +static uint8_t rtFsFatCurrentFatDateTime(PCRTFSFATVOL pVol, uint16_t *puDate, uint16_t *puTime) +{ + RTTIMESPEC TimeSpec; + return rtFsFatTimeSpec2FatDateTime(pVol, RTTimeNow(&TimeSpec), puDate, puTime); +} + + +/** + * Initialization of a RTFSFATOBJ structure from a FAT directory entry. + * + * @note The RTFSFATOBJ::pParentDir and RTFSFATOBJ::Clusters members are + * properly initialized elsewhere. + * + * @param pObj The structure to initialize. + * @param pDirEntry The directory entry. + * @param offEntryInDir The offset in the parent directory. + * @param pVol The volume. + */ +static void rtFsFatObj_InitFromDirEntry(PRTFSFATOBJ pObj, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir, PRTFSFATVOL pVol) +{ + RTListInit(&pObj->Entry); + pObj->cRefs = 1; + pObj->pParentDir = NULL; + pObj->pVol = pVol; + pObj->offEntryInDir = offEntryInDir; + pObj->fAttrib = ((RTFMODE)pDirEntry->fAttrib << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_OS2; + pObj->fAttrib = rtFsModeFromDos(pObj->fAttrib, (char *)&pDirEntry->achName[0], sizeof(pDirEntry->achName), 0); + pObj->cbObject = pDirEntry->cbFile; + pObj->fMaybeDirtyFat = false; + pObj->fMaybeDirtyDirEnt = false; + rtFsFatDateTime2TimeSpec(&pObj->ModificationTime, pDirEntry->uModifyDate, pDirEntry->uModifyTime, 0, pVol); + rtFsFatDateTime2TimeSpec(&pObj->BirthTime, pDirEntry->uBirthDate, pDirEntry->uBirthTime, pDirEntry->uBirthCentiseconds, pVol); + rtFsFatDateTime2TimeSpec(&pObj->AccessTime, pDirEntry->uAccessDate, 0, 0, pVol); +} + + +/** + * Dummy initialization of a RTFSFATOBJ structure. + * + * @note The RTFSFATOBJ::pParentDir and RTFSFATOBJ::Clusters members are + * properly initialized elsewhere. + * + * @param pObj The structure to initialize. + * @param cbObject The object size. + * @param fAttrib The attributes. + * @param pVol The volume. + */ +static void rtFsFatObj_InitDummy(PRTFSFATOBJ pObj, uint32_t cbObject, RTFMODE fAttrib, PRTFSFATVOL pVol) +{ + RTListInit(&pObj->Entry); + pObj->cRefs = 1; + pObj->pParentDir = NULL; + pObj->pVol = pVol; + pObj->offEntryInDir = UINT32_MAX; + pObj->fAttrib = fAttrib; + pObj->cbObject = cbObject; + pObj->fMaybeDirtyFat = false; + pObj->fMaybeDirtyDirEnt = false; + RTTimeSpecSetDosSeconds(&pObj->AccessTime, 0); + RTTimeSpecSetDosSeconds(&pObj->ModificationTime, 0); + RTTimeSpecSetDosSeconds(&pObj->BirthTime, 0); +} + + +/** + * Flushes FAT object meta data. + * + * @returns IPRT status code + * @param pObj The common object structure. + */ +static int rtFsFatObj_FlushMetaData(PRTFSFATOBJ pObj) +{ + int rc = VINF_SUCCESS; + if (pObj->fMaybeDirtyFat) + { + rc = rtFsFatClusterMap_Flush(pObj->pVol); + if (RT_SUCCESS(rc)) + pObj->fMaybeDirtyFat = false; + } + if (pObj->fMaybeDirtyDirEnt) + { + int rc2 = rtFsFatDirShrd_Flush(pObj->pParentDir); + if (RT_SUCCESS(rc2)) + pObj->fMaybeDirtyDirEnt = false; + else if (RT_SUCCESS(rc)) + rc = rc2; + } + return rc; +} + + +/** + * Worker for rtFsFatFile_Close and rtFsFatDir_Close that does common work. + * + * @returns IPRT status code. + * @param pObj The common object structure. + */ +static int rtFsFatObj_Close(PRTFSFATOBJ pObj) +{ + int rc = rtFsFatObj_FlushMetaData(pObj); + if (pObj->pParentDir) + rtFsFatDirShrd_RemoveOpenChild(pObj->pParentDir, pObj); + rtFsFatChain_Delete(&pObj->Clusters); + return rc; +} + + +/** + * Worker for rtFsFatFile_QueryInfo and rtFsFatDir_QueryInfo + */ +static int rtFsFatObj_QueryInfo(PRTFSFATOBJ pThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + LogFlow(("rtFsFatObj_QueryInfo: %p fMode=%#x\n", pThis, pThis->fAttrib)); + + pObjInfo->cbObject = pThis->cbObject; + pObjInfo->cbAllocated = pThis->Clusters.cbChain; + pObjInfo->AccessTime = pThis->AccessTime; + pObjInfo->ModificationTime = pThis->ModificationTime; + pObjInfo->ChangeTime = pThis->ModificationTime; + pObjInfo->BirthTime = pThis->BirthTime; + pObjInfo->Attr.fMode = pThis->fAttrib; + pObjInfo->Attr.enmAdditional = enmAddAttr; + + switch (enmAddAttr) + { + case RTFSOBJATTRADD_NOTHING: RT_FALL_THRU(); + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.u.Unix.uid = NIL_RTUID; + pObjInfo->Attr.u.Unix.gid = NIL_RTGID; + pObjInfo->Attr.u.Unix.cHardlinks = 1; + pObjInfo->Attr.u.Unix.INodeIdDevice = 0; + pObjInfo->Attr.u.Unix.INodeId = 0; /* Could probably use the directory entry offset. */ + pObjInfo->Attr.u.Unix.fFlags = 0; + pObjInfo->Attr.u.Unix.GenerationId = 0; + pObjInfo->Attr.u.Unix.Device = 0; + break; + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = 0; + pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; + break; + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = 0; + pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; + break; + case RTFSOBJATTRADD_EASIZE: + pObjInfo->Attr.u.EASize.cb = 0; + break; + default: + return VERR_INVALID_PARAMETER; + } + return VINF_SUCCESS; +} + + +/** + * Worker for rtFsFatFile_SetMode and rtFsFatDir_SetMode. + */ +static int rtFsFatObj_SetMode(PRTFSFATOBJ pThis, RTFMODE fMode, RTFMODE fMask) +{ +#if 0 + if (fMask != ~RTFS_TYPE_MASK) + { + fMode |= ~fMask & ObjInfo.Attr.fMode; + } +#else + RT_NOREF(pThis, fMode, fMask); + return VERR_NOT_IMPLEMENTED; +#endif +} + + +/** + * Worker for rtFsFatFile_SetTimes and rtFsFatDir_SetTimes. + */ +static int rtFsFatObj_SetTimes(PRTFSFATOBJ pThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ +#if 0 + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; +#else + RT_NOREF(pThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_NOT_IMPLEMENTED; +#endif +} + + + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsFatFile_Close(void *pvThis) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + LogFlow(("rtFsFatFile_Close(%p/%p)\n", pThis, pThis->pShared)); + + PRTFSFATFILESHRD pShared = pThis->pShared; + pThis->pShared = NULL; + + int rc = VINF_SUCCESS; + if (pShared) + { + if (ASMAtomicDecU32(&pShared->Core.cRefs) == 0) + { + LogFlow(("rtFsFatFile_Close: Destroying shared structure %p\n", pShared)); + rc = rtFsFatObj_Close(&pShared->Core); + RTMemFree(pShared); + } + else + rc = rtFsFatObj_FlushMetaData(&pShared->Core); + } + return rc; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsFatFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + return rtFsFatObj_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsFatFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + AssertReturn(pSgBuf->cSegs != 0, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + /* + * Check for EOF. + */ + if (off == -1) + off = pThis->offFile; + if ((uint64_t)off >= pShared->Core.cbObject) + { + if (pcbRead) + { + *pcbRead = 0; + return VINF_EOF; + } + return VERR_EOF; + } + + /* + * Do the reading cluster by cluster. + */ + int rc = VINF_SUCCESS; + uint32_t cbFileLeft = pShared->Core.cbObject - (uint32_t)off; + uint32_t cbRead = 0; + size_t cbLeft = pSgBuf->paSegs[0].cbSeg; + uint8_t *pbDst = (uint8_t *)pSgBuf->paSegs[0].pvSeg; + while (cbLeft > 0) + { + if (cbFileLeft > 0) + { + uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pShared->Core.Clusters, (uint32_t)off, pShared->Core.pVol); + if (offDisk != UINT64_MAX) + { + uint32_t cbToRead = pShared->Core.Clusters.cbCluster - ((uint32_t)off & (pShared->Core.Clusters.cbCluster - 1)); + if (cbToRead > cbLeft) + cbToRead = (uint32_t)cbLeft; + if (cbToRead > cbFileLeft) + cbToRead = cbFileLeft; + rc = RTVfsFileReadAt(pShared->Core.pVol->hVfsBacking, offDisk, pbDst, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + off += cbToRead; + pbDst += cbToRead; + cbRead += cbToRead; + cbFileLeft -= cbToRead; + cbLeft -= cbToRead; + continue; + } + } + else + rc = VERR_VFS_BOGUS_OFFSET; + } + else + rc = pcbRead ? VINF_EOF : VERR_EOF; + break; + } + + /* Update the offset and return. */ + pThis->offFile = off; + if (pcbRead) + *pcbRead = cbRead; + return rc; +} + + +/** + * Changes the size of a file or directory FAT object. + * + * @returns IPRT status code + * @param pObj The common object. + * @param cbFile The new file size. + */ +static int rtFsFatObj_SetSize(PRTFSFATOBJ pObj, uint32_t cbFile) +{ + AssertReturn( ((pObj->cbObject + pObj->Clusters.cbCluster - 1) >> pObj->Clusters.cClusterByteShift) + == pObj->Clusters.cClusters, VERR_INTERNAL_ERROR_3); + + /* + * Do nothing if the size didn't change. + */ + if (pObj->cbObject == cbFile) + return VINF_SUCCESS; + + /* + * Do we need to allocate or free clusters? + */ + int rc = VINF_SUCCESS; + uint32_t const cClustersNew = (cbFile + pObj->Clusters.cbCluster - 1) >> pObj->Clusters.cClusterByteShift; + AssertReturn(pObj->pParentDir, VERR_INTERNAL_ERROR_2); + if (pObj->Clusters.cClusters == cClustersNew) + { /* likely when writing small bits at a time. */ } + else if (pObj->Clusters.cClusters < cClustersNew) + { + /* Allocate and append new clusters. */ + do + { + uint32_t idxCluster; + rc = rtFsFatClusterMap_AllocateCluster(pObj->pVol, rtFsFatChain_GetLastCluster(&pObj->Clusters), &idxCluster); + if (RT_SUCCESS(rc)) + rc = rtFsFatChain_Append(&pObj->Clusters, idxCluster); + } while (pObj->Clusters.cClusters < cClustersNew && RT_SUCCESS(rc)); + pObj->fMaybeDirtyFat = true; + } + else + { + /* Free clusters we don't need any more. */ + if (cClustersNew > 0) + rc = rtFsFatClusterMap_SetEndOfChain(pObj->pVol, rtFsFatChain_GetClusterByIndex(&pObj->Clusters, cClustersNew - 1)); + if (RT_SUCCESS(rc)) + { + uint32_t iClusterToFree = cClustersNew; + while (iClusterToFree < pObj->Clusters.cClusters && RT_SUCCESS(rc)) + { + rc = rtFsFatClusterMap_FreeCluster(pObj->pVol, rtFsFatChain_GetClusterByIndex(&pObj->Clusters, iClusterToFree)); + iClusterToFree++; + } + + rtFsFatChain_Shrink(&pObj->Clusters, cClustersNew); + } + pObj->fMaybeDirtyFat = true; + } + if (RT_SUCCESS(rc)) + { + /* + * Update the object size, since we've got the right number of clusters backing it now. + */ + pObj->cbObject = cbFile; + + /* + * Update the directory entry. + */ + uint32_t uWriteLock; + PFATDIRENTRY pDirEntry; + rc = rtFsFatDirShrd_GetEntryForUpdate(pObj->pParentDir, pObj->offEntryInDir, &pDirEntry, &uWriteLock); + if (RT_SUCCESS(rc)) + { + pDirEntry->cbFile = cbFile; + uint32_t idxFirstCluster; + if (cClustersNew == 0) + idxFirstCluster = 0; /** @todo figure out if setting the cluster to 0 is the right way to deal with empty files... */ + else + idxFirstCluster = rtFsFatChain_GetFirstCluster(&pObj->Clusters); + pDirEntry->idxCluster = (uint16_t)idxFirstCluster; + if (pObj->pVol->enmFatType >= RTFSFATTYPE_FAT32) + pDirEntry->u.idxClusterHigh = (uint16_t)(idxFirstCluster >> 16); + + rc = rtFsFatDirShrd_PutEntryAfterUpdate(pObj->pParentDir, pDirEntry, uWriteLock); + pObj->fMaybeDirtyDirEnt = true; + } + } + Log3(("rtFsFatObj_SetSize: Returns %Rrc\n", rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite} + */ +static DECLCALLBACK(int) rtFsFatFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + PRTFSFATVOL pVol = pShared->Core.pVol; + AssertReturn(pSgBuf->cSegs != 0, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + if (pVol->fReadOnly) + return VERR_WRITE_PROTECT; + + if (off == -1) + off = pThis->offFile; + + /* + * Do the reading cluster by cluster. + */ + int rc = VINF_SUCCESS; + uint32_t cbWritten = 0; + size_t cbLeft = pSgBuf->paSegs[0].cbSeg; + uint8_t const *pbSrc = (uint8_t const *)pSgBuf->paSegs[0].pvSeg; + while (cbLeft > 0) + { + /* Figure out how much we can write. Checking for max file size and such. */ + uint32_t cbToWrite = pShared->Core.Clusters.cbCluster - ((uint32_t)off & (pShared->Core.Clusters.cbCluster - 1)); + if (cbToWrite > cbLeft) + cbToWrite = (uint32_t)cbLeft; + uint64_t offNew = (uint64_t)off + cbToWrite; + if (offNew < _4G) + { /*likely*/ } + else if ((uint64_t)off < _4G - 1U) + cbToWrite = _4G - 1U - off; + else + { + rc = VERR_FILE_TOO_BIG; + break; + } + + /* Grow the file? */ + if ((uint32_t)offNew > pShared->Core.cbObject) + { + rc = rtFsFatObj_SetSize(&pShared->Core, (uint32_t)offNew); + if (RT_SUCCESS(rc)) + { /* likely */} + else + break; + } + + /* Figure the disk offset. */ + uint64_t offDisk = rtFsFatChain_FileOffsetToDiskOff(&pShared->Core.Clusters, (uint32_t)off, pVol); + if (offDisk != UINT64_MAX) + { + rc = RTVfsFileWriteAt(pVol->hVfsBacking, offDisk, pbSrc, cbToWrite, NULL); + if (RT_SUCCESS(rc)) + { + off += cbToWrite; + pbSrc += cbToWrite; + cbWritten += cbToWrite; + cbLeft -= cbToWrite; + } + else + break; + } + else + { + rc = VERR_VFS_BOGUS_OFFSET; + break; + } + } + + /* Update the offset and return. */ + pThis->offFile = off; + if (pcbWritten) + *pcbWritten = cbWritten; + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsFatFile_Flush(void *pvThis) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + int rc1 = rtFsFatObj_FlushMetaData(&pShared->Core); + int rc2 = RTVfsFileFlush(pShared->Core.pVol->hVfsBacking); + return RT_FAILURE(rc1) ? rc1 : rc2; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne} + */ +static DECLCALLBACK(int) rtFsFatFile_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, + uint32_t *pfRetEvents) +{ + NOREF(pvThis); + int rc; + if (fEvents != RTPOLL_EVT_ERROR) + { + *pfRetEvents = fEvents & ~RTPOLL_EVT_ERROR; + rc = VINF_SUCCESS; + } + else if (fIntr) + rc = RTThreadSleep(cMillies); + else + { + uint64_t uMsStart = RTTimeMilliTS(); + do + rc = RTThreadSleep(cMillies); + while ( rc == VERR_INTERRUPTED + && !fIntr + && RTTimeMilliTS() - uMsStart < cMillies); + if (rc == VERR_INTERRUPTED) + rc = VERR_TIMEOUT; + } + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsFatFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + *poffActual = pThis->offFile; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsFatFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + return rtFsFatObj_SetMode(&pThis->pShared->Core, fMode, fMask); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsFatFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + return rtFsFatObj_SetTimes(&pThis->pShared->Core, pAccessTime, pModificationTime, pChangeTime, pBirthTime); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsFatFile_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + RT_NOREF(pvThis, uid, gid); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsFatFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + + RTFOFF offNew; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offNew = offSeek; + break; + case RTFILE_SEEK_END: + offNew = (RTFOFF)pShared->Core.cbObject + offSeek; + break; + case RTFILE_SEEK_CURRENT: + offNew = (RTFOFF)pThis->offFile + offSeek; + break; + default: + return VERR_INVALID_PARAMETER; + } + if (offNew >= 0) + { + if (offNew <= _4G) + { + pThis->offFile = offNew; + *poffActual = offNew; + return VINF_SUCCESS; + } + return VERR_OUT_OF_RANGE; + } + return VERR_NEGATIVE_SEEK; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsFatFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + *pcbFile = pShared->Core.cbObject; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSetSize} + */ +static DECLCALLBACK(int) rtFsFatFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags) +{ + PRTFSFATFILE pThis = (PRTFSFATFILE)pvThis; + PRTFSFATFILESHRD pShared = pThis->pShared; + AssertReturn(!fFlags, VERR_NOT_SUPPORTED); + if (cbFile > UINT32_MAX) + return VERR_FILE_TOO_BIG; + return rtFsFatObj_SetSize(&pShared->Core, (uint32_t)cbFile); +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize} + */ +static DECLCALLBACK(int) rtFsFatFile_QueryMaxSize(void *pvThis, uint64_t *pcbMax) +{ + RT_NOREF(pvThis); + *pcbMax = UINT32_MAX; + return VINF_SUCCESS; +} + + +/** + * FAT file operations. + */ +DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtFsFatFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "FatFile", + rtFsFatFile_Close, + rtFsFatFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsFatFile_Read, + rtFsFatFile_Write, + rtFsFatFile_Flush, + rtFsFatFile_PollOne, + rtFsFatFile_Tell, + NULL /*pfnSkip*/, + NULL /*pfnZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + rtFsFatFile_SetMode, + rtFsFatFile_SetTimes, + rtFsFatFile_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsFatFile_Seek, + rtFsFatFile_QuerySize, + rtFsFatFile_SetSize, + rtFsFatFile_QueryMaxSize, + RTVFSFILEOPS_VERSION +}; + + +/** + * Instantiates a new directory. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param pParentDir The parent directory. + * @param pDirEntry The parent directory entry. + * @param offEntryInDir The byte offset of the directory entry in the parent + * directory. + * @param fOpen RTFILE_O_XXX flags. + * @param phVfsFile Where to return the file handle. + */ +static int rtFsFatFile_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir, + uint64_t fOpen, PRTVFSFILE phVfsFile) +{ + AssertPtr(pParentDir); + Assert(!(offEntryInDir & (sizeof(FATDIRENTRY) - 1))); + + PRTFSFATFILE pNewFile; + int rc = RTVfsNewFile(&g_rtFsFatFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + pNewFile->offFile = 0; + pNewFile->pShared = NULL; + + /* + * Look for existing shared object, create a new one if necessary. + */ + PRTFSFATFILESHRD pShared = (PRTFSFATFILESHRD)rtFsFatDirShrd_LookupShared(pParentDir, offEntryInDir); + if (pShared) + { + LogFlow(("rtFsFatFile_New: cbObject=%#RX32 \n", pShared->Core.cbObject)); + pNewFile->pShared = pShared; + return VINF_SUCCESS; + } + + pShared = (PRTFSFATFILESHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + rtFsFatObj_InitFromDirEntry(&pShared->Core, pDirEntry, offEntryInDir, pThis); + pNewFile->pShared = pShared; + + rc = rtFsFatClusterMap_ReadClusterChain(pThis, RTFSFAT_GET_CLUSTER(pDirEntry, pThis), &pShared->Core.Clusters); + if (RT_SUCCESS(rc)) + { + /* + * Link into parent directory so we can use it to update + * our directory entry. + */ + rtFsFatDirShrd_AddOpenChild(pParentDir, &pShared->Core); + + /* + * Should we truncate the file or anything of that sort? + */ + if ( (fOpen & RTFILE_O_TRUNCATE) + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE) + { + Log3(("rtFsFatFile_New: calling rtFsFatObj_SetSize to zap the file size.\n")); + rc = rtFsFatObj_SetSize(&pShared->Core, 0); + } + if (RT_SUCCESS(rc)) + { + LogFlow(("rtFsFatFile_New: cbObject=%#RX32 pShared=%p\n", pShared->Core.cbObject, pShared)); + return VINF_SUCCESS; + } + } + } + else + rc = VERR_NO_MEMORY; + + /* Destroy the file object. */ + RTVfsFileRelease(*phVfsFile); + } + *phVfsFile = NIL_RTVFSFILE; + return rc; +} + + +/** + * Looks up the shared structure for a child. + * + * @returns Referenced pointer to the shared structure, NULL if not found. + * @param pThis The directory. + * @param offEntryInDir The directory record offset of the child. + */ +static PRTFSFATOBJ rtFsFatDirShrd_LookupShared(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir) +{ + PRTFSFATOBJ pCur; + RTListForEach(&pThis->OpenChildren, pCur, RTFSFATOBJ, Entry) + { + if (pCur->offEntryInDir == offEntryInDir) + { + uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs); + Assert(cRefs > 1); RT_NOREF(cRefs); + return pCur; + } + } + return NULL; +} + + +/** + * Flush directory changes when having a fully buffered directory. + * + * @returns IPRT status code + * @param pThis The directory. + */ +static int rtFsFatDirShrd_FlushFullyBuffered(PRTFSFATDIRSHRD pThis) +{ + Assert(pThis->fFullyBuffered); + uint32_t const cbSector = pThis->Core.pVol->cbSector; + RTVFSFILE const hVfsBacking = pThis->Core.pVol->hVfsBacking; + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < pThis->u.Full.cSectors; i++) + if (ASMBitTest(pThis->u.Full.pbDirtySectors, i)) + { + int rc2 = RTVfsFileWriteAt(hVfsBacking, pThis->offEntriesOnDisk + i * cbSector, + (uint8_t *)pThis->paEntries + i * cbSector, cbSector, NULL); + if (RT_SUCCESS(rc2)) + ASMBitClear(pThis->u.Full.pbDirtySectors, i); + else if (RT_SUCCESS(rc)) + rc = rc2; + } + return rc; +} + + +/** + * Flush directory changes when using simple buffering. + * + * @returns IPRT status code + * @param pThis The directory. + */ +static int rtFsFatDirShrd_FlushSimple(PRTFSFATDIRSHRD pThis) +{ + Assert(!pThis->fFullyBuffered); + int rc; + if ( !pThis->u.Simple.fDirty + || pThis->offEntriesOnDisk != UINT64_MAX) + rc = VINF_SUCCESS; + else + { + Assert(pThis->u.Simple.offInDir != UINT32_MAX); + rc = RTVfsFileWriteAt(pThis->Core.pVol->hVfsBacking, pThis->offEntriesOnDisk, + pThis->paEntries, pThis->Core.pVol->cbSector, NULL); + if (RT_SUCCESS(rc)) + pThis->u.Simple.fDirty = false; + } + return rc; +} + + +/** + * Flush directory changes. + * + * @returns IPRT status code + * @param pThis The directory. + */ +static int rtFsFatDirShrd_Flush(PRTFSFATDIRSHRD pThis) +{ + if (pThis->fFullyBuffered) + return rtFsFatDirShrd_FlushFullyBuffered(pThis); + return rtFsFatDirShrd_FlushSimple(pThis); +} + + +/** + * Gets one or more entires at @a offEntryInDir. + * + * Common worker for rtFsFatDirShrd_GetEntriesAt and rtFsFatDirShrd_GetEntryForUpdate + * + * @returns IPRT status code. + * @param pThis The directory. + * @param offEntryInDir The directory offset in bytes. + * @param fForUpdate Whether it's for updating. + * @param ppaEntries Where to return pointer to the entry at + * @a offEntryInDir. + * @param pcEntries Where to return the number of entries + * @a *ppaEntries points to. + * @param puBufferReadLock Where to return the buffer read lock handle. + * Call rtFsFatDirShrd_ReleaseBufferAfterReading when + * done. + */ +static int rtFsFatDirShrd_GetEntriesAtCommon(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, bool fForUpdate, + PFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puLock) +{ + *puLock = UINT32_MAX; + + int rc; + Assert(RT_ALIGN_32(offEntryInDir, sizeof(FATDIRENTRY)) == offEntryInDir); + Assert(pThis->Core.cbObject / sizeof(FATDIRENTRY) == pThis->cEntries); + uint32_t const idxEntryInDir = offEntryInDir / sizeof(FATDIRENTRY); + if (idxEntryInDir < pThis->cEntries) + { + if (pThis->fFullyBuffered) + { + /* + * Fully buffered: Return pointer to all the entires starting at offEntryInDir. + */ + *ppaEntries = &pThis->paEntries[idxEntryInDir]; + *pcEntries = pThis->cEntries - idxEntryInDir; + *puLock = !fForUpdate ? 1 : UINT32_C(0x80000001); + rc = VINF_SUCCESS; + } + else + { + /* + * Simple buffering: If hit, return the number of entries. + */ + PRTFSFATVOL pVol = pThis->Core.pVol; + uint32_t off = offEntryInDir - pThis->u.Simple.offInDir; + if (off < pVol->cbSector) + { + *ppaEntries = &pThis->paEntries[off / sizeof(FATDIRENTRY)]; + *pcEntries = (pVol->cbSector - off) / sizeof(FATDIRENTRY); + *puLock = !fForUpdate ? 1 : UINT32_C(0x80000001); + rc = VINF_SUCCESS; + } + else + { + /* + * Simple buffering: Miss. + * Flush dirty. Read in new sector. Return entries in sector starting + * at offEntryInDir. + */ + if (!pThis->u.Simple.fDirty) + rc = VINF_SUCCESS; + else + rc = rtFsFatDirShrd_FlushSimple(pThis); + if (RT_SUCCESS(rc)) + { + off = offEntryInDir & (pVol->cbSector - 1); + pThis->u.Simple.offInDir = (offEntryInDir & ~(pVol->cbSector - 1)); + pThis->offEntriesOnDisk = rtFsFatChain_FileOffsetToDiskOff(&pThis->Core.Clusters, pThis->u.Simple.offInDir, + pThis->Core.pVol); + rc = RTVfsFileReadAt(pThis->Core.pVol->hVfsBacking, pThis->offEntriesOnDisk, + pThis->paEntries, pVol->cbSector, NULL); + if (RT_SUCCESS(rc)) + { + *ppaEntries = &pThis->paEntries[off / sizeof(FATDIRENTRY)]; + *pcEntries = (pVol->cbSector - off) / sizeof(FATDIRENTRY); + *puLock = !fForUpdate ? 1 : UINT32_C(0x80000001); + rc = VINF_SUCCESS; + } + else + { + pThis->u.Simple.offInDir = UINT32_MAX; + pThis->offEntriesOnDisk = UINT64_MAX; + } + } + } + } + } + else + rc = VERR_FILE_NOT_FOUND; + return rc; +} + + +/** + * Puts back a directory entry after updating it, releasing the write lock and + * marking it dirty. + * + * @returns IPRT status code + * @param pThis The directory. + * @param pDirEntry The directory entry. + * @param uWriteLock The write lock. + */ +static int rtFsFatDirShrd_PutEntryAfterUpdate(PRTFSFATDIRSHRD pThis, PFATDIRENTRY pDirEntry, uint32_t uWriteLock) +{ + Assert(uWriteLock == UINT32_C(0x80000001)); + RT_NOREF(uWriteLock); + if (pThis->fFullyBuffered) + { + uint32_t idxSector = ((uintptr_t)pDirEntry - (uintptr_t)pThis->paEntries) / pThis->Core.pVol->cbSector; + ASMBitSet(pThis->u.Full.pbDirtySectors, idxSector); + } + else + pThis->u.Simple.fDirty = true; + return VINF_SUCCESS; +} + + +/** + * Gets the pointer to the given directory entry for the purpose of updating it. + * + * Call rtFsFatDirShrd_PutEntryAfterUpdate afterwards. + * + * @returns IPRT status code. + * @param pThis The directory. + * @param offEntryInDir The byte offset of the directory entry, within the + * directory. + * @param ppDirEntry Where to return the pointer to the directory entry. + * @param puWriteLock Where to return the write lock. + */ +static int rtFsFatDirShrd_GetEntryForUpdate(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, PFATDIRENTRY *ppDirEntry, + uint32_t *puWriteLock) +{ + uint32_t cEntriesIgn; + return rtFsFatDirShrd_GetEntriesAtCommon(pThis, offEntryInDir, true /*fForUpdate*/, (PFATDIRENTRYUNION *)ppDirEntry, + &cEntriesIgn, puWriteLock); +} + + +/** + * Release a directory buffer after done reading from it. + * + * This is currently just a placeholder. + * + * @param pThis The directory. + * @param uBufferReadLock The buffer lock. + */ +static void rtFsFatDirShrd_ReleaseBufferAfterReading(PRTFSFATDIRSHRD pThis, uint32_t uBufferReadLock) +{ + RT_NOREF(pThis, uBufferReadLock); + Assert(uBufferReadLock == 1); +} + + +/** + * Gets one or more entires at @a offEntryInDir. + * + * @returns IPRT status code. + * @param pThis The directory. + * @param offEntryInDir The directory offset in bytes. + * @param ppaEntries Where to return pointer to the entry at + * @a offEntryInDir. + * @param pcEntries Where to return the number of entries + * @a *ppaEntries points to. + * @param puBufferReadLock Where to return the buffer read lock handle. + * Call rtFsFatDirShrd_ReleaseBufferAfterReading when + * done. + */ +static int rtFsFatDirShrd_GetEntriesAt(PRTFSFATDIRSHRD pThis, uint32_t offEntryInDir, + PCFATDIRENTRYUNION *ppaEntries, uint32_t *pcEntries, uint32_t *puBufferReadLock) +{ + return rtFsFatDirShrd_GetEntriesAtCommon(pThis, offEntryInDir, false /*fForUpdate*/, (PFATDIRENTRYUNION *)ppaEntries, + pcEntries, puBufferReadLock); +} + + +/** + * Translates a unicode codepoint to an uppercased CP437 index. + * + * @returns CP437 index if valie, UINT16_MAX if not. + * @param uc The codepoint to convert. + */ +static uint16_t rtFsFatUnicodeCodepointToUpperCodepage(RTUNICP uc) +{ + /* + * The first 128 chars have 1:1 translation for valid FAT chars. + */ + if (uc < 128) + { + if (g_awchFatCp437ValidChars[uc] == uc) + return (uint16_t)uc; + if (RT_C_IS_LOWER(uc)) + return uc - 0x20; + return UINT16_MAX; + } + + /* + * Try for uppercased, settle for lower case if no upper case variant in the table. + * This is really expensive, btw. + */ + RTUNICP ucUpper = RTUniCpToUpper(uc); + for (unsigned i = 128; i < 256; i++) + if (g_awchFatCp437ValidChars[i] == ucUpper) + return i; + if (ucUpper != uc) + for (unsigned i = 128; i < 256; i++) + if (g_awchFatCp437ValidChars[i] == uc) + return i; + return UINT16_MAX; +} + + +/** + * Convert filename string to 8-dot-3 format, doing necessary ASCII uppercasing + * and such. + * + * @returns true if 8.3 formattable name, false if not. + * @param pszName8Dot3 Where to return the 8-dot-3 name when returning + * @c true. Filled with zero on false. 8+3+1 bytes. + * @param pszName The filename to convert. + */ +static bool rtFsFatDir_StringTo8Dot3(char *pszName8Dot3, const char *pszName) +{ + /* + * Don't try convert names with more than 12 unicode chars in them. + */ + size_t const cucName = RTStrUniLen(pszName); + if (cucName <= 12 && cucName > 0) + { + /* + * Recode the input string as CP437, uppercasing it, validating the + * name, formatting it as a FAT directory entry string. + */ + size_t offDst = 0; + bool fExt = false; + for (;;) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pszName, &uc); + if (RT_SUCCESS(rc)) + { + if (uc) + { + if (offDst < 8+3) + { + uint16_t idxCp = rtFsFatUnicodeCodepointToUpperCodepage(uc); + if (idxCp != UINT16_MAX) + { + pszName8Dot3[offDst++] = (char)idxCp; + Assert(uc != '.'); + continue; + } + + /* Maybe the dot? */ + if ( uc == '.' + && !fExt + && offDst <= 8) + { + fExt = true; + while (offDst < 8) + pszName8Dot3[offDst++] = ' '; + continue; + } + } + } + /* String terminator: Check length, pad and convert 0xe5. */ + else if (offDst <= (size_t)(fExt ? 8 + 3 : 8)) + { + while (offDst < 8 + 3) + pszName8Dot3[offDst++] = ' '; + Assert(offDst == 8 + 3); + pszName8Dot3[offDst] = '\0'; + + if ((uint8_t)pszName8Dot3[0] == FATDIRENTRY_CH0_DELETED) + pszName8Dot3[0] = FATDIRENTRY_CH0_ESC_E5; + return true; + } + } + /* invalid */ + break; + } + } + memset(&pszName8Dot3[0], 0, 8+3+1); + return false; +} + + +/** + * Calculates the checksum of a directory entry. + * @returns Checksum. + * @param pDirEntry The directory entry to checksum. + */ +static uint8_t rtFsFatDir_CalcChecksum(PCFATDIRENTRY pDirEntry) +{ + uint8_t bChecksum = pDirEntry->achName[0]; + for (uint8_t off = 1; off < RT_ELEMENTS(pDirEntry->achName); off++) + { + bChecksum = RTFSFAT_ROT_R1_U8(bChecksum); + bChecksum += pDirEntry->achName[off]; + } + return bChecksum; +} + + +/** + * Locates a directory entry in a directory. + * + * @returns IPRT status code. + * @retval VERR_FILE_NOT_FOUND if not found. + * @param pThis The directory to search. + * @param pszEntry The entry to look for. + * @param poffEntryInDir Where to return the offset of the directory + * entry. + * @param pfLong Where to return long name indicator. + * @param pDirEntry Where to return a copy of the directory entry. + */ +static int rtFsFatDirShrd_FindEntry(PRTFSFATDIRSHRD pThis, const char *pszEntry, uint32_t *poffEntryInDir, bool *pfLong, + PFATDIRENTRY pDirEntry) +{ + /* Set return values. */ + *pfLong = false; + *poffEntryInDir = UINT32_MAX; + + /* + * Turn pszEntry into a 8.3 filename, if possible. + */ + char szName8Dot3[8+3+1]; + bool fIs8Dot3Name = rtFsFatDir_StringTo8Dot3(szName8Dot3, pszEntry); + + /* + * Scan the directory buffer by buffer. + */ + RTUTF16 wszName[260+1]; + uint8_t bChecksum = UINT8_MAX; + uint8_t idNextSlot = UINT8_MAX; + size_t cwcName = 0; + uint32_t offEntryInDir = 0; + uint32_t const cbDir = pThis->Core.cbObject; + Assert(RT_ALIGN_32(cbDir, sizeof(*pDirEntry)) == cbDir); + AssertCompile(FATDIRNAMESLOT_MAX_SLOTS * FATDIRNAMESLOT_CHARS_PER_SLOT < RT_ELEMENTS(wszName)); + wszName[260] = '\0'; + + while (offEntryInDir < cbDir) + { + /* Get chunk of entries starting at offEntryInDir. */ + uint32_t uBufferLock = UINT32_MAX; + uint32_t cEntries = 0; + PCFATDIRENTRYUNION paEntries = NULL; + int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock); + if (RT_FAILURE(rc)) + return rc; + + /* + * Now work thru each of the entries. + */ + for (uint32_t iEntry = 0; iEntry < cEntries; iEntry++, offEntryInDir += sizeof(FATDIRENTRY)) + { + switch ((uint8_t)paEntries[iEntry].Entry.achName[0]) + { + default: + break; + case FATDIRENTRY_CH0_DELETED: + cwcName = 0; + continue; + case FATDIRENTRY_CH0_END_OF_DIR: + if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0) + { + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VERR_FILE_NOT_FOUND; + } + cwcName = 0; + break; /* Technically a valid entry before DOS 2.0, or so some claim. */ + } + + /* + * Check for long filename slot. + */ + if ( paEntries[iEntry].Slot.fAttrib == FAT_ATTR_NAME_SLOT + && paEntries[iEntry].Slot.idxZero == 0 + && paEntries[iEntry].Slot.fZero == 0 + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) <= FATDIRNAMESLOT_HIGHEST_SLOT_ID + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) != 0) + { + /* New slot? */ + if (paEntries[iEntry].Slot.idSlot & FATDIRNAMESLOT_FIRST_SLOT_FLAG) + { + idNextSlot = paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG; + bChecksum = paEntries[iEntry].Slot.bChecksum; + cwcName = idNextSlot * FATDIRNAMESLOT_CHARS_PER_SLOT; + wszName[cwcName] = '\0'; + } + /* Is valid next entry? */ + else if ( paEntries[iEntry].Slot.idSlot == idNextSlot + && paEntries[iEntry].Slot.bChecksum == bChecksum) + { /* likely */ } + else + cwcName = 0; + if (cwcName) + { + idNextSlot--; + size_t offName = idNextSlot * FATDIRNAMESLOT_CHARS_PER_SLOT; + memcpy(&wszName[offName], paEntries[iEntry].Slot.awcName0, sizeof(paEntries[iEntry].Slot.awcName0)); + memcpy(&wszName[offName + 5], paEntries[iEntry].Slot.awcName1, sizeof(paEntries[iEntry].Slot.awcName1)); + memcpy(&wszName[offName + 5 + 6], paEntries[iEntry].Slot.awcName2, sizeof(paEntries[iEntry].Slot.awcName2)); + } + } + /* + * Regular directory entry. Do the matching, first 8.3 then long name. + */ + else if ( fIs8Dot3Name + && !(paEntries[iEntry].Entry.fAttrib & FAT_ATTR_VOLUME) + && memcmp(paEntries[iEntry].Entry.achName, szName8Dot3, sizeof(paEntries[iEntry].Entry.achName)) == 0) + { + *poffEntryInDir = offEntryInDir; + *pDirEntry = paEntries[iEntry].Entry; + *pfLong = false; + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VINF_SUCCESS; + } + else if ( cwcName != 0 + && idNextSlot == 0 + && !(paEntries[iEntry].Entry.fAttrib & FAT_ATTR_VOLUME) + && rtFsFatDir_CalcChecksum(&paEntries[iEntry].Entry) == bChecksum + && RTUtf16ICmpUtf8(wszName, pszEntry) == 0) + { + *poffEntryInDir = offEntryInDir; + *pDirEntry = paEntries[iEntry].Entry; + *pfLong = true; + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VINF_SUCCESS; + } + else + cwcName = 0; + } + + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + } + + return VERR_FILE_NOT_FOUND; +} + + +/** + * Watered down version of rtFsFatDirShrd_FindEntry that is used by the short name + * generator to check for duplicates. + * + * @returns IPRT status code. + * @retval VERR_FILE_NOT_FOUND if not found. + * @retval VINF_SUCCESS if found. + * @param pThis The directory to search. + * @param pszEntry The entry to look for. + */ +static int rtFsFatDirShrd_FindEntryShort(PRTFSFATDIRSHRD pThis, const char *pszName8Dot3) +{ + Assert(strlen(pszName8Dot3) == 8+3); + + /* + * Scan the directory buffer by buffer. + */ + uint32_t offEntryInDir = 0; + uint32_t const cbDir = pThis->Core.cbObject; + Assert(RT_ALIGN_32(cbDir, sizeof(FATDIRENTRY)) == cbDir); + + while (offEntryInDir < cbDir) + { + /* Get chunk of entries starting at offEntryInDir. */ + uint32_t uBufferLock = UINT32_MAX; + uint32_t cEntries = 0; + PCFATDIRENTRYUNION paEntries = NULL; + int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock); + if (RT_FAILURE(rc)) + return rc; + + /* + * Now work thru each of the entries. + */ + for (uint32_t iEntry = 0; iEntry < cEntries; iEntry++, offEntryInDir += sizeof(FATDIRENTRY)) + { + switch ((uint8_t)paEntries[iEntry].Entry.achName[0]) + { + default: + break; + case FATDIRENTRY_CH0_DELETED: + continue; + case FATDIRENTRY_CH0_END_OF_DIR: + if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0) + { + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VERR_FILE_NOT_FOUND; + } + break; /* Technically a valid entry before DOS 2.0, or so some claim. */ + } + + /* + * Skip long filename slots. + */ + if ( paEntries[iEntry].Slot.fAttrib == FAT_ATTR_NAME_SLOT + && paEntries[iEntry].Slot.idxZero == 0 + && paEntries[iEntry].Slot.fZero == 0 + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) <= FATDIRNAMESLOT_HIGHEST_SLOT_ID + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) != 0) + { /* skipped */ } + /* + * Regular directory entry. Do the matching, first 8.3 then long name. + */ + else if (memcmp(paEntries[iEntry].Entry.achName, pszName8Dot3, sizeof(paEntries[iEntry].Entry.achName)) == 0) + { + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VINF_SUCCESS; + } + } + + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + } + + return VERR_FILE_NOT_FOUND; +} + + +/** + * Calculates the FATDIRENTRY::fCase flags for the given name. + * + * ASSUMES that the name is a 8.3 name. + * + * @returns Case flag mask. + * @param pszName The name. + */ +static uint8_t rtFsFatDir_CalcCaseFlags(const char *pszName) +{ + uint8_t bRet = FATDIRENTRY_CASE_F_LOWER_BASE | FATDIRENTRY_CASE_F_LOWER_EXT; + uint8_t bCurrent = FATDIRENTRY_CASE_F_LOWER_BASE; + for (;;) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pszName, &uc); + if (RT_SUCCESS(rc)) + { + if (uc != 0) + { + if (uc != '.') + { + if (RTUniCpIsUpper(uc)) + { + bRet &= ~bCurrent; + if (!bRet) + return 0; + } + } + else + bCurrent = FATDIRENTRY_CASE_F_LOWER_EXT; + } + else if (bCurrent == FATDIRENTRY_CASE_F_LOWER_BASE) + return bRet & ~FATDIRENTRY_CASE_F_LOWER_EXT; + else + return bRet; + } + else + return 0; + } +} + + +/** + * Checks if we need to generate a long name for @a pszEntry. + * + * @returns true if we need to, false if we don't. + * @param pszEntry The UTF-8 directory entry entry name. + * @param fIs8Dot3Name Whether we've managed to create a 8-dot-3 name. + * @param pDirEntry The directory entry with the 8-dot-3 name when + * fIs8Dot3Name is set. + */ +static bool rtFsFatDir_NeedLongName(const char *pszEntry, bool fIs8Dot3Name, PCFATDIRENTRY pDirEntry) +{ + /* + * Check the easy ways out first. + */ + + /* If we couldn't make a straight 8-dot-3 name out of it, the we + must do the long name thing. No question. */ + if (!fIs8Dot3Name) + return true; + + /* If both lower case flags are set, then the whole name must be + lowercased, so we won't need a long entry. */ + if (pDirEntry->fCase == (FATDIRENTRY_CASE_F_LOWER_BASE | FATDIRENTRY_CASE_F_LOWER_EXT)) + return false; + + /* + * Okay, check out the whole string then, part by part. (This is code + * similar to rtFsFatDir_CalcCaseFlags.) + */ + uint8_t fCurrent = pDirEntry->fCase & FATDIRENTRY_CASE_F_LOWER_BASE; + for (;;) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pszEntry, &uc); + if (RT_SUCCESS(rc)) + { + if (uc != 0) + { + if (uc != '.') + { + if ( fCurrent + || !RTUniCpIsLower(uc)) + { /* okay */ } + else + return true; + } + else + fCurrent = pDirEntry->fCase & FATDIRENTRY_CASE_F_LOWER_EXT; + } + /* It checked out to the end, so we don't need a long name. */ + else + return false; + } + else + return true; + } +} + + +/** + * Checks if the given long name is valid for a long file name or not. + * + * Encoding, length and character set limitations are checked. + * + * @returns IRPT status code. + * @param pwszEntry The long filename. + * @param cwc The length of the filename in UTF-16 chars. + */ +static int rtFsFatDir_ValidateLongName(PCRTUTF16 pwszEntry, size_t cwc) +{ + /* Length limitation. */ + if (cwc <= RTFSFAT_MAX_LFN_CHARS) + { + /* Character set limitations. */ + for (size_t off = 0; off < cwc; off++) + { + RTUTF16 wc = pwszEntry[off]; + if (wc < 128) + { + if (g_awchFatCp437ValidChars[wc] <= UINT16_C(0xfffe)) + { /* likely */ } + else + return VERR_INVALID_NAME; + } + } + + /* Name limitations. */ + if ( cwc == 1 + && pwszEntry[0] == '.') + return VERR_INVALID_NAME; + if ( cwc == 2 + && pwszEntry[0] == '.' + && pwszEntry[1] == '.') + return VERR_INVALID_NAME; + + /** @todo Check for more invalid names, also in the 8.3 case! */ + return VINF_SUCCESS; + } + return VERR_FILENAME_TOO_LONG; +} + + +/** + * Worker for rtFsFatDirShrd_GenerateShortName. + */ +static void rtFsFatDir_CopyShortName(char *pszDst, uint32_t cchDst, const char *pszSrc, size_t cchSrc, char chPad) +{ + /* Copy from source. */ + if (cchSrc > 0) + { + const char *pszSrcEnd = &pszSrc[cchSrc]; + while (cchDst > 0 && pszSrc != pszSrcEnd) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pszSrc, &uc); + if (RT_SUCCESS(rc)) + { + if (uc < 128) + { + if (g_awchFatCp437ValidChars[uc] != uc) + { + if (uc) + { + uc = RTUniCpToUpper(uc); + if (g_awchFatCp437ValidChars[uc] != uc) + uc = '_'; + } + else + break; + } + } + else + uc = '_'; + } + else + uc = '_'; + + *pszDst++ = (char)uc; + cchDst--; + } + } + + /* Pad the remaining space. */ + while (cchDst-- > 0) + *pszDst++ = chPad; +} + + +/** + * Generates a short filename. + * + * @returns IPRT status code. + * @param pThis The directory. + * @param pszEntry The long name (UTF-8). + * @param pDirEntry Where to put the short name. + */ +static int rtFsFatDirShrd_GenerateShortName(PRTFSFATDIRSHRD pThis, const char *pszEntry, PFATDIRENTRY pDirEntry) +{ + /* Do some input parsing. */ + const char *pszExt = RTPathSuffix(pszEntry); + size_t const cchBasename = pszExt ? pszExt - pszEntry : strlen(pszEntry); + size_t const cchExt = pszExt ? strlen(++pszExt) : 0; + + /* Fill in the extension first. It stays the same. */ + char szShortName[8+3+1]; + rtFsFatDir_CopyShortName(&szShortName[8], 3, pszExt, cchExt, ' '); + szShortName[8+3] = '\0'; + + /* + * First try single digit 1..9. + */ + rtFsFatDir_CopyShortName(szShortName, 6, pszEntry, cchBasename, '_'); + szShortName[6] = '~'; + for (uint32_t iLastDigit = 1; iLastDigit < 10; iLastDigit++) + { + szShortName[7] = iLastDigit + '0'; + int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName); + if (rc == VERR_FILE_NOT_FOUND) + { + memcpy(pDirEntry->achName, szShortName, sizeof(pDirEntry->achName)); + return VINF_SUCCESS; + } + if (RT_FAILURE(rc)) + return rc; + } + + /* + * First try two digits 10..99. + */ + szShortName[5] = '~'; + for (uint32_t iFirstDigit = 1; iFirstDigit < 10; iFirstDigit++) + for (uint32_t iLastDigit = 0; iLastDigit < 10; iLastDigit++) + { + szShortName[6] = iFirstDigit + '0'; + szShortName[7] = iLastDigit + '0'; + int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName); + if (rc == VERR_FILE_NOT_FOUND) + { + memcpy(pDirEntry->achName, szShortName, sizeof(pDirEntry->achName)); + return VINF_SUCCESS; + } + if (RT_FAILURE(rc)) + return rc; + } + + /* + * Okay, do random numbers then. + */ + szShortName[2] = '~'; + for (uint32_t i = 0; i < 8192; i++) + { + char szHex[68]; + ssize_t cchHex = RTStrFormatU32(szHex, sizeof(szHex), RTRandU32(), 16, 5, 0, RTSTR_F_CAPITAL | RTSTR_F_WIDTH | RTSTR_F_ZEROPAD); + AssertReturn(cchHex >= 5, VERR_NET_NOT_UNIQUE_NAME); + szShortName[7] = szHex[cchHex - 1]; + szShortName[6] = szHex[cchHex - 2]; + szShortName[5] = szHex[cchHex - 3]; + szShortName[4] = szHex[cchHex - 4]; + szShortName[3] = szHex[cchHex - 5]; + int rc = rtFsFatDirShrd_FindEntryShort(pThis, szShortName); + if (rc == VERR_FILE_NOT_FOUND) + { + memcpy(pDirEntry->achName, szShortName, sizeof(pDirEntry->achName)); + return VINF_SUCCESS; + } + if (RT_FAILURE(rc)) + return rc; + } + + return VERR_NET_NOT_UNIQUE_NAME; +} + + +/** + * Considers whether we need to create a long name or not. + * + * If a long name is needed and the name wasn't 8-dot-3 compatible, a 8-dot-3 + * name will be generated and stored in *pDirEntry. + * + * @returns IPRT status code + * @param pThis The directory. + * @param pszEntry The name. + * @param fIs8Dot3Name Whether we have a 8-dot-3 name already. + * @param pDirEntry Where to return the generated 8-dot-3 name. + * @param paSlots Where to return the long name entries. The array + * can hold at least FATDIRNAMESLOT_MAX_SLOTS entries. + * @param pcSlots Where to return the actual number of slots used. + */ +static int rtFsFatDirShrd_MaybeCreateLongNameAndShortAlias(PRTFSFATDIRSHRD pThis, const char *pszEntry, bool fIs8Dot3Name, + PFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t *pcSlots) +{ + RT_NOREF(pThis, pDirEntry, paSlots, pszEntry); + + /* + * If we don't need to create a long name, return immediately. + */ + if (!rtFsFatDir_NeedLongName(pszEntry, fIs8Dot3Name, pDirEntry)) + { + *pcSlots = 0; + return VINF_SUCCESS; + } + + /* + * Convert the name to UTF-16 and figure it's length (this validates the + * input encoding). Then do long name validation (length, charset limitation). + */ + RTUTF16 wszEntry[FATDIRNAMESLOT_MAX_SLOTS * FATDIRNAMESLOT_CHARS_PER_SLOT + 4]; + PRTUTF16 pwszEntry = wszEntry; + size_t cwcEntry; + int rc = RTStrToUtf16Ex(pszEntry, RTSTR_MAX, &pwszEntry, RT_ELEMENTS(wszEntry), &cwcEntry); + if (RT_SUCCESS(rc)) + rc = rtFsFatDir_ValidateLongName(pwszEntry, cwcEntry); + if (RT_SUCCESS(rc)) + { + /* + * Generate a short name if we need to. + */ + if (!fIs8Dot3Name) + rc = rtFsFatDirShrd_GenerateShortName(pThis, pszEntry, pDirEntry); + if (RT_SUCCESS(rc)) + { + /* + * Fill in the long name slots. First we pad the wszEntry with 0xffff + * until it is a multiple of of the slot count. That way we can copy + * the name straight into the entry without constaints. + */ + memset(&wszEntry[cwcEntry + 1], 0xff, + RT_MIN(sizeof(wszEntry) - (cwcEntry + 1) * sizeof(RTUTF16), + FATDIRNAMESLOT_CHARS_PER_SLOT * sizeof(RTUTF16))); + + uint8_t const bChecksum = rtFsFatDir_CalcChecksum(pDirEntry); + size_t const cSlots = (cwcEntry + FATDIRNAMESLOT_CHARS_PER_SLOT - 1) / FATDIRNAMESLOT_CHARS_PER_SLOT; + size_t iSlot = cSlots; + PCRTUTF16 pwszSrc = wszEntry; + while (iSlot-- > 0) + { + memcpy(paSlots[iSlot].awcName0, pwszSrc, sizeof(paSlots[iSlot].awcName0)); + pwszSrc += RT_ELEMENTS(paSlots[iSlot].awcName0); + memcpy(paSlots[iSlot].awcName1, pwszSrc, sizeof(paSlots[iSlot].awcName1)); + pwszSrc += RT_ELEMENTS(paSlots[iSlot].awcName1); + memcpy(paSlots[iSlot].awcName2, pwszSrc, sizeof(paSlots[iSlot].awcName2)); + pwszSrc += RT_ELEMENTS(paSlots[iSlot].awcName2); + + paSlots[iSlot].idSlot = (uint8_t)(cSlots - iSlot); + paSlots[iSlot].fAttrib = FAT_ATTR_NAME_SLOT; + paSlots[iSlot].fZero = 0; + paSlots[iSlot].idxZero = 0; + paSlots[iSlot].bChecksum = bChecksum; + } + paSlots[0].idSlot |= FATDIRNAMESLOT_FIRST_SLOT_FLAG; + *pcSlots = (uint32_t)cSlots; + return VINF_SUCCESS; + } + } + *pcSlots = UINT32_MAX; + return rc; +} + + +/** + * Searches the directory for a given number of free directory entries. + * + * The free entries must be consecutive of course. + * + * @returns IPRT status code. + * @retval VERR_DISK_FULL if no space was found, *pcFreeTail set. + * @param pThis The directory to search. + * @param cEntriesNeeded How many entries we need. + * @param poffEntryInDir Where to return the offset of the first entry we + * found. + * @param pcFreeTail Where to return the number of free entries at the + * end of the directory when VERR_DISK_FULL is + * returned. + */ +static int rtFsFatChain_FindFreeEntries(PRTFSFATDIRSHRD pThis, uint32_t cEntriesNeeded, + uint32_t *poffEntryInDir, uint32_t *pcFreeTail) +{ + /* First try make gcc happy. */ + *pcFreeTail = 0; + *poffEntryInDir = UINT32_MAX; + + /* + * Scan the whole directory, buffer by buffer. + */ + uint32_t offStartFreeEntries = UINT32_MAX; + uint32_t cFreeEntries = 0; + uint32_t offEntryInDir = 0; + uint32_t const cbDir = pThis->Core.cbObject; + Assert(RT_ALIGN_32(cbDir, sizeof(FATDIRENTRY)) == cbDir); + while (offEntryInDir < cbDir) + { + /* Get chunk of entries starting at offEntryInDir. */ + uint32_t uBufferLock = UINT32_MAX; + uint32_t cEntries = 0; + PCFATDIRENTRYUNION paEntries = NULL; + int rc = rtFsFatDirShrd_GetEntriesAt(pThis, offEntryInDir, &paEntries, &cEntries, &uBufferLock); + if (RT_FAILURE(rc)) + return rc; + + /* + * Now work thru each of the entries. + */ + for (uint32_t iEntry = 0; iEntry < cEntries; iEntry++, offEntryInDir += sizeof(FATDIRENTRY)) + { + uint8_t const bFirst = paEntries[iEntry].Entry.achName[0]; + if ( bFirst == FATDIRENTRY_CH0_DELETED + || bFirst == FATDIRENTRY_CH0_END_OF_DIR) + { + if (offStartFreeEntries != UINT32_MAX) + cFreeEntries++; + else + { + offStartFreeEntries = offEntryInDir; + cFreeEntries = 1; + } + if (cFreeEntries >= cEntriesNeeded) + { + *pcFreeTail = cEntriesNeeded; + *poffEntryInDir = offStartFreeEntries; + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VINF_SUCCESS; + } + + if (bFirst == FATDIRENTRY_CH0_END_OF_DIR) + { + if (pThis->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0) + { + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + *pcFreeTail = cFreeEntries = (cbDir - offStartFreeEntries) / sizeof(FATDIRENTRY); + if (cFreeEntries >= cEntriesNeeded) + { + *poffEntryInDir = offStartFreeEntries; + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + return VINF_SUCCESS; + } + return VERR_DISK_FULL; + } + } + } + else if (offStartFreeEntries != UINT32_MAX) + { + offStartFreeEntries = UINT32_MAX; + cFreeEntries = 0; + } + } + rtFsFatDirShrd_ReleaseBufferAfterReading(pThis, uBufferLock); + } + *pcFreeTail = cFreeEntries; + return VERR_DISK_FULL; +} + + +/** + * Try grow the directory. + * + * This is not called on the root directory. + * + * @returns IPRT status code. + * @retval VERR_DISK_FULL if we failed to allocated new space. + * @param pThis The directory to grow. + * @param cMinNewEntries The minimum number of new entries to allocated. + */ +static int rtFsFatChain_GrowDirectory(PRTFSFATDIRSHRD pThis, uint32_t cMinNewEntries) +{ + RT_NOREF(pThis, cMinNewEntries); + return VERR_DISK_FULL; +} + + +/** + * Inserts a directory with zero of more long name slots preceeding it. + * + * @returns IPRT status code. + * @param pThis The directory. + * @param pDirEntry The directory entry. + * @param paSlots The long name slots. + * @param cSlots The number of long name slots. + * @param poffEntryInDir Where to return the directory offset. + */ +static int rtFsFatChain_InsertEntries(PRTFSFATDIRSHRD pThis, PCFATDIRENTRY pDirEntry, PFATDIRNAMESLOT paSlots, uint32_t cSlots, + uint32_t *poffEntryInDir) +{ + uint32_t const cTotalEntries = cSlots + 1; + + /* + * Find somewhere to put the entries. Try extend the directory if we're + * not successful at first. + */ + uint32_t cFreeTailEntries; + uint32_t offFirstInDir; + int rc = rtFsFatChain_FindFreeEntries(pThis, cTotalEntries, &offFirstInDir, &cFreeTailEntries); + if (rc == VERR_DISK_FULL) + { + Assert(cFreeTailEntries < cTotalEntries); + + /* Try grow it and use the newly allocated space. */ + if ( pThis->Core.pParentDir + && pThis->cEntries < _64K /* Don't grow beyond 64K entries */) + { + offFirstInDir = pThis->Core.cbObject - cFreeTailEntries * sizeof(FATDIRENTRY); + rc = rtFsFatChain_GrowDirectory(pThis, cTotalEntries - cFreeTailEntries); + } + + if (rc == VERR_DISK_FULL) + { + /** @todo Try compact the directory if we couldn't grow it. */ + } + } + if (RT_SUCCESS(rc)) + { + /* + * Update the directory. + */ + uint32_t offCurrent = offFirstInDir; + for (uint32_t iSrcSlot = 0; iSrcSlot < cTotalEntries; iSrcSlot++, offCurrent += sizeof(FATDIRENTRY)) + { + uint32_t uBufferLock; + PFATDIRENTRY pDstEntry; + rc = rtFsFatDirShrd_GetEntryForUpdate(pThis, offCurrent, &pDstEntry, &uBufferLock); + if (RT_SUCCESS(rc)) + { + if (iSrcSlot < cSlots) + memcpy(pDstEntry, &paSlots[iSrcSlot], sizeof(*pDstEntry)); + else + memcpy(pDstEntry, pDirEntry, sizeof(*pDstEntry)); + rc = rtFsFatDirShrd_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock); + if (RT_SUCCESS(rc)) + continue; + + /* + * Bail out: Try mark any edited entries as deleted. + */ + iSrcSlot++; + } + while (iSrcSlot-- > 0) + { + int rc2 = rtFsFatDirShrd_GetEntryForUpdate(pThis, offFirstInDir + iSrcSlot * sizeof(FATDIRENTRY), + &pDstEntry, &uBufferLock); + if (RT_SUCCESS(rc2)) + { + pDstEntry->achName[0] = FATDIRENTRY_CH0_DELETED; + rtFsFatDirShrd_PutEntryAfterUpdate(pThis, pDstEntry, uBufferLock); + } + } + *poffEntryInDir = UINT32_MAX; + return rc; + } + AssertRC(rc); + + /* + * Successfully inserted all. + */ + *poffEntryInDir = offFirstInDir + cSlots * sizeof(FATDIRENTRY); + return VINF_SUCCESS; + } + + *poffEntryInDir = UINT32_MAX; + return rc; +} + + + +/** + * Creates a new directory entry. + * + * @returns IPRT status code + * @param pThis The directory. + * @param pszEntry The name of the new entry. + * @param fAttrib The attributes. + * @param cbInitial The initialize size. + * @param poffEntryInDir Where to return the offset of the directory entry. + * @param pDirEntry Where to return a copy of the directory entry. + * + * @remarks ASSUMES caller has already called rtFsFatDirShrd_FindEntry to make sure + * the entry doesn't exist. + */ +static int rtFsFatDirShrd_CreateEntry(PRTFSFATDIRSHRD pThis, const char *pszEntry, uint8_t fAttrib, uint32_t cbInitial, + uint32_t *poffEntryInDir, PFATDIRENTRY pDirEntry) +{ + PRTFSFATVOL pVol = pThis->Core.pVol; + *poffEntryInDir = UINT32_MAX; + if (pVol->fReadOnly) + return VERR_WRITE_PROTECT; + + /* + * Create the directory entries on the stack. + */ + bool fIs8Dot3Name = rtFsFatDir_StringTo8Dot3((char *)pDirEntry->achName, pszEntry); + pDirEntry->fAttrib = fAttrib; + pDirEntry->fCase = fIs8Dot3Name ? rtFsFatDir_CalcCaseFlags(pszEntry) : 0; + pDirEntry->uBirthCentiseconds = rtFsFatCurrentFatDateTime(pVol, &pDirEntry->uBirthDate, &pDirEntry->uBirthTime); + pDirEntry->uAccessDate = pDirEntry->uBirthDate; + pDirEntry->uModifyDate = pDirEntry->uBirthDate; + pDirEntry->uModifyTime = pDirEntry->uBirthTime; + pDirEntry->idxCluster = 0; /* Will fill this in later if cbInitial is non-zero. */ + pDirEntry->u.idxClusterHigh = 0; + pDirEntry->cbFile = cbInitial; + + /* + * Create long filename slots if necessary. + */ + uint32_t cSlots = UINT32_MAX; + FATDIRNAMESLOT aSlots[FATDIRNAMESLOT_MAX_SLOTS]; + AssertCompile(RTFSFAT_MAX_LFN_CHARS < RT_ELEMENTS(aSlots) * FATDIRNAMESLOT_CHARS_PER_SLOT); + int rc = rtFsFatDirShrd_MaybeCreateLongNameAndShortAlias(pThis, pszEntry, fIs8Dot3Name, pDirEntry, aSlots, &cSlots); + if (RT_SUCCESS(rc)) + { + Assert(cSlots <= FATDIRNAMESLOT_MAX_SLOTS); + + /* + * Allocate initial clusters if requested. + */ + RTFSFATCHAIN Clusters; + rtFsFatChain_InitEmpty(&Clusters, pVol); + if (cbInitial > 0) + { + rc = rtFsFatClusterMap_AllocateMoreClusters(pVol, &Clusters, + (cbInitial + Clusters.cbCluster - 1) >> Clusters.cClusterByteShift); + if (RT_SUCCESS(rc)) + { + uint32_t idxFirstCluster = rtFsFatChain_GetFirstCluster(&Clusters); + pDirEntry->idxCluster = (uint16_t)idxFirstCluster; + if (pVol->enmFatType >= RTFSFATTYPE_FAT32) + pDirEntry->u.idxClusterHigh = (uint16_t)(idxFirstCluster >> 16); + } + } + if (RT_SUCCESS(rc)) + { + /* + * Insert the directory entry and name slots. + */ + rc = rtFsFatChain_InsertEntries(pThis, pDirEntry, aSlots, cSlots, poffEntryInDir); + if (RT_SUCCESS(rc)) + { + rtFsFatChain_Delete(&Clusters); + return VINF_SUCCESS; + } + + for (uint32_t iClusterToFree = 0; iClusterToFree < Clusters.cClusters; iClusterToFree++) + rtFsFatClusterMap_FreeCluster(pVol, rtFsFatChain_GetClusterByIndex(&Clusters, iClusterToFree)); + rtFsFatChain_Delete(&Clusters); + } + } + return rc; +} + + +/** + * Releases a reference to a shared directory structure. + * + * @param pShared The shared directory structure. + */ +static int rtFsFatDirShrd_Release(PRTFSFATDIRSHRD pShared) +{ + uint32_t cRefs = ASMAtomicDecU32(&pShared->Core.cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (cRefs == 0) + { + LogFlow(("rtFsFatDirShrd_Release: Destroying shared structure %p\n", pShared)); + Assert(pShared->Core.cRefs == 0); + + int rc; + if (pShared->paEntries) + { + rc = rtFsFatDirShrd_Flush(pShared); + RTMemFree(pShared->paEntries); + pShared->paEntries = NULL; + } + else + rc = VINF_SUCCESS; + + if ( pShared->fFullyBuffered + && pShared->u.Full.pbDirtySectors) + { + RTMemFree(pShared->u.Full.pbDirtySectors); + pShared->u.Full.pbDirtySectors = NULL; + } + + int rc2 = rtFsFatObj_Close(&pShared->Core); + if (RT_SUCCESS(rc)) + rc = rc2; + + RTMemFree(pShared); + return rc; + } + return VINF_SUCCESS; +} + + +/** + * Retains a reference to a shared directory structure. + * + * @param pShared The shared directory structure. + */ +static void rtFsFatDirShrd_Retain(PRTFSFATDIRSHRD pShared) +{ + uint32_t cRefs = ASMAtomicIncU32(&pShared->Core.cRefs); + Assert(cRefs > 1); NOREF(cRefs); +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsFatDir_Close(void *pvThis) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + PRTFSFATDIRSHRD pShared = pThis->pShared; + pThis->pShared = NULL; + if (pShared) + return rtFsFatDirShrd_Release(pShared); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsFatDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + return rtFsFatObj_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsFatDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + return rtFsFatObj_SetMode(&pThis->pShared->Core, fMode, fMask); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsFatDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + return rtFsFatObj_SetTimes(&pThis->pShared->Core, pAccessTime, pModificationTime, pChangeTime, pBirthTime); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsFatDir_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + RT_NOREF(pvThis, uid, gid); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpen} + */ +static DECLCALLBACK(int) rtFsFatDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen, + uint32_t fFlags, PRTVFSOBJ phVfsObj) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + PRTFSFATDIRSHRD pShared = pThis->pShared; + int rc; + + /* + * Special cases '.' and '.' + */ + if (pszEntry[0] == '.') + { + PRTFSFATDIRSHRD pSharedToOpen; + if (pszEntry[1] == '\0') + pSharedToOpen = pShared; + else if (pszEntry[1] == '.' && pszEntry[2] == '\0') + { + pSharedToOpen = pShared->Core.pParentDir; + if (!pSharedToOpen) + pSharedToOpen = pShared; + } + else + pSharedToOpen = NULL; + if (pSharedToOpen) + { + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { + rtFsFatDirShrd_Retain(pSharedToOpen); + RTVFSDIR hVfsDir; + rc = rtFsFatDir_NewWithShared(pShared->Core.pVol, pSharedToOpen, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_ACCESS_DENIED; + } + else + rc = VERR_IS_A_DIRECTORY; + return rc; + } + } + + /* + * Try open existing file. + */ + uint32_t offEntryInDir; + bool fLong; + FATDIRENTRY DirEntry; + rc = rtFsFatDirShrd_FindEntry(pShared, pszEntry, &offEntryInDir, &fLong, &DirEntry); + if (RT_SUCCESS(rc)) + { + switch (DirEntry.fAttrib & (FAT_ATTR_DIRECTORY | FAT_ATTR_VOLUME)) + { + case 0: + if (fFlags & RTVFSOBJ_F_OPEN_FILE) + { + if ( !(DirEntry.fAttrib & FAT_ATTR_READONLY) + || !(fOpen & RTFILE_O_WRITE)) + { + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE) + { + RTVFSFILE hVfsFile; + rc = rtFsFatFile_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, fOpen, &hVfsFile); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_ALREADY_EXISTS; + } + else + rc = VERR_ACCESS_DENIED; + } + else + rc = VERR_IS_A_FILE; + break; + + case FAT_ATTR_DIRECTORY: + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + if ( !(DirEntry.fAttrib & FAT_ATTR_READONLY) + || !(fOpen & RTFILE_O_WRITE)) + { + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { + RTVFSDIR hVfsDir; + rc = rtFsFatDir_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, + RTFSFAT_GET_CLUSTER(&DirEntry, pShared->Core.pVol), UINT64_MAX /*offDisk*/, + DirEntry.cbFile, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else if ((fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE) + rc = VERR_INVALID_FUNCTION; + else + rc = VERR_ALREADY_EXISTS; + } + else + rc = VERR_ACCESS_DENIED; + } + else + rc = VERR_IS_A_DIRECTORY; + break; + + default: + rc = VERR_PATH_NOT_FOUND; + break; + } + } + /* + * Create a file or directory? + */ + else if (rc == VERR_FILE_NOT_FOUND) + { + if ( ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_CREATE_REPLACE) + && (fFlags & RTVFSOBJ_F_CREATE_MASK) != RTVFSOBJ_F_CREATE_NOTHING) + { + if ((fFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_FILE) + { + rc = rtFsFatDirShrd_CreateEntry(pShared, pszEntry, FAT_ATTR_ARCHIVE, 0 /*cbInitial*/, &offEntryInDir, &DirEntry); + if (RT_SUCCESS(rc)) + { + RTVFSFILE hVfsFile; + rc = rtFsFatFile_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, fOpen, &hVfsFile); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + } + else if ((fFlags & RTVFSOBJ_F_CREATE_MASK) == RTVFSOBJ_F_CREATE_DIRECTORY) + { + rc = rtFsFatDirShrd_CreateEntry(pShared, pszEntry, FAT_ATTR_ARCHIVE | FAT_ATTR_DIRECTORY, + pShared->Core.pVol->cbCluster, &offEntryInDir, &DirEntry); + if (RT_SUCCESS(rc)) + { + RTVFSDIR hVfsDir; + rc = rtFsFatDir_New(pShared->Core.pVol, pShared, &DirEntry, offEntryInDir, + RTFSFAT_GET_CLUSTER(&DirEntry, pShared->Core.pVol), UINT64_MAX /*offDisk*/, + DirEntry.cbFile, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + } + else + rc = VERR_VFS_UNSUPPORTED_CREATE_TYPE; + } + } + + return rc; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink} + */ +static DECLCALLBACK(int) rtFsFatDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, phVfsSymlink); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink} + */ +static DECLCALLBACK(int) rtFsFatDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget, + RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry} + */ +static DECLCALLBACK(int) rtFsFatDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType) +{ + RT_NOREF(pvThis, pszEntry, fType); + return VERR_NOT_IMPLEMENTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry} + */ +static DECLCALLBACK(int) rtFsFatDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName) +{ + RT_NOREF(pvThis, pszEntry, fType, pszNewName); + return VERR_NOT_IMPLEMENTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRewindDir} + */ +static DECLCALLBACK(int) rtFsFatDir_RewindDir(void *pvThis) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + pThis->offDir = 0; + return VINF_SUCCESS; +} + + +/** + * Calculates the UTF-8 length of the name in the given directory entry. + * + * @returns The length in characters (bytes), excluding terminator. + * @param pShared The shared directory structure (for codepage). + * @param pEntry The directory entry. + */ +static size_t rtFsFatDir_CalcUtf8LengthForDirEntry(PRTFSFATDIRSHRD pShared, PCFATDIRENTRY pEntry) +{ + RT_NOREF(pShared); + PCRTUTF16 g_pawcMap = &g_awchFatCp437Chars[0]; + + /* The base name (this won't work with DBCS, but that's not a concern at the moment). */ + size_t offSrc = 8; + while (offSrc > 1 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[offSrc - 1]])) + offSrc--; + + size_t cchRet = 0; + while (offSrc-- > 0) + cchRet += RTStrCpSize(g_pawcMap[pEntry->achName[offSrc]]); + + /* Extension. */ + offSrc = 11; + while (offSrc > 8 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[offSrc - 1]])) + offSrc--; + if (offSrc > 8) + { + cchRet += 1; /* '.' */ + while (offSrc-- > 8) + cchRet += RTStrCpSize(g_pawcMap[pEntry->achName[offSrc]]); + } + + return cchRet; +} + + +/** + * Copies the name from the directory entry into a UTF-16 buffer. + * + * @returns Number of UTF-16 items written (excluding terminator). + * @param pShared The shared directory structure (for codepage). + * @param pEntry The directory entry. + * @param pwszDst The destination buffer. + * @param cwcDst The destination buffer size. + */ +static uint16_t rtFsFatDir_CopyDirEntryToUtf16(PRTFSFATDIRSHRD pShared, PCFATDIRENTRY pEntry, PRTUTF16 pwszDst, size_t cwcDst) +{ + Assert(cwcDst > 0); + + RT_NOREF(pShared); + PCRTUTF16 g_pawcMap = &g_awchFatCp437Chars[0]; + + /* The base name (this won't work with DBCS, but that's not a concern at the moment). */ + size_t cchSrc = 8; + while (cchSrc > 1 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[cchSrc - 1]])) + cchSrc--; + + size_t offDst = 0; + for (size_t offSrc = 0; offSrc < cchSrc; offSrc++) + { + AssertReturnStmt(offDst + 1 < cwcDst, pwszDst[cwcDst - 1] = '\0', (uint16_t)cwcDst); + pwszDst[offDst++] = g_pawcMap[pEntry->achName[offSrc]]; + } + + /* Extension. */ + cchSrc = 3; + while (cchSrc > 0 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[8 + cchSrc - 1]])) + cchSrc--; + if (cchSrc > 0) + { + AssertReturnStmt(offDst + 1 < cwcDst, pwszDst[cwcDst - 1] = '\0', (uint16_t)cwcDst); + pwszDst[offDst++] = '.'; + + for (size_t offSrc = 0; offSrc < cchSrc; offSrc++) + { + AssertReturnStmt(offDst + 1 < cwcDst, pwszDst[cwcDst - 1] = '\0', (uint16_t)cwcDst); + pwszDst[offDst++] = g_pawcMap[pEntry->achName[8 + offSrc]]; + } + } + + pwszDst[offDst] = '\0'; + return (uint16_t)offDst; +} + + +/** + * Copies the name from the directory entry into a UTF-8 buffer. + * + * @returns Number of UTF-16 items written (excluding terminator). + * @param pShared The shared directory structure (for codepage). + * @param pEntry The directory entry. + * @param pszDst The destination buffer. + * @param cbDst The destination buffer size. + */ +static uint16_t rtFsFatDir_CopyDirEntryToUtf8(PRTFSFATDIRSHRD pShared, PCFATDIRENTRY pEntry, char *pszDst, size_t cbDst) +{ + Assert(cbDst > 0); + + RT_NOREF(pShared); + PCRTUTF16 g_pawcMap = &g_awchFatCp437Chars[0]; + + /* The base name (this won't work with DBCS, but that's not a concern at the moment). */ + size_t cchSrc = 8; + while (cchSrc > 1 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[cchSrc - 1]])) + cchSrc--; + + char * const pszDstEnd = pszDst + cbDst; + char *pszCurDst = pszDst; + for (size_t offSrc = 0; offSrc < cchSrc; offSrc++) + { + RTUNICP const uc = g_pawcMap[pEntry->achName[offSrc]]; + size_t cbCp = RTStrCpSize(uc); + AssertReturnStmt(cbCp < (size_t)(pszDstEnd - pszCurDst), *pszCurDst = '\0', (uint16_t)(pszDstEnd - pszCurDst)); + pszCurDst = RTStrPutCp(pszCurDst, uc); + } + + /* Extension. */ + cchSrc = 3; + while (cchSrc > 0 && RTUniCpIsSpace(g_pawcMap[pEntry->achName[8 + cchSrc - 1]])) + cchSrc--; + if (cchSrc > 0) + { + AssertReturnStmt(1U < (size_t)(pszDstEnd - pszCurDst), *pszCurDst = '\0', (uint16_t)(pszDstEnd - pszCurDst)); + *pszCurDst++ = '.'; + + for (size_t offSrc = 0; offSrc < cchSrc; offSrc++) + { + RTUNICP const uc = g_pawcMap[pEntry->achName[8 + offSrc]]; + size_t cbCp = RTStrCpSize(uc); + AssertReturnStmt(cbCp < (size_t)(pszDstEnd - pszCurDst), *pszCurDst = '\0', (uint16_t)(pszDstEnd - pszCurDst)); + pszCurDst = RTStrPutCp(pszCurDst, uc); + } + } + + *pszCurDst = '\0'; + return (uint16_t)(pszDstEnd - pszCurDst); +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnReadDir} + */ +static DECLCALLBACK(int) rtFsFatDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + PRTFSFATDIR pThis = (PRTFSFATDIR)pvThis; + PRTFSFATDIRSHRD pShared = pThis->pShared; + + /* + * Fake '.' and '..' entries (required for root, we do it everywhere). + */ + if (pThis->offDir < 2) + { + size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[pThis->offDir + 2]); + if (cbNeeded < *pcbDirEntry) + *pcbDirEntry = cbNeeded; + else + { + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + + int rc; + if ( pThis->offDir == 0 + || pShared->Core.pParentDir == NULL) + rc = rtFsFatObj_QueryInfo(&pShared->Core, &pDirEntry->Info, enmAddAttr); + else + rc = rtFsFatObj_QueryInfo(&pShared->Core.pParentDir->Core, &pDirEntry->Info, enmAddAttr); + + pDirEntry->cwcShortName = 0; + pDirEntry->wszShortName[0] = '\0'; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[1] = '.'; + pDirEntry->szName[++pThis->offDir] = '\0'; + pDirEntry->cbName = pThis->offDir; + return rc; + } + if ( pThis->offDir == 2 + && pShared->cEntries >= 2) + { + /* Skip '.' and '..' entries if present. */ + uint32_t uBufferLock = UINT32_MAX; + uint32_t cEntries = 0; + PCFATDIRENTRYUNION paEntries = NULL; + int rc = rtFsFatDirShrd_GetEntriesAt(pShared, 0, &paEntries, &cEntries, &uBufferLock); + if (RT_FAILURE(rc)) + return rc; + if ( (paEntries[0].Entry.fAttrib & FAT_ATTR_DIRECTORY) + && memcmp(paEntries[0].Entry.achName, RT_STR_TUPLE(". ")) == 0) + { + if ( (paEntries[1].Entry.fAttrib & FAT_ATTR_DIRECTORY) + && memcmp(paEntries[1].Entry.achName, RT_STR_TUPLE(".. ")) == 0) + pThis->offDir += sizeof(paEntries[0]) * 2; + else + pThis->offDir += sizeof(paEntries[0]); + } + rtFsFatDirShrd_ReleaseBufferAfterReading(pShared, uBufferLock); + } + + /* + * Scan the directory buffer by buffer. + */ + RTUTF16 wszName[260+1]; + uint8_t bChecksum = UINT8_MAX; + uint8_t idNextSlot = UINT8_MAX; + size_t cwcName = 0; + uint32_t offEntryInDir = pThis->offDir - 2; + uint32_t const cbDir = pShared->Core.cbObject; + Assert(RT_ALIGN_32(cbDir, sizeof(*pDirEntry)) == cbDir); + AssertCompile(FATDIRNAMESLOT_MAX_SLOTS * FATDIRNAMESLOT_CHARS_PER_SLOT < RT_ELEMENTS(wszName)); + wszName[260] = '\0'; + + while (offEntryInDir < cbDir) + { + /* Get chunk of entries starting at offEntryInDir. */ + uint32_t uBufferLock = UINT32_MAX; + uint32_t cEntries = 0; + PCFATDIRENTRYUNION paEntries = NULL; + int rc = rtFsFatDirShrd_GetEntriesAt(pShared, offEntryInDir, &paEntries, &cEntries, &uBufferLock); + if (RT_FAILURE(rc)) + return rc; + + /* + * Now work thru each of the entries. + */ + for (uint32_t iEntry = 0; iEntry < cEntries; iEntry++, offEntryInDir += sizeof(FATDIRENTRY)) + { + switch ((uint8_t)paEntries[iEntry].Entry.achName[0]) + { + default: + break; + case FATDIRENTRY_CH0_DELETED: + cwcName = 0; + continue; + case FATDIRENTRY_CH0_END_OF_DIR: + if (pShared->Core.pVol->enmBpbVersion >= RTFSFATBPBVER_DOS_2_0) + { + pThis->offDir = cbDir + 2; + rtFsFatDirShrd_ReleaseBufferAfterReading(pShared, uBufferLock); + return VERR_NO_MORE_FILES; + } + cwcName = 0; + break; /* Technically a valid entry before DOS 2.0, or so some claim. */ + } + + /* + * Check for long filename slot. + */ + if ( paEntries[iEntry].Slot.fAttrib == FAT_ATTR_NAME_SLOT + && paEntries[iEntry].Slot.idxZero == 0 + && paEntries[iEntry].Slot.fZero == 0 + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) <= FATDIRNAMESLOT_HIGHEST_SLOT_ID + && (paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG) != 0) + { + /* New slot? */ + if (paEntries[iEntry].Slot.idSlot & FATDIRNAMESLOT_FIRST_SLOT_FLAG) + { + idNextSlot = paEntries[iEntry].Slot.idSlot & ~FATDIRNAMESLOT_FIRST_SLOT_FLAG; + bChecksum = paEntries[iEntry].Slot.bChecksum; + cwcName = idNextSlot * FATDIRNAMESLOT_CHARS_PER_SLOT; + wszName[cwcName] = '\0'; + } + /* Is valid next entry? */ + else if ( paEntries[iEntry].Slot.idSlot == idNextSlot + && paEntries[iEntry].Slot.bChecksum == bChecksum) + { /* likely */ } + else + cwcName = 0; + if (cwcName) + { + idNextSlot--; + size_t offName = idNextSlot * FATDIRNAMESLOT_CHARS_PER_SLOT; + memcpy(&wszName[offName], paEntries[iEntry].Slot.awcName0, sizeof(paEntries[iEntry].Slot.awcName0)); + memcpy(&wszName[offName + 5], paEntries[iEntry].Slot.awcName1, sizeof(paEntries[iEntry].Slot.awcName1)); + memcpy(&wszName[offName + 5 + 6], paEntries[iEntry].Slot.awcName2, sizeof(paEntries[iEntry].Slot.awcName2)); + } + } + /* + * Got a regular directory entry. Try return it to the caller if not volume label. + */ + else if (!(paEntries[iEntry].Entry.fAttrib & FAT_ATTR_VOLUME)) + { + /* Do the length calc and check for overflows. */ + bool fLongName = false; + size_t cchName = 0; + if ( cwcName != 0 + && idNextSlot == 0 + && rtFsFatDir_CalcChecksum(&paEntries[iEntry].Entry) == bChecksum) + { + rc = RTUtf16CalcUtf8LenEx(wszName, cwcName, &cchName); + if (RT_SUCCESS(rc)) + fLongName = true; + } + if (!fLongName) + cchName = rtFsFatDir_CalcUtf8LengthForDirEntry(pShared, &paEntries[iEntry].Entry); + size_t cbNeeded = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchName + 1]); + if (cbNeeded <= *pcbDirEntry) + *pcbDirEntry = cbNeeded; + else + { + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + + /* To avoid duplicating code in rtFsFatObj_InitFromDirRec and + rtFsFatObj_QueryInfo, we create a dummy RTFSFATOBJ on the stack. */ + RTFSFATOBJ TmpObj; + RT_ZERO(TmpObj); + rtFsFatObj_InitFromDirEntry(&TmpObj, &paEntries[iEntry].Entry, offEntryInDir, pShared->Core.pVol); + + rtFsFatDirShrd_ReleaseBufferAfterReading(pShared, uBufferLock); + + rc = rtFsFatObj_QueryInfo(&TmpObj, &pDirEntry->Info, enmAddAttr); + + /* Copy out the names. */ + pDirEntry->cbName = (uint16_t)cchName; + if (fLongName) + { + char *pszDst = &pDirEntry->szName[0]; + int rc2 = RTUtf16ToUtf8Ex(wszName, cwcName, &pszDst, cchName + 1, NULL); + AssertRC(rc2); + + pDirEntry->cwcShortName = rtFsFatDir_CopyDirEntryToUtf16(pShared, &paEntries[iEntry].Entry, + pDirEntry->wszShortName, + RT_ELEMENTS(pDirEntry->wszShortName)); + } + else + { + rtFsFatDir_CopyDirEntryToUtf8(pShared, &paEntries[iEntry].Entry, &pDirEntry->szName[0], cchName + 1); + pDirEntry->wszShortName[0] = '\0'; + pDirEntry->cwcShortName = 0; + } + + if (RT_SUCCESS(rc)) + pThis->offDir = offEntryInDir + sizeof(paEntries[iEntry]) + 2; + Assert(RTStrValidateEncoding(pDirEntry->szName) == VINF_SUCCESS); + return rc; + } + else + cwcName = 0; + } + + rtFsFatDirShrd_ReleaseBufferAfterReading(pShared, uBufferLock); + } + + pThis->offDir = cbDir + 2; + return VERR_NO_MORE_FILES; +} + + +/** + * FAT directory operations. + */ +static const RTVFSDIROPS g_rtFsFatDirOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_DIR, + "FatDir", + rtFsFatDir_Close, + rtFsFatDir_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSDIROPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj), + rtFsFatDir_SetMode, + rtFsFatDir_SetTimes, + rtFsFatDir_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsFatDir_Open, + NULL /* pfnFollowAbsoluteSymlink */, + NULL /* pfnOpenFile*/, + NULL /* pfnOpenDir */, + NULL /* pfnCreateDir */, + rtFsFatDir_OpenSymlink, + rtFsFatDir_CreateSymlink, + NULL /* pfnQueryEntryInfo */, + rtFsFatDir_UnlinkEntry, + rtFsFatDir_RenameEntry, + rtFsFatDir_RewindDir, + rtFsFatDir_ReadDir, + RTVFSDIROPS_VERSION, +}; + + + + +/** + * Adds an open child to the parent directory. + * + * Maintains an additional reference to the parent dir to prevent it from going + * away. If @a pDir is the root directory, it also ensures the volume is + * referenced and sticks around until the last open object is gone. + * + * @param pDir The directory. + * @param pChild The child being opened. + * @sa rtFsFatDirShrd_RemoveOpenChild + */ +static void rtFsFatDirShrd_AddOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild) +{ + rtFsFatDirShrd_Retain(pDir); + + RTListAppend(&pDir->OpenChildren, &pChild->Entry); + pChild->pParentDir = pDir; +} + + +/** + * Removes an open child to the parent directory. + * + * @param pDir The directory. + * @param pChild The child being removed. + * + * @remarks This is the very last thing you do as it may cause a few other + * objects to be released recursively (parent dir and the volume). + * + * @sa rtFsFatDirShrd_AddOpenChild + */ +static void rtFsFatDirShrd_RemoveOpenChild(PRTFSFATDIRSHRD pDir, PRTFSFATOBJ pChild) +{ + AssertReturnVoid(pChild->pParentDir == pDir); + RTListNodeRemove(&pChild->Entry); + pChild->pParentDir = NULL; + + rtFsFatDirShrd_Release(pDir); +} + + +/** + * Instantiates a new shared directory instance. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param pParentDir The parent directory. This is NULL for the root + * directory. + * @param pDirEntry The parent directory entry. This is NULL for the + * root directory. + * @param offEntryInDir The byte offset of the directory entry in the parent + * directory. UINT32_MAX if root directory. + * @param idxCluster The cluster where the directory content is to be + * found. This can be UINT32_MAX if a root FAT12/16 + * directory. + * @param offDisk The disk byte offset of the FAT12/16 root directory. + * This is UINT64_MAX if idxCluster is given. + * @param cbDir The size of the directory. + * @param ppSharedDir Where to return shared FAT directory instance. + */ +static int rtFsFatDirShrd_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir, + uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTFSFATDIRSHRD *ppSharedDir) +{ + Assert((idxCluster == UINT32_MAX) != (offDisk == UINT64_MAX)); + Assert((pDirEntry == NULL) == (offEntryInDir == UINT32_MAX)); + *ppSharedDir = NULL; + + int rc = VERR_NO_MEMORY; + PRTFSFATDIRSHRD pShared = (PRTFSFATDIRSHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + /* + * Initialize it all so rtFsFatDir_Close doesn't trip up in anyway. + */ + RTListInit(&pShared->OpenChildren); + if (pDirEntry) + rtFsFatObj_InitFromDirEntry(&pShared->Core, pDirEntry, offEntryInDir, pThis); + else + rtFsFatObj_InitDummy(&pShared->Core, cbDir, RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_UNIX_ALL_PERMS, pThis); + + pShared->cEntries = cbDir / sizeof(FATDIRENTRY); + pShared->fIsLinearRootDir = idxCluster == UINT32_MAX; + pShared->fFullyBuffered = pShared->fIsLinearRootDir; + pShared->paEntries = NULL; + pShared->offEntriesOnDisk = UINT64_MAX; + if (pShared->fFullyBuffered) + pShared->cbAllocatedForEntries = RT_ALIGN_32(cbDir, pThis->cbSector); + else + pShared->cbAllocatedForEntries = pThis->cbSector; + + /* + * If clustered backing, read the chain and see if we cannot still do the full buffering. + */ + if (idxCluster != UINT32_MAX) + { + rc = rtFsFatClusterMap_ReadClusterChain(pThis, idxCluster, &pShared->Core.Clusters); + if (RT_SUCCESS(rc)) + { + if ( pShared->Core.Clusters.cClusters >= 1 + && pShared->Core.Clusters.cbChain <= _64K + && rtFsFatChain_IsContiguous(&pShared->Core.Clusters)) + { + Assert(pShared->Core.Clusters.cbChain >= cbDir); + pShared->cbAllocatedForEntries = pShared->Core.Clusters.cbChain; + pShared->fFullyBuffered = true; + } + + /* DOS doesn't set a size on directores, so use the cluster length instead. */ + if ( cbDir == 0 + && pShared->Core.Clusters.cbChain > 0) + { + cbDir = pShared->Core.Clusters.cbChain; + pShared->Core.cbObject = cbDir; + pShared->cEntries = cbDir / sizeof(FATDIRENTRY); + if (pShared->fFullyBuffered) + pShared->cbAllocatedForEntries = RT_ALIGN_32(cbDir, pThis->cbSector); + } + } + } + else + { + rtFsFatChain_InitEmpty(&pShared->Core.Clusters, pThis); + rc = VINF_SUCCESS; + } + if (RT_SUCCESS(rc)) + { + /* + * Allocate and initialize the buffering. Fill the buffer. + */ + pShared->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pShared->cbAllocatedForEntries); + if (!pShared->paEntries) + { + if (pShared->fFullyBuffered && !pShared->fIsLinearRootDir) + { + pShared->fFullyBuffered = false; + pShared->cbAllocatedForEntries = pThis->cbSector; + pShared->paEntries = (PFATDIRENTRYUNION)RTMemAlloc(pShared->cbAllocatedForEntries); + } + if (!pShared->paEntries) + rc = VERR_NO_MEMORY; + } + + if (RT_SUCCESS(rc)) + { + if (pShared->fFullyBuffered) + { + pShared->u.Full.cDirtySectors = 0; + pShared->u.Full.cSectors = pShared->cbAllocatedForEntries / pThis->cbSector; + pShared->u.Full.pbDirtySectors = (uint8_t *)RTMemAllocZ((pShared->u.Full.cSectors + 63) / 8); + if (pShared->u.Full.pbDirtySectors) + pShared->offEntriesOnDisk = offDisk != UINT64_MAX ? offDisk + : rtFsFatClusterToDiskOffset(pThis, idxCluster); + else + rc = VERR_NO_MEMORY; + } + else + { + pShared->offEntriesOnDisk = rtFsFatClusterToDiskOffset(pThis, idxCluster); + pShared->u.Simple.offInDir = 0; + pShared->u.Simple.fDirty = false; + } + if (RT_SUCCESS(rc)) + rc = RTVfsFileReadAt(pThis->hVfsBacking, pShared->offEntriesOnDisk, + pShared->paEntries, pShared->cbAllocatedForEntries, NULL); + if (RT_SUCCESS(rc)) + { + /* + * Link into parent directory so we can use it to update + * our directory entry. + */ + if (pParentDir) + rtFsFatDirShrd_AddOpenChild(pParentDir, &pShared->Core); + *ppSharedDir = pShared; + return VINF_SUCCESS; + } + } + + /* Free the buffer on failure so rtFsFatDir_Close doesn't try do anything with it. */ + RTMemFree(pShared->paEntries); + pShared->paEntries = NULL; + } + + Assert(pShared->Core.cRefs == 1); + rtFsFatDirShrd_Release(pShared); + } + return rc; +} + + +/** + * Instantiates a new directory with a shared structure presupplied. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param pShared Referenced pointer to the shared structure. The + * reference is always CONSUMED. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsFatDir_NewWithShared(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pShared, PRTVFSDIR phVfsDir) +{ + /* + * Create VFS object around the shared structure. + */ + PRTFSFATDIR pNewDir; + int rc = RTVfsNewDir(&g_rtFsFatDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, + NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir); + if (RT_SUCCESS(rc)) + { + /* + * Look for existing shared object, create a new one if necessary. + * We CONSUME a reference to pShared here. + */ + pNewDir->offDir = 0; + pNewDir->pShared = pShared; + return VINF_SUCCESS; + } + + rtFsFatDirShrd_Release(pShared); + *phVfsDir = NIL_RTVFSDIR; + return rc; +} + + + +/** + * Instantiates a new directory VFS, creating the shared structure as necessary. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param pParentDir The parent directory. This is NULL for the root + * directory. + * @param pDirEntry The parent directory entry. This is NULL for the + * root directory. + * @param offEntryInDir The byte offset of the directory entry in the parent + * directory. UINT32_MAX if root directory. + * @param idxCluster The cluster where the directory content is to be + * found. This can be UINT32_MAX if a root FAT12/16 + * directory. + * @param offDisk The disk byte offset of the FAT12/16 root directory. + * This is UINT64_MAX if idxCluster is given. + * @param cbDir The size of the directory. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsFatDir_New(PRTFSFATVOL pThis, PRTFSFATDIRSHRD pParentDir, PCFATDIRENTRY pDirEntry, uint32_t offEntryInDir, + uint32_t idxCluster, uint64_t offDisk, uint32_t cbDir, PRTVFSDIR phVfsDir) +{ + /* + * Look for existing shared object, create a new one if necessary. + */ + PRTFSFATDIRSHRD pShared = (PRTFSFATDIRSHRD)rtFsFatDirShrd_LookupShared(pParentDir, offEntryInDir); + if (!pShared) + { + int rc = rtFsFatDirShrd_New(pThis, pParentDir, pDirEntry, offEntryInDir, idxCluster, offDisk, cbDir, &pShared); + if (RT_FAILURE(rc)) + { + *phVfsDir = NIL_RTVFSDIR; + return rc; + } + } + return rtFsFatDir_NewWithShared(pThis, pShared, phVfsDir); +} + + + + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose} + */ +static DECLCALLBACK(int) rtFsFatVol_Close(void *pvThis) +{ + PRTFSFATVOL pThis = (PRTFSFATVOL)pvThis; + LogFlow(("rtFsFatVol_Close(%p)\n", pThis)); + + int rc = VINF_SUCCESS; + if (pThis->pRootDir != NULL) + { + Assert(RTListIsEmpty(&pThis->pRootDir->OpenChildren)); + Assert(pThis->pRootDir->Core.cRefs == 1); + rc = rtFsFatDirShrd_Release(pThis->pRootDir); + pThis->pRootDir = NULL; + } + + int rc2 = rtFsFatClusterMap_Destroy(pThis); + if (RT_SUCCESS(rc)) + rc = rc2; + + RTVfsFileRelease(pThis->hVfsBacking); + pThis->hVfsBacking = NIL_RTVFSFILE; + + return rc; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsFatVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_NOREF(pvThis, pObjInfo, enmAddAttr); + return VERR_WRONG_TYPE; +} + + +/** + * @interface_method_impl{RTVFSOPS,pfnOpenRoot} + */ +static DECLCALLBACK(int) rtFsFatVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir) +{ + PRTFSFATVOL pThis = (PRTFSFATVOL)pvThis; + + rtFsFatDirShrd_Retain(pThis->pRootDir); /* consumed by the next call */ + return rtFsFatDir_NewWithShared(pThis, pThis->pRootDir, phVfsDir); +} + + +/** + * @interface_method_impl{RTVFSOPS,pfnQueryRangeState} + */ +static DECLCALLBACK(int) rtFsFatVol_QueryRangeState(void *pvThis, uint64_t off, size_t cb, bool *pfUsed) +{ + + + RT_NOREF(pvThis, off, cb, pfUsed); + return VERR_NOT_IMPLEMENTED; +} + + +DECL_HIDDEN_CONST(const RTVFSOPS) g_rtFsFatVolOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_VFS, + "FatVol", + rtFsFatVol_Close, + rtFsFatVol_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSOPS_VERSION, + 0 /* fFeatures */, + rtFsFatVol_OpenRoot, + rtFsFatVol_QueryRangeState, + RTVFSOPS_VERSION +}; + + +/** + * Tries to detect a DOS 1.x formatted image and fills in the BPB fields. + * + * There is no BPB here, but fortunately, there isn't much variety. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance, BPB derived fields are filled + * in on success. + * @param pBootSector The boot sector. + * @param pbFatSector Points to the FAT sector, or whatever is 512 bytes after + * the boot sector. + * @param pErrInfo Where to return additional error information. + */ +static int rtFsFatVolTryInitDos1x(PRTFSFATVOL pThis, PCFATBOOTSECTOR pBootSector, uint8_t const *pbFatSector, + PRTERRINFO pErrInfo) +{ + /* + * PC-DOS 1.0 does a 2fh byte short jump w/o any NOP following it. + * Instead the following are three words and a 9 byte build date + * string. The remaining space is zero filled. + * + * Note! No idea how this would look like for 8" floppies, only got 5"1/4'. + * + * ASSUME all non-BPB disks are using this format. + */ + if ( pBootSector->abJmp[0] != 0xeb /* jmp rel8 */ + || pBootSector->abJmp[1] < 0x2f + || pBootSector->abJmp[1] >= 0x80 + || pBootSector->abJmp[2] == 0x90 /* nop */) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "No DOS v1.0 bootsector either - invalid jmp: %.3Rhxs", pBootSector->abJmp); + uint32_t const offJump = 2 + pBootSector->abJmp[1]; + uint32_t const offFirstZero = 2 /*jmp */ + 3 * 2 /* words */ + 9 /* date string */; + Assert(offFirstZero >= RT_UOFFSETOF(FATBOOTSECTOR, Bpb)); + uint32_t const cbZeroPad = RT_MIN(offJump - offFirstZero, + sizeof(pBootSector->Bpb.Bpb20) - (offFirstZero - RT_UOFFSETOF(FATBOOTSECTOR, Bpb))); + + if (!ASMMemIsAllU8((uint8_t const *)pBootSector + offFirstZero, cbZeroPad, 0)) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "No DOS v1.0 bootsector either - expected zero padding %#x LB %#x: %.*Rhxs", + offFirstZero, cbZeroPad, cbZeroPad, (uint8_t const *)pBootSector + offFirstZero); + + /* + * Check the FAT ID so we can tell if this is double or single sided, + * as well as being a valid FAT12 start. + */ + if ( (pbFatSector[0] != 0xfe && pbFatSector[0] != 0xff) + || pbFatSector[1] != 0xff + || pbFatSector[2] != 0xff) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "No DOS v1.0 bootsector either - unexpected start of FAT: %.3Rhxs", pbFatSector); + + /* + * Fixed DOS 1.0 config. + */ + pThis->enmFatType = RTFSFATTYPE_FAT12; + pThis->enmBpbVersion = RTFSFATBPBVER_NO_BPB; + pThis->bMedia = pbFatSector[0]; + pThis->cReservedSectors = 1; + pThis->cbSector = 512; + pThis->cbCluster = pThis->bMedia == 0xfe ? 1024 : 512; + pThis->cFats = 2; + pThis->cbFat = 512; + pThis->aoffFats[0] = pThis->offBootSector + pThis->cReservedSectors * 512; + pThis->aoffFats[1] = pThis->aoffFats[0] + pThis->cbFat; + pThis->offRootDir = pThis->aoffFats[1] + pThis->cbFat; + pThis->cRootDirEntries = 512; + pThis->offFirstCluster = pThis->offRootDir + RT_ALIGN_32(pThis->cRootDirEntries * sizeof(FATDIRENTRY), + pThis->cbSector); + pThis->cbTotalSize = pThis->bMedia == 0xfe ? 8 * 1 * 40 * 512 : 8 * 2 * 40 * 512; + pThis->cClusters = (pThis->cbTotalSize - (pThis->offFirstCluster - pThis->offBootSector)) / pThis->cbCluster; + return VINF_SUCCESS; +} + + +/** + * Worker for rtFsFatVolTryInitDos2Plus that handles remaining BPB fields. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance, BPB derived fields are filled + * in on success. + * @param pBootSector The boot sector. + * @param fMaybe331 Set if it could be a DOS v3.31 BPB. + * @param pErrInfo Where to return additional error information. + */ +static int rtFsFatVolTryInitDos2PlusBpb(PRTFSFATVOL pThis, PCFATBOOTSECTOR pBootSector, bool fMaybe331, PRTERRINFO pErrInfo) +{ + pThis->enmBpbVersion = RTFSFATBPBVER_DOS_2_0; + + /* + * Figure total sector count. Could both be zero, in which case we have to + * fall back on the size of the backing stuff. + */ + if (pBootSector->Bpb.Bpb20.cTotalSectors16 != 0) + pThis->cbTotalSize = pBootSector->Bpb.Bpb20.cTotalSectors16 * pThis->cbSector; + else if ( pBootSector->Bpb.Bpb331.cTotalSectors32 != 0 + && fMaybe331) + { + pThis->enmBpbVersion = RTFSFATBPBVER_DOS_3_31; + pThis->cbTotalSize = pBootSector->Bpb.Bpb331.cTotalSectors32 * (uint64_t)pThis->cbSector; + } + else + pThis->cbTotalSize = pThis->cbBacking - pThis->offBootSector; + if (pThis->cReservedSectors * pThis->cbSector >= pThis->cbTotalSize) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus FAT12/16 total or reserved sector count: %#x vs %#x", + pThis->cReservedSectors, pThis->cbTotalSize / pThis->cbSector); + + /* + * The fat size. Complete FAT offsets. + */ + if ( pBootSector->Bpb.Bpb20.cSectorsPerFat == 0 + || ((uint32_t)pBootSector->Bpb.Bpb20.cSectorsPerFat * pThis->cFats + 1) * pThis->cbSector > pThis->cbTotalSize) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Bogus FAT12/16 sectors per FAT: %#x (total sectors %#RX64)", + pBootSector->Bpb.Bpb20.cSectorsPerFat, pThis->cbTotalSize / pThis->cbSector); + pThis->cbFat = pBootSector->Bpb.Bpb20.cSectorsPerFat * pThis->cbSector; + + AssertReturn(pThis->cFats < RT_ELEMENTS(pThis->aoffFats), VERR_VFS_BOGUS_FORMAT); + for (unsigned iFat = 1; iFat <= pThis->cFats; iFat++) + pThis->aoffFats[iFat] = pThis->aoffFats[iFat - 1] + pThis->cbFat; + + /* + * Do root directory calculations. + */ + pThis->idxRootDirCluster = UINT32_MAX; + pThis->offRootDir = pThis->aoffFats[pThis->cFats]; + if (pThis->cRootDirEntries == 0) + return RTErrInfoSet(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Zero FAT12/16 root directory size"); + pThis->cbRootDir = pThis->cRootDirEntries * sizeof(FATDIRENTRY); + pThis->cbRootDir = RT_ALIGN_32(pThis->cbRootDir, pThis->cbSector); + + /* + * First cluster and cluster count checks and calcs. Determin FAT type. + */ + pThis->offFirstCluster = pThis->offRootDir + pThis->cbRootDir; + uint64_t cbSystemStuff = pThis->offFirstCluster - pThis->offBootSector; + if (cbSystemStuff >= pThis->cbTotalSize) + return RTErrInfoSet(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Bogus FAT12/16 total size, root dir, or fat size"); + pThis->cClusters = (pThis->cbTotalSize - cbSystemStuff) / pThis->cbCluster; + + if (pThis->cClusters >= FAT_MAX_FAT16_DATA_CLUSTERS) + { + pThis->cClusters = FAT_MAX_FAT16_DATA_CLUSTERS; + pThis->enmFatType = RTFSFATTYPE_FAT16; + } + else if (pThis->cClusters >= FAT_MIN_FAT16_DATA_CLUSTERS) + pThis->enmFatType = RTFSFATTYPE_FAT16; + else + pThis->enmFatType = RTFSFATTYPE_FAT12; /** @todo Not sure if this is entirely the right way to go about it... */ + + uint32_t cClustersPerFat; + if (pThis->enmFatType == RTFSFATTYPE_FAT16) + cClustersPerFat = pThis->cbFat / 2; + else + cClustersPerFat = pThis->cbFat * 2 / 3; + if (pThis->cClusters > cClustersPerFat) + pThis->cClusters = cClustersPerFat; + + return VINF_SUCCESS; +} + + +/** + * Worker for rtFsFatVolTryInitDos2Plus and rtFsFatVolTryInitDos2PlusFat32 that + * handles common extended BPBs fields. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance. + * @param bExtSignature The extended BPB signature. + * @param uSerialNumber The serial number. + * @param pachLabel Pointer to the volume label field. + * @param pachType Pointer to the file system type field. + */ +static void rtFsFatVolInitCommonEbpbBits(PRTFSFATVOL pThis, uint8_t bExtSignature, uint32_t uSerialNumber, + char const *pachLabel, char const *pachType) +{ + pThis->uSerialNo = uSerialNumber; + if (bExtSignature == FATEBPB_SIGNATURE) + { + memcpy(pThis->szLabel, pachLabel, RT_SIZEOFMEMB(FATEBPB, achLabel)); + pThis->szLabel[RT_SIZEOFMEMB(FATEBPB, achLabel)] = '\0'; + RTStrStrip(pThis->szLabel); + + memcpy(pThis->szType, pachType, RT_SIZEOFMEMB(FATEBPB, achType)); + pThis->szType[RT_SIZEOFMEMB(FATEBPB, achType)] = '\0'; + RTStrStrip(pThis->szType); + } + else + { + pThis->szLabel[0] = '\0'; + pThis->szType[0] = '\0'; + } +} + + +/** + * Worker for rtFsFatVolTryInitDos2Plus that deals with FAT32. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance, BPB derived fields are filled + * in on success. + * @param pBootSector The boot sector. + * @param pErrInfo Where to return additional error information. + */ +static int rtFsFatVolTryInitDos2PlusFat32(PRTFSFATVOL pThis, PCFATBOOTSECTOR pBootSector, PRTERRINFO pErrInfo) +{ + pThis->enmFatType = RTFSFATTYPE_FAT32; + pThis->enmBpbVersion = pBootSector->Bpb.Fat32Ebpb.bExtSignature == FATEBPB_SIGNATURE + ? RTFSFATBPBVER_FAT32_29 : RTFSFATBPBVER_FAT32_28; + pThis->fFat32Flags = pBootSector->Bpb.Fat32Ebpb.fFlags; + + if (pBootSector->Bpb.Fat32Ebpb.uVersion != FAT32EBPB_VERSION_0_0) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Unsupported FAT32 version: %d.%d (%#x)", + RT_HI_U8(pBootSector->Bpb.Fat32Ebpb.uVersion), RT_LO_U8(pBootSector->Bpb.Fat32Ebpb.uVersion), + pBootSector->Bpb.Fat32Ebpb.uVersion); + + /* + * Figure total sector count. We expected it to be filled in. + */ + bool fUsing64BitTotalSectorCount = false; + if (pBootSector->Bpb.Fat32Ebpb.Bpb.cTotalSectors16 != 0) + pThis->cbTotalSize = pBootSector->Bpb.Fat32Ebpb.Bpb.cTotalSectors16 * pThis->cbSector; + else if (pBootSector->Bpb.Fat32Ebpb.Bpb.cTotalSectors32 != 0) + pThis->cbTotalSize = pBootSector->Bpb.Fat32Ebpb.Bpb.cTotalSectors32 * (uint64_t)pThis->cbSector; + else if ( pBootSector->Bpb.Fat32Ebpb.u.cTotalSectors64 <= UINT64_MAX / 512 + && pBootSector->Bpb.Fat32Ebpb.u.cTotalSectors64 > 3 + && pBootSector->Bpb.Fat32Ebpb.bExtSignature != FATEBPB_SIGNATURE_OLD) + { + pThis->cbTotalSize = pBootSector->Bpb.Fat32Ebpb.u.cTotalSectors64 * pThis->cbSector; + fUsing64BitTotalSectorCount = true; + } + else + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "FAT32 total sector count out of range: %#RX64", + pBootSector->Bpb.Fat32Ebpb.u.cTotalSectors64); + if (pThis->cReservedSectors * pThis->cbSector >= pThis->cbTotalSize) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus FAT32 total or reserved sector count: %#x vs %#x", + pThis->cReservedSectors, pThis->cbTotalSize / pThis->cbSector); + + /* + * Fat size. We check the 16-bit field even if it probably should be zero all the time. + */ + if (pBootSector->Bpb.Fat32Ebpb.Bpb.cSectorsPerFat != 0) + { + if ( pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32 != 0 + && pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32 != pBootSector->Bpb.Fat32Ebpb.Bpb.cSectorsPerFat) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Both 16-bit and 32-bit FAT size fields are set: %#RX16 vs %#RX32", + pBootSector->Bpb.Fat32Ebpb.Bpb.cSectorsPerFat, pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32); + pThis->cbFat = pBootSector->Bpb.Fat32Ebpb.Bpb.cSectorsPerFat * pThis->cbSector; + } + else + { + uint64_t cbFat = pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32 * (uint64_t)pThis->cbSector; + if ( cbFat == 0 + || cbFat >= FAT_MAX_FAT32_TOTAL_CLUSTERS * 4 + pThis->cbSector * 16) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus 32-bit FAT size: %#RX32", pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32); + pThis->cbFat = (uint32_t)cbFat; + } + + /* + * Complete the FAT offsets and first cluster offset, then calculate number + * of data clusters. + */ + AssertReturn(pThis->cFats < RT_ELEMENTS(pThis->aoffFats), VERR_VFS_BOGUS_FORMAT); + for (unsigned iFat = 1; iFat <= pThis->cFats; iFat++) + pThis->aoffFats[iFat] = pThis->aoffFats[iFat - 1] + pThis->cbFat; + pThis->offFirstCluster = pThis->aoffFats[pThis->cFats]; + + if (pThis->offFirstCluster - pThis->offBootSector >= pThis->cbTotalSize) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus 32-bit FAT size or total sector count: cFats=%d cbFat=%#x cbTotalSize=%#x", + pThis->cFats, pThis->cbFat, pThis->cbTotalSize); + + uint64_t cClusters = (pThis->cbTotalSize - (pThis->offFirstCluster - pThis->offBootSector)) / pThis->cbCluster; + if (cClusters <= FAT_MAX_FAT32_DATA_CLUSTERS) + pThis->cClusters = (uint32_t)cClusters; + else + pThis->cClusters = FAT_MAX_FAT32_DATA_CLUSTERS; + if (pThis->cClusters > (pThis->cbFat / 4 - FAT_FIRST_DATA_CLUSTER)) + pThis->cClusters = (pThis->cbFat / 4 - FAT_FIRST_DATA_CLUSTER); + + /* + * Root dir cluster. + */ + if ( pBootSector->Bpb.Fat32Ebpb.uRootDirCluster < FAT_FIRST_DATA_CLUSTER + || pBootSector->Bpb.Fat32Ebpb.uRootDirCluster >= pThis->cClusters) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus FAT32 root directory cluster: %#x", pBootSector->Bpb.Fat32Ebpb.uRootDirCluster); + pThis->idxRootDirCluster = pBootSector->Bpb.Fat32Ebpb.uRootDirCluster; + pThis->offRootDir = pThis->offFirstCluster + + (pBootSector->Bpb.Fat32Ebpb.uRootDirCluster - FAT_FIRST_DATA_CLUSTER) * pThis->cbCluster; + + /* + * Info sector. + */ + if ( pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo == 0 + || pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo == UINT16_MAX) + pThis->offFat32InfoSector = UINT64_MAX; + else if (pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo >= pThis->cReservedSectors) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus FAT32 info sector number: %#x (reserved sectors %#x)", + pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo, pThis->cReservedSectors); + else + { + pThis->offFat32InfoSector = pThis->cbSector * pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo + pThis->offBootSector; + int rc = RTVfsFileReadAt(pThis->hVfsBacking, pThis->offFat32InfoSector, + &pThis->Fat32InfoSector, sizeof(pThis->Fat32InfoSector), NULL); + if (RT_FAILURE(rc)) + return RTErrInfoSetF(pErrInfo, rc, "Failed to read FAT32 info sector at offset %#RX64", pThis->offFat32InfoSector); + if ( pThis->Fat32InfoSector.uSignature1 != FAT32INFOSECTOR_SIGNATURE_1 + || pThis->Fat32InfoSector.uSignature2 != FAT32INFOSECTOR_SIGNATURE_2 + || pThis->Fat32InfoSector.uSignature3 != FAT32INFOSECTOR_SIGNATURE_3) + return RTErrInfoSetF(pErrInfo, rc, "FAT32 info sector signature mismatch: %#x %#x %#x", + pThis->Fat32InfoSector.uSignature1, pThis->Fat32InfoSector.uSignature2, + pThis->Fat32InfoSector.uSignature3); + } + + /* + * Boot sector copy. + */ + if ( pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo == 0 + || pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo == UINT16_MAX) + { + pThis->cBootSectorCopies = 0; + pThis->offBootSectorCopies = UINT64_MAX; + } + else if (pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo >= pThis->cReservedSectors) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bogus FAT32 info boot sector copy location: %#x (reserved sectors %#x)", + pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo, pThis->cReservedSectors); + else + { + /** @todo not sure if cbSector is correct here. */ + pThis->cBootSectorCopies = 3; + if ( (uint32_t)pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo + pThis->cBootSectorCopies + > pThis->cReservedSectors) + pThis->cBootSectorCopies = (uint8_t)(pThis->cReservedSectors - pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo); + pThis->offBootSectorCopies = pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo * pThis->cbSector + pThis->offBootSector; + if ( pThis->offFat32InfoSector != UINT64_MAX + && pThis->offFat32InfoSector - pThis->offBootSectorCopies < (uint64_t)(pThis->cBootSectorCopies * pThis->cbSector)) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "FAT32 info sector and boot sector copies overlap: %#x vs %#x", + pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo, pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo); + } + + /* + * Serial number, label and type. + */ + rtFsFatVolInitCommonEbpbBits(pThis, pBootSector->Bpb.Fat32Ebpb.bExtSignature, pBootSector->Bpb.Fat32Ebpb.uSerialNumber, + pBootSector->Bpb.Fat32Ebpb.achLabel, + fUsing64BitTotalSectorCount ? pBootSector->achOemName : pBootSector->Bpb.Fat32Ebpb.achLabel); + if (pThis->szType[0] == '\0') + memcpy(pThis->szType, "FAT32", 6); + + return VINF_SUCCESS; +} + + +/** + * Tries to detect a DOS 2.0+ formatted image and fills in the BPB fields. + * + * We ASSUME BPB here, but need to figure out which version of the BPB it is, + * which is lots of fun. + * + * @returns IPRT status code. + * @param pThis The FAT volume instance, BPB derived fields are filled + * in on success. + * @param pBootSector The boot sector. + * @param pbFatSector Points to the FAT sector, or whatever is 512 bytes after + * the boot sector. On successful return it will contain + * the first FAT sector. + * @param pErrInfo Where to return additional error information. + */ +static int rtFsFatVolTryInitDos2Plus(PRTFSFATVOL pThis, PCFATBOOTSECTOR pBootSector, uint8_t *pbFatSector, PRTERRINFO pErrInfo) +{ + /* + * Check if we've got a known jump instruction first, because that will + * give us a max (E)BPB size hint. + */ + uint8_t offJmp = UINT8_MAX; + if ( pBootSector->abJmp[0] == 0xeb + && pBootSector->abJmp[1] <= 0x7f) + offJmp = pBootSector->abJmp[1] + 2; + else if ( pBootSector->abJmp[0] == 0x90 + && pBootSector->abJmp[1] == 0xeb + && pBootSector->abJmp[2] <= 0x7f) + offJmp = pBootSector->abJmp[2] + 3; + else if ( pBootSector->abJmp[0] == 0xe9 + && pBootSector->abJmp[2] <= 0x7f) + offJmp = RT_MIN(127, RT_MAKE_U16(pBootSector->abJmp[1], pBootSector->abJmp[2])); + uint8_t const cbMaxBpb = offJmp - RT_UOFFSETOF(FATBOOTSECTOR, Bpb); + + /* + * Do the basic DOS v2.0 BPB fields. + */ + if (cbMaxBpb < sizeof(FATBPB20)) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "DOS signature, but jmp too short for any BPB: %#x (max %#x BPB)", offJmp, cbMaxBpb); + + if (pBootSector->Bpb.Bpb20.cFats == 0) + return RTErrInfoSet(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "DOS signature, number of FATs is zero, so not FAT file system"); + if (pBootSector->Bpb.Bpb20.cFats > 4) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "DOS signature, too many FATs: %#x", pBootSector->Bpb.Bpb20.cFats); + pThis->cFats = pBootSector->Bpb.Bpb20.cFats; + + if (!FATBPB_MEDIA_IS_VALID(pBootSector->Bpb.Bpb20.bMedia)) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "DOS signature, invalid media byte: %#x", pBootSector->Bpb.Bpb20.bMedia); + pThis->bMedia = pBootSector->Bpb.Bpb20.bMedia; + + if (!RT_IS_POWER_OF_TWO(pBootSector->Bpb.Bpb20.cbSector)) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "DOS signature, sector size not power of two: %#x", pBootSector->Bpb.Bpb20.cbSector); + if ( pBootSector->Bpb.Bpb20.cbSector != 512 + && pBootSector->Bpb.Bpb20.cbSector != 4096 + && pBootSector->Bpb.Bpb20.cbSector != 1024 + && pBootSector->Bpb.Bpb20.cbSector != 128) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "DOS signature, unsupported sector size: %#x", pBootSector->Bpb.Bpb20.cbSector); + pThis->cbSector = pBootSector->Bpb.Bpb20.cbSector; + + if ( !RT_IS_POWER_OF_TWO(pBootSector->Bpb.Bpb20.cSectorsPerCluster) + || !pBootSector->Bpb.Bpb20.cSectorsPerCluster) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "DOS signature, cluster size not non-zero power of two: %#x", + pBootSector->Bpb.Bpb20.cSectorsPerCluster); + pThis->cbCluster = pBootSector->Bpb.Bpb20.cSectorsPerCluster * pThis->cbSector; + + uint64_t const cMaxRoot = (pThis->cbBacking - pThis->offBootSector - 512) / sizeof(FATDIRENTRY); /* we'll check again later. */ + if (pBootSector->Bpb.Bpb20.cMaxRootDirEntries >= cMaxRoot) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "DOS signature, too many root entries: %#x (max %#RX64)", + pBootSector->Bpb.Bpb20.cSectorsPerCluster, cMaxRoot); + pThis->cRootDirEntries = pBootSector->Bpb.Bpb20.cMaxRootDirEntries; + + if ( pBootSector->Bpb.Bpb20.cReservedSectors == 0 + || pBootSector->Bpb.Bpb20.cReservedSectors >= _32K) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "DOS signature, bogus reserved sector count: %#x", pBootSector->Bpb.Bpb20.cReservedSectors); + pThis->cReservedSectors = pBootSector->Bpb.Bpb20.cReservedSectors; + pThis->aoffFats[0] = pThis->offBootSector + pThis->cReservedSectors * pThis->cbSector; + + /* + * Jump ahead and check for FAT32 EBPB. + * If found, we simply ASSUME it's a FAT32 file system. + */ + int rc; + if ( ( sizeof(FAT32EBPB) <= cbMaxBpb + && pBootSector->Bpb.Fat32Ebpb.bExtSignature == FATEBPB_SIGNATURE) + || ( RT_UOFFSETOF(FAT32EBPB, achLabel) <= cbMaxBpb + && pBootSector->Bpb.Fat32Ebpb.bExtSignature == FATEBPB_SIGNATURE_OLD) ) + { + rc = rtFsFatVolTryInitDos2PlusFat32(pThis, pBootSector, pErrInfo); + if (RT_FAILURE(rc)) + return rc; + } + else + { + /* + * Check for extended BPB, otherwise we'll have to make qualified guesses + * about what kind of BPB we're up against based on jmp offset and zero fields. + * ASSUMES either FAT16 or FAT12. + */ + if ( ( sizeof(FATEBPB) <= cbMaxBpb + && pBootSector->Bpb.Ebpb.bExtSignature == FATEBPB_SIGNATURE) + || ( RT_UOFFSETOF(FATEBPB, achLabel) <= cbMaxBpb + && pBootSector->Bpb.Ebpb.bExtSignature == FATEBPB_SIGNATURE_OLD) ) + { + rtFsFatVolInitCommonEbpbBits(pThis, pBootSector->Bpb.Ebpb.bExtSignature, pBootSector->Bpb.Ebpb.uSerialNumber, + pBootSector->Bpb.Ebpb.achLabel, pBootSector->Bpb.Ebpb.achType); + rc = rtFsFatVolTryInitDos2PlusBpb(pThis, pBootSector, true /*fMaybe331*/, pErrInfo); + pThis->enmBpbVersion = pBootSector->Bpb.Ebpb.bExtSignature == FATEBPB_SIGNATURE + ? RTFSFATBPBVER_EXT_29 : RTFSFATBPBVER_EXT_28; + } + else + rc = rtFsFatVolTryInitDos2PlusBpb(pThis, pBootSector, cbMaxBpb >= sizeof(FATBPB331), pErrInfo); + if (RT_FAILURE(rc)) + return rc; + if (pThis->szType[0] == '\0') + memcpy(pThis->szType, pThis->enmFatType == RTFSFATTYPE_FAT12 ? "FAT12" : "FAT16", 6); + } + + /* + * Check the FAT ID. May have to read a bit of the FAT into the buffer. + */ + if (pThis->aoffFats[0] != pThis->offBootSector + 512) + { + rc = RTVfsFileReadAt(pThis->hVfsBacking, pThis->aoffFats[0], pbFatSector, 512, NULL); + if (RT_FAILURE(rc)) + return RTErrInfoSet(pErrInfo, rc, "error reading first FAT sector"); + } + if (pbFatSector[0] != pThis->bMedia) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Media byte and FAT ID mismatch: %#x vs %#x (%.7Rhxs)", pbFatSector[0], pThis->bMedia, pbFatSector); + uint32_t idxOurEndOfChain; + switch (pThis->enmFatType) + { + case RTFSFATTYPE_FAT12: + if ((pbFatSector[1] & 0xf) != 0xf) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Bogus FAT ID patting (FAT12): %.3Rhxs", pbFatSector); + pThis->idxMaxLastCluster = FAT_LAST_FAT12_DATA_CLUSTER; + pThis->idxEndOfChain = (pbFatSector[1] >> 4) | ((uint32_t)pbFatSector[2] << 4); + idxOurEndOfChain = FAT_FIRST_FAT12_EOC | 0xf; + break; + + case RTFSFATTYPE_FAT16: + if (pbFatSector[1] != 0xff) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Bogus FAT ID patting (FAT16): %.4Rhxs", pbFatSector); + pThis->idxMaxLastCluster = FAT_LAST_FAT16_DATA_CLUSTER; + pThis->idxEndOfChain = RT_MAKE_U16(pbFatSector[2], pbFatSector[3]); + idxOurEndOfChain = FAT_FIRST_FAT16_EOC | 0xf; + break; + + case RTFSFATTYPE_FAT32: + if ( pbFatSector[1] != 0xff + || pbFatSector[2] != 0xff + || (pbFatSector[3] & 0x0f) != 0x0f) + return RTErrInfoSetF(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Bogus FAT ID patting (FAT32): %.8Rhxs", pbFatSector); + pThis->idxMaxLastCluster = FAT_LAST_FAT32_DATA_CLUSTER; + pThis->idxEndOfChain = RT_MAKE_U32_FROM_U8(pbFatSector[4], pbFatSector[5], pbFatSector[6], pbFatSector[7]); + idxOurEndOfChain = FAT_FIRST_FAT32_EOC | 0xf; + break; + + default: AssertFailedReturn(VERR_INTERNAL_ERROR_2); + } + + if (pThis->idxEndOfChain <= pThis->idxMaxLastCluster) + { + Log(("rtFsFatVolTryInitDos2Plus: Bogus idxEndOfChain=%#x, using %#x instead\n", pThis->idxEndOfChain, idxOurEndOfChain)); + pThis->idxEndOfChain = idxOurEndOfChain; + } + + RT_NOREF(pbFatSector); + return VINF_SUCCESS; +} + + +/** + * Given a power of two value @a cb return exponent value. + * + * @returns Shift count + * @param cb The value. + */ +static uint8_t rtFsFatVolCalcByteShiftCount(uint32_t cb) +{ + Assert(RT_IS_POWER_OF_TWO(cb)); + unsigned iBit = ASMBitFirstSetU32(cb); + Assert(iBit >= 1); + iBit--; + return iBit; +} + + +/** + * Worker for RTFsFatVolOpen. + * + * @returns IPRT status code. + * @param pThis The FAT VFS instance to initialize. + * @param hVfsSelf The FAT VFS handle (no reference consumed). + * @param hVfsBacking The file backing the alleged FAT file system. + * Reference is consumed (via rtFsFatVol_Destroy). + * @param fReadOnly Readonly or readwrite mount. + * @param offBootSector The boot sector offset in bytes. + * @param pErrInfo Where to return additional error info. Can be NULL. + */ +static int rtFsFatVolTryInit(PRTFSFATVOL pThis, RTVFS hVfsSelf, RTVFSFILE hVfsBacking, + bool fReadOnly, uint64_t offBootSector, PRTERRINFO pErrInfo) +{ + /* + * First initialize the state so that rtFsFatVol_Destroy won't trip up. + */ + pThis->hVfsSelf = hVfsSelf; + pThis->hVfsBacking = hVfsBacking; /* Caller referenced it for us, we consume it; rtFsFatVol_Destroy releases it. */ + pThis->cbBacking = 0; + pThis->offBootSector = offBootSector; + pThis->offNanoUTC = RTTimeLocalDeltaNano(); + pThis->offMinUTC = pThis->offNanoUTC / RT_NS_1MIN; + pThis->fReadOnly = fReadOnly; + pThis->cReservedSectors = 1; + + pThis->cbSector = 512; + pThis->cbCluster = 512; + pThis->cClusters = 0; + pThis->offFirstCluster = 0; + pThis->cbTotalSize = 0; + + pThis->enmFatType = RTFSFATTYPE_INVALID; + pThis->cFatEntries = 0; + pThis->cFats = 0; + pThis->cbFat = 0; + for (unsigned i = 0; i < RT_ELEMENTS(pThis->aoffFats); i++) + pThis->aoffFats[i] = UINT64_MAX; + pThis->pFatCache = NULL; + + pThis->offRootDir = UINT64_MAX; + pThis->idxRootDirCluster = UINT32_MAX; + pThis->cRootDirEntries = UINT32_MAX; + pThis->cbRootDir = 0; + pThis->pRootDir = NULL; + + pThis->uSerialNo = 0; + pThis->szLabel[0] = '\0'; + pThis->szType[0] = '\0'; + pThis->cBootSectorCopies = 0; + pThis->fFat32Flags = 0; + pThis->offBootSectorCopies = UINT64_MAX; + pThis->offFat32InfoSector = UINT64_MAX; + RT_ZERO(pThis->Fat32InfoSector); + + /* + * Get stuff that may fail. + */ + int rc = RTVfsFileGetSize(hVfsBacking, &pThis->cbBacking); + if (RT_FAILURE(rc)) + return rc; + pThis->cbTotalSize = pThis->cbBacking - pThis->offBootSector; + + /* + * Read the boot sector and the following sector (start of the allocation + * table unless it a FAT32 FS). We'll then validate the boot sector and + * start of the FAT, expanding the BPB into the instance data. + */ + union + { + uint8_t ab[512*2]; + uint16_t au16[512*2 / 2]; + uint32_t au32[512*2 / 4]; + FATBOOTSECTOR BootSector; + FAT32INFOSECTOR InfoSector; + } Buf; + RT_ZERO(Buf); + + rc = RTVfsFileReadAt(hVfsBacking, offBootSector, &Buf.BootSector, 512 * 2, NULL); + if (RT_FAILURE(rc)) + return RTErrInfoSet(pErrInfo, rc, "Unable to read bootsect"); + + /* + * Extract info from the BPB and validate the two special FAT entries. + * + * Check the DOS signature first. The PC-DOS 1.0 boot floppy does not have + * a signature and we ASSUME this is the case for all floppies formated by it. + */ + if (Buf.BootSector.uSignature != FATBOOTSECTOR_SIGNATURE) + { + if (Buf.BootSector.uSignature != 0) + return RTErrInfoSetF(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "No DOS bootsector signature: %#06x", Buf.BootSector.uSignature); + rc = rtFsFatVolTryInitDos1x(pThis, &Buf.BootSector, &Buf.ab[512], pErrInfo); + } + else + rc = rtFsFatVolTryInitDos2Plus(pThis, &Buf.BootSector, &Buf.ab[512], pErrInfo); + if (RT_FAILURE(rc)) + return rc; + + /* + * Calc shift counts. + */ + pThis->cSectorByteShift = rtFsFatVolCalcByteShiftCount(pThis->cbSector); + pThis->cClusterByteShift = rtFsFatVolCalcByteShiftCount(pThis->cbCluster); + + /* + * Setup the FAT cache. + */ + rc = rtFsFatClusterMap_Create(pThis, &Buf.ab[512], pErrInfo); + if (RT_FAILURE(rc)) + return rc; + + /* + * Create the root directory fun. + */ + if (pThis->idxRootDirCluster == UINT32_MAX) + rc = rtFsFatDirShrd_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/, + UINT32_MAX, pThis->offRootDir, pThis->cbRootDir, &pThis->pRootDir); + else + rc = rtFsFatDirShrd_New(pThis, NULL /*pParentDir*/, NULL /*pDirEntry*/, UINT32_MAX /*offEntryInDir*/, + pThis->idxRootDirCluster, UINT64_MAX, pThis->cbRootDir, &pThis->pRootDir); + return rc; +} + + +/** + * Opens a FAT file system volume. + * + * @returns IPRT status code. + * @param hVfsFileIn The file or device backing the volume. + * @param fReadOnly Whether to mount it read-only. + * @param offBootSector The offset of the boot sector relative to the start + * of @a hVfsFileIn. Pass 0 for floppies. + * @param phVfs Where to return the virtual file system handle. + * @param pErrInfo Where to return additional error information. + */ +RTDECL(int) RTFsFatVolOpen(RTVFSFILE hVfsFileIn, bool fReadOnly, uint64_t offBootSector, PRTVFS phVfs, PRTERRINFO pErrInfo) +{ + /* + * Quick input validation. + */ + AssertPtrReturn(phVfs, VERR_INVALID_POINTER); + *phVfs = NIL_RTVFS; + + uint32_t cRefs = RTVfsFileRetain(hVfsFileIn); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a new FAT VFS instance and try initialize it using the given input file. + */ + RTVFS hVfs = NIL_RTVFS; + void *pvThis = NULL; + int rc = RTVfsNew(&g_rtFsFatVolOps, sizeof(RTFSFATVOL), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, &pvThis); + if (RT_SUCCESS(rc)) + { + rc = rtFsFatVolTryInit((PRTFSFATVOL)pvThis, hVfs, hVfsFileIn, fReadOnly, offBootSector, pErrInfo); + if (RT_SUCCESS(rc)) + *phVfs = hVfs; + else + RTVfsRelease(hVfs); + } + else + RTVfsFileRelease(hVfsFileIn); + return rc; +} + + + + +/** + * Fills a range in the file with zeros in the most efficient manner. + * + * @returns IPRT status code. + * @param hVfsFile The file to write to. + * @param off Where to start filling with zeros. + * @param cbZeros How many zero blocks to write. + */ +static int rtFsFatVolWriteZeros(RTVFSFILE hVfsFile, uint64_t off, uint32_t cbZeros) +{ + while (cbZeros > 0) + { + uint32_t cbToWrite = sizeof(g_abRTZero64K); + if (cbToWrite > cbZeros) + cbToWrite = cbZeros; + int rc = RTVfsFileWriteAt(hVfsFile, off, g_abRTZero64K, cbToWrite, NULL); + if (RT_FAILURE(rc)) + return rc; + off += cbToWrite; + cbZeros -= cbToWrite; + } + return VINF_SUCCESS; +} + + +/** + * Formats a FAT volume. + * + * @returns IRPT status code. + * @param hVfsFile The volume file. + * @param offVol The offset into @a hVfsFile of the file. + * Typically 0. + * @param cbVol The size of the volume. Pass 0 if the rest of + * hVfsFile should be used. + * @param fFlags See RTFSFATVOL_FMT_F_XXX. + * @param cbSector The logical sector size. Must be power of two. + * Optional, pass zero to use 512. + * @param cSectorsPerCluster Number of sectors per cluster. Power of two. + * Optional, pass zero to auto detect. + * @param enmFatType The FAT type (12, 16, 32) to use. + * Optional, pass RTFSFATTYPE_INVALID for default. + * @param cHeads The number of heads to report in the BPB. + * Optional, pass zero to auto detect. + * @param cSectorsPerTrack The number of sectors per track to put in the + * BPB. Optional, pass zero to auto detect. + * @param bMedia The media byte value and FAT ID to use. + * Optional, pass zero to auto detect. + * @param cRootDirEntries Number of root directory entries. + * Optional, pass zero to auto detect. + * @param cHiddenSectors Number of hidden sectors. Pass 0 for + * unpartitioned media. + * @param pErrInfo Additional error information, maybe. Optional. + */ +RTDECL(int) RTFsFatVolFormat(RTVFSFILE hVfsFile, uint64_t offVol, uint64_t cbVol, uint32_t fFlags, uint16_t cbSector, + uint16_t cSectorsPerCluster, RTFSFATTYPE enmFatType, uint32_t cHeads, uint32_t cSectorsPerTrack, + uint8_t bMedia, uint16_t cRootDirEntries, uint32_t cHiddenSectors, PRTERRINFO pErrInfo) +{ + int rc; + uint32_t cFats = 2; + + /* + * Validate input. + */ + if (!cbSector) + cbSector = 512; + else + AssertMsgReturn( cbSector == 128 + || cbSector == 512 + || cbSector == 1024 + || cbSector == 4096, + ("cbSector=%#x\n", cbSector), + VERR_INVALID_PARAMETER); + AssertMsgReturn(cSectorsPerCluster == 0 || (cSectorsPerCluster <= 128 && RT_IS_POWER_OF_TWO(cSectorsPerCluster)), + ("cSectorsPerCluster=%#x\n", cSectorsPerCluster), VERR_INVALID_PARAMETER); + if (bMedia != 0) + { + AssertMsgReturn(FAT_ID_IS_VALID(bMedia), ("bMedia=%#x\n", bMedia), VERR_INVALID_PARAMETER); + AssertMsgReturn(FATBPB_MEDIA_IS_VALID(bMedia), ("bMedia=%#x\n", bMedia), VERR_INVALID_PARAMETER); + } + AssertReturn(!(fFlags & ~RTFSFATVOL_FMT_F_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(enmFatType >= RTFSFATTYPE_INVALID && enmFatType < RTFSFATTYPE_END, VERR_INVALID_PARAMETER); + + if (!cbVol) + { + uint64_t cbFile; + rc = RTVfsFileGetSize(hVfsFile, &cbFile); + AssertRCReturn(rc, rc); + AssertMsgReturn(cbFile > offVol, ("cbFile=%#RX64 offVol=%#RX64\n", cbFile, offVol), VERR_INVALID_PARAMETER); + cbVol = cbFile - offVol; + } + uint64_t const cSectorsInVol = cbVol / cbSector; + + /* + * Guess defaults if necessary. + */ + if (!cSectorsPerCluster || !cHeads || !cSectorsPerTrack || !bMedia || !cRootDirEntries) + { + static struct + { + uint64_t cbVol; + uint8_t bMedia; + uint8_t cHeads; + uint8_t cSectorsPerTrack; + uint8_t cSectorsPerCluster; + uint16_t cRootDirEntries; + } s_aDefaults[] = + { + /* cbVol, bMedia, cHeads, cSectorsPTrk, cSectorsPClstr, cRootDirEntries */ + { 163840, 0xfe, /* cyl: 40,*/ 1, 8, 1, 64 }, + { 184320, 0xfc, /* cyl: 40,*/ 1, 9, 2, 64 }, + { 327680, 0xff, /* cyl: 40,*/ 2, 8, 2, 112 }, + { 368640, 0xfd, /* cyl: 40,*/ 2, 9, 2, 112 }, + { 737280, 0xf9, /* cyl: 80,*/ 2, 9, 2, 112 }, + { 1228800, 0xf9, /* cyl: 80,*/ 2, 15, 2, 112 }, + { 1474560, 0xf0, /* cyl: 80,*/ 2, 18, 1, 224 }, + { 2949120, 0xf0, /* cyl: 80,*/ 2, 36, 2, 224 }, + { 528482304, 0xf8, /* cyl: 1024,*/ 16, 63, 0, 512 }, // 504MB limit + { UINT64_C(7927234560), 0xf8, /* cyl: 1024,*/ 240, 63, 0, 512 }, // 7.3GB limit + { UINT64_C(8422686720), 0xf8, /* cyl: 1024,*/ 255, 63, 0, 512 }, // 7.84GB limit + + }; + uint32_t iDefault = 0; + while ( iDefault < RT_ELEMENTS(s_aDefaults) - 1U + && cbVol > s_aDefaults[iDefault].cbVol) + iDefault++; + if (!cHeads) + cHeads = s_aDefaults[iDefault].cHeads; + if (!cSectorsPerTrack) + cSectorsPerTrack = s_aDefaults[iDefault].cSectorsPerTrack; + if (!bMedia) + bMedia = s_aDefaults[iDefault].bMedia; + if (!cRootDirEntries) + cRootDirEntries = s_aDefaults[iDefault].cRootDirEntries; + if (!cSectorsPerCluster) + { + cSectorsPerCluster = s_aDefaults[iDefault].cSectorsPerCluster; + if (!cSectorsPerCluster) + { + uint32_t cbFat12Overhead = cbSector /* boot sector */ + + RT_ALIGN_32(FAT_MAX_FAT12_TOTAL_CLUSTERS * 3 / 2, cbSector) * cFats /* FATs */ + + RT_ALIGN_32(cRootDirEntries * sizeof(FATDIRENTRY), cbSector) /* root dir */; + uint32_t cbFat16Overhead = cbSector /* boot sector */ + + RT_ALIGN_32(FAT_MAX_FAT16_TOTAL_CLUSTERS * 2, cbSector) * cFats /* FATs */ + + RT_ALIGN_32(cRootDirEntries * sizeof(FATDIRENTRY), cbSector) /* root dir */; + + if ( enmFatType == RTFSFATTYPE_FAT12 + || cbVol <= cbFat12Overhead + FAT_MAX_FAT12_DATA_CLUSTERS * 4 * cbSector) + { + enmFatType = RTFSFATTYPE_FAT12; + cSectorsPerCluster = 1; + while ( cSectorsPerCluster < 128 + && cSectorsInVol + > cbFat12Overhead / cbSector + + (uint32_t)cSectorsPerCluster * FAT_MAX_FAT12_DATA_CLUSTERS + + cSectorsPerCluster - 1) + cSectorsPerCluster <<= 1; + } + else if ( enmFatType == RTFSFATTYPE_FAT16 + || cbVol <= cbFat16Overhead + FAT_MAX_FAT16_DATA_CLUSTERS * 128 * cbSector) + { + enmFatType = RTFSFATTYPE_FAT16; + cSectorsPerCluster = 1; + while ( cSectorsPerCluster < 128 + && cSectorsInVol + > cbFat12Overhead / cbSector + + (uint32_t)cSectorsPerCluster * FAT_MAX_FAT16_DATA_CLUSTERS + + cSectorsPerCluster - 1) + cSectorsPerCluster <<= 1; + } + else + { + /* The target here is keeping the FAT size below 8MB. Seems windows + likes a minimum 4KB cluster size as wells as a max of 32KB (googling). */ + enmFatType = RTFSFATTYPE_FAT32; + uint32_t cbFat32Overhead = cbSector * 32 /* boot sector, info sector, boot sector copies, reserved sectors */ + + _8M * cFats; + if (cbSector >= _4K) + cSectorsPerCluster = 1; + else + cSectorsPerCluster = _4K / cbSector; + while ( cSectorsPerCluster < 128 + && cSectorsPerCluster * cbSector < _32K + && cSectorsInVol > cbFat32Overhead / cbSector + (uint64_t)cSectorsPerCluster * _2M) + cSectorsPerCluster <<= 1; + } + } + } + } + Assert(cSectorsPerCluster); + Assert(cRootDirEntries); + uint32_t cbRootDir = RT_ALIGN_32(cRootDirEntries * sizeof(FATDIRENTRY), cbSector); + uint32_t const cbCluster = cSectorsPerCluster * cbSector; + + /* + * If we haven't figured out the FAT type yet, do so. + * The file system code determins the FAT based on cluster counts, + * so we must do so here too. + */ + if (enmFatType == RTFSFATTYPE_INVALID) + { + uint32_t cbFat12Overhead = cbSector /* boot sector */ + + RT_ALIGN_32(FAT_MAX_FAT12_TOTAL_CLUSTERS * 3 / 2, cbSector) * cFats /* FATs */ + + RT_ALIGN_32(cRootDirEntries * sizeof(FATDIRENTRY), cbSector) /* root dir */; + if ( cbVol <= cbFat12Overhead + cbCluster + || (cbVol - cbFat12Overhead) / cbCluster <= FAT_MAX_FAT12_DATA_CLUSTERS) + enmFatType = RTFSFATTYPE_FAT12; + else + { + uint32_t cbFat16Overhead = cbSector /* boot sector */ + + RT_ALIGN_32(FAT_MAX_FAT16_TOTAL_CLUSTERS * 2, cbSector) * cFats /* FATs */ + + cbRootDir; + if ( cbVol <= cbFat16Overhead + cbCluster + || (cbVol - cbFat16Overhead) / cbCluster <= FAT_MAX_FAT16_DATA_CLUSTERS) + enmFatType = RTFSFATTYPE_FAT16; + else + enmFatType = RTFSFATTYPE_FAT32; + } + } + if (enmFatType == RTFSFATTYPE_FAT32) + cbRootDir = cbCluster; + + /* + * Calculate the FAT size and number of data cluster. + * + * Since the FAT size depends on how many data clusters there are, we start + * with a minimum FAT size and maximum clust count, then recalucate it. The + * result isn't necessarily stable, so we will only retry stabalizing the + * result a few times. + */ + uint32_t cbReservedFixed = enmFatType == RTFSFATTYPE_FAT32 ? 32 * cbSector : cbSector + cbRootDir; + uint32_t cbFat = cbSector; + if (cbReservedFixed + cbFat * cFats >= cbVol) + return RTErrInfoSetF(pErrInfo, VERR_DISK_FULL, "volume is too small (cbVol=%#RX64 rsvd=%#x cbFat=%#x cFat=%#x)", + cbVol, cbReservedFixed, cbFat, cFats); + uint32_t cMaxClusters = enmFatType == RTFSFATTYPE_FAT12 ? FAT_MAX_FAT12_DATA_CLUSTERS + : enmFatType == RTFSFATTYPE_FAT16 ? FAT_MAX_FAT16_DATA_CLUSTERS + : FAT_MAX_FAT12_DATA_CLUSTERS; + uint32_t cClusters = (uint32_t)RT_MIN((cbVol - cbReservedFixed - cbFat * cFats) / cbCluster, cMaxClusters); + uint32_t cPrevClusters; + uint32_t cTries = 4; + do + { + cPrevClusters = cClusters; + switch (enmFatType) + { + case RTFSFATTYPE_FAT12: + cbFat = (uint32_t)RT_MIN(FAT_MAX_FAT12_TOTAL_CLUSTERS, cClusters) * 3 / 2; + break; + case RTFSFATTYPE_FAT16: + cbFat = (uint32_t)RT_MIN(FAT_MAX_FAT16_TOTAL_CLUSTERS, cClusters) * 2; + break; + case RTFSFATTYPE_FAT32: + cbFat = (uint32_t)RT_MIN(FAT_MAX_FAT32_TOTAL_CLUSTERS, cClusters) * 4; + cbFat = RT_ALIGN_32(cbFat, _4K); + break; + default: + AssertFailedReturn(VERR_INTERNAL_ERROR_2); + } + cbFat = RT_ALIGN_32(cbFat, cbSector); + if (cbReservedFixed + cbFat * cFats >= cbVol) + return RTErrInfoSetF(pErrInfo, VERR_DISK_FULL, "volume is too small (cbVol=%#RX64 rsvd=%#x cbFat=%#x cFat=%#x)", + cbVol, cbReservedFixed, cbFat, cFats); + cClusters = (uint32_t)RT_MIN((cbVol - cbReservedFixed - cbFat * cFats) / cbCluster, cMaxClusters); + } while ( cClusters != cPrevClusters + && cTries-- > 0); + uint64_t const cTotalSectors = cClusters * (uint64_t)cSectorsPerCluster + (cbReservedFixed + cbFat * cFats) / cbSector; + + /* + * Check that the file system type and cluster count matches up. If they + * don't the type will be misdetected. + * + * Note! These assertions could trigger if the above calculations are wrong. + */ + switch (enmFatType) + { + case RTFSFATTYPE_FAT12: + AssertMsgReturn(cClusters >= FAT_MIN_FAT12_DATA_CLUSTERS && cClusters <= FAT_MAX_FAT12_DATA_CLUSTERS, + ("cClusters=%#x\n", cClusters), VERR_OUT_OF_RANGE); + break; + case RTFSFATTYPE_FAT16: + AssertMsgReturn(cClusters >= FAT_MIN_FAT16_DATA_CLUSTERS && cClusters <= FAT_MAX_FAT16_DATA_CLUSTERS, + ("cClusters=%#x\n", cClusters), VERR_OUT_OF_RANGE); + break; + case RTFSFATTYPE_FAT32: + AssertMsgReturn(cClusters >= FAT_MIN_FAT32_DATA_CLUSTERS && cClusters <= FAT_MAX_FAT32_DATA_CLUSTERS, + ("cClusters=%#x\n", cClusters), VERR_OUT_OF_RANGE); + RT_FALL_THRU(); + default: + AssertFailedReturn(VERR_INTERNAL_ERROR_2); + } + + /* + * Okay, create the boot sector. + */ + size_t cbBuf = RT_MAX(RT_MAX(_64K, cbCluster), cbSector * 2U); + uint8_t *pbBuf = (uint8_t *)RTMemTmpAllocZ(cbBuf); + AssertReturn(pbBuf, VERR_NO_TMP_MEMORY); + + const char *pszLastOp = "boot sector"; + PFATBOOTSECTOR pBootSector = (PFATBOOTSECTOR)pbBuf; + pBootSector->abJmp[0] = 0xeb; + pBootSector->abJmp[1] = RT_UOFFSETOF(FATBOOTSECTOR, Bpb) + + (enmFatType == RTFSFATTYPE_FAT32 ? sizeof(FAT32EBPB) : sizeof(FATEBPB)) - 2; + pBootSector->abJmp[2] = 0x90; + memcpy(pBootSector->achOemName, enmFatType == RTFSFATTYPE_FAT32 ? "FAT32 " : "IPRT 6.2", sizeof(pBootSector->achOemName)); + pBootSector->Bpb.Bpb331.cbSector = (uint16_t)cbSector; + pBootSector->Bpb.Bpb331.cSectorsPerCluster = (uint8_t)cSectorsPerCluster; + pBootSector->Bpb.Bpb331.cReservedSectors = enmFatType == RTFSFATTYPE_FAT32 ? cbReservedFixed / cbSector : 1; + pBootSector->Bpb.Bpb331.cFats = (uint8_t)cFats; + pBootSector->Bpb.Bpb331.cMaxRootDirEntries = enmFatType == RTFSFATTYPE_FAT32 ? 0 : cRootDirEntries; + pBootSector->Bpb.Bpb331.cTotalSectors16 = cTotalSectors <= UINT16_MAX ? (uint16_t)cTotalSectors : 0; + pBootSector->Bpb.Bpb331.bMedia = bMedia; + pBootSector->Bpb.Bpb331.cSectorsPerFat = enmFatType == RTFSFATTYPE_FAT32 ? 0 : cbFat / cbSector; + pBootSector->Bpb.Bpb331.cSectorsPerTrack = cSectorsPerTrack; + pBootSector->Bpb.Bpb331.cTracksPerCylinder = cHeads; + pBootSector->Bpb.Bpb331.cHiddenSectors = cHiddenSectors; + /* XP barfs if both cTotalSectors32 and cTotalSectors16 are set */ + pBootSector->Bpb.Bpb331.cTotalSectors32 = cTotalSectors <= UINT32_MAX && pBootSector->Bpb.Bpb331.cTotalSectors16 == 0 + ? (uint32_t)cTotalSectors : 0; + if (enmFatType != RTFSFATTYPE_FAT32) + { + pBootSector->Bpb.Ebpb.bInt13Drive = 0; + pBootSector->Bpb.Ebpb.bReserved = 0; + pBootSector->Bpb.Ebpb.bExtSignature = FATEBPB_SIGNATURE; + pBootSector->Bpb.Ebpb.uSerialNumber = RTRandU32(); + memset(pBootSector->Bpb.Ebpb.achLabel, ' ', sizeof(pBootSector->Bpb.Ebpb.achLabel)); + memcpy(pBootSector->Bpb.Ebpb.achType, enmFatType == RTFSFATTYPE_FAT12 ? "FAT12 " : "FAT16 ", + sizeof(pBootSector->Bpb.Ebpb.achType)); + } + else + { + pBootSector->Bpb.Fat32Ebpb.cSectorsPerFat32 = cbFat / cbSector; + pBootSector->Bpb.Fat32Ebpb.fFlags = 0; + pBootSector->Bpb.Fat32Ebpb.uVersion = FAT32EBPB_VERSION_0_0; + pBootSector->Bpb.Fat32Ebpb.uRootDirCluster = FAT_FIRST_DATA_CLUSTER; + pBootSector->Bpb.Fat32Ebpb.uInfoSectorNo = 1; + pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo = 6; + RT_ZERO(pBootSector->Bpb.Fat32Ebpb.abReserved); + + pBootSector->Bpb.Fat32Ebpb.bInt13Drive = 0; + pBootSector->Bpb.Fat32Ebpb.bReserved = 0; + pBootSector->Bpb.Fat32Ebpb.bExtSignature = FATEBPB_SIGNATURE; + pBootSector->Bpb.Fat32Ebpb.uSerialNumber = RTRandU32(); + memset(pBootSector->Bpb.Fat32Ebpb.achLabel, ' ', sizeof(pBootSector->Bpb.Fat32Ebpb.achLabel)); + if (cTotalSectors > UINT32_MAX) + pBootSector->Bpb.Fat32Ebpb.u.cTotalSectors64 = cTotalSectors; + else + memcpy(pBootSector->Bpb.Fat32Ebpb.u.achType, "FAT32 ", sizeof(pBootSector->Bpb.Fat32Ebpb.u.achType)); + } + pbBuf[pBootSector->abJmp[1] + 2 + 0] = 0xcd; /* int 19h */ + pbBuf[pBootSector->abJmp[1] + 2 + 1] = 0x19; + pbBuf[pBootSector->abJmp[1] + 2 + 2] = 0xcc; /* int3 */ + pbBuf[pBootSector->abJmp[1] + 2 + 3] = 0xcc; + + pBootSector->uSignature = FATBOOTSECTOR_SIGNATURE; + if (cbSector != sizeof(*pBootSector)) + *(uint16_t *)&pbBuf[cbSector - 2] = FATBOOTSECTOR_SIGNATURE; /** @todo figure out how disks with non-512 byte sectors work! */ + + rc = RTVfsFileWriteAt(hVfsFile, offVol, pBootSector, cbSector, NULL); + uint32_t const offFirstFat = pBootSector->Bpb.Bpb331.cReservedSectors * cbSector; + + /* + * Write the FAT32 info sector, 3 boot sector copies, and zero fill + * the other reserved sectors. + */ + if (RT_SUCCESS(rc) && enmFatType == RTFSFATTYPE_FAT32) + { + pszLastOp = "fat32 info sector"; + PFAT32INFOSECTOR pInfoSector = (PFAT32INFOSECTOR)&pbBuf[cbSector]; /* preserve the boot sector. */ + RT_ZERO(*pInfoSector); + pInfoSector->uSignature1 = FAT32INFOSECTOR_SIGNATURE_1; + pInfoSector->uSignature2 = FAT32INFOSECTOR_SIGNATURE_2; + pInfoSector->uSignature3 = FAT32INFOSECTOR_SIGNATURE_3; + pInfoSector->cFreeClusters = cClusters - 1; /* ASSUMES 1 cluster for the root dir. */ + pInfoSector->cLastAllocatedCluster = FAT_FIRST_DATA_CLUSTER; + rc = RTVfsFileWriteAt(hVfsFile, offVol + cbSector, pInfoSector, cbSector, NULL); + + uint32_t iSector = 2; + if (RT_SUCCESS(rc)) + { + pszLastOp = "fat32 unused reserved sectors"; + rc = rtFsFatVolWriteZeros(hVfsFile, offVol + iSector * cbSector, + (pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo - iSector) * cbSector); + iSector = pBootSector->Bpb.Fat32Ebpb.uBootSectorCopySectorNo; + } + + if (RT_SUCCESS(rc)) + { + pszLastOp = "boot sector copy"; + for (uint32_t i = 0; i < 3 && RT_SUCCESS(rc); i++, iSector++) + rc = RTVfsFileWriteAt(hVfsFile, offVol + iSector * cbSector, pBootSector, cbSector, NULL); + } + + if (RT_SUCCESS(rc)) + { + pszLastOp = "fat32 unused reserved sectors"; + rc = rtFsFatVolWriteZeros(hVfsFile, offVol + iSector * cbSector, + (pBootSector->Bpb.Bpb331.cReservedSectors - iSector) * cbSector); + } + } + + /* + * The FATs. + */ + if (RT_SUCCESS(rc)) + { + pszLastOp = "fat"; + pBootSector = NULL; /* invalid */ + RT_BZERO(pbBuf, cbSector); + switch (enmFatType) + { + case RTFSFATTYPE_FAT32: + pbBuf[11] = 0x0f; /* EOC for root dir*/ + pbBuf[10] = 0xff; + pbBuf[9] = 0xff; + pbBuf[8] = 0xff; + pbBuf[7] = 0x0f; /* Formatter's EOC, followed by signed extend FAT ID. */ + pbBuf[6] = 0xff; + pbBuf[5] = 0xff; + pbBuf[4] = 0xff; + RT_FALL_THRU(); + case RTFSFATTYPE_FAT16: + pbBuf[3] = 0xff; + RT_FALL_THRU(); + case RTFSFATTYPE_FAT12: + pbBuf[2] = 0xff; + pbBuf[1] = 0xff; + pbBuf[0] = bMedia; /* FAT ID */ + break; + default: AssertFailed(); + } + for (uint32_t iFatCopy = 0; iFatCopy < cFats && RT_SUCCESS(rc); iFatCopy++) + { + rc = RTVfsFileWriteAt(hVfsFile, offVol + offFirstFat + cbFat * iFatCopy, pbBuf, cbSector, NULL); + if (RT_SUCCESS(rc) && cbFat > cbSector) + rc = rtFsFatVolWriteZeros(hVfsFile, offVol + offFirstFat + cbFat * iFatCopy + cbSector, cbFat - cbSector); + } + } + + /* + * The root directory. + */ + if (RT_SUCCESS(rc)) + { + /** @todo any mandatory directory entries we need to fill in here? */ + pszLastOp = "root dir"; + rc = rtFsFatVolWriteZeros(hVfsFile, offVol + offFirstFat + cbFat * cFats, cbRootDir); + } + + /* + * If long format, fill the rest of the disk with 0xf6. + */ + AssertCompile(RTFSFATVOL_FMT_F_QUICK != 0); + if (RT_SUCCESS(rc) && !(fFlags & RTFSFATVOL_FMT_F_QUICK)) + { + pszLastOp = "formatting data clusters"; + uint64_t offCur = offFirstFat + cbFat * cFats + cbRootDir; + uint64_t cbLeft = cTotalSectors * cbSector; + if (cbVol - cbLeft <= _256K) /* HACK ALERT! Format to end of volume if it's a cluster rounding thing. */ + cbLeft = cbVol; + if (cbLeft > offCur) + { + cbLeft -= offCur; + offCur += offVol; + + memset(pbBuf, 0xf6, cbBuf); + while (cbLeft > 0) + { + size_t cbToWrite = cbLeft >= cbBuf ? cbBuf : (size_t)cbLeft; + rc = RTVfsFileWriteAt(hVfsFile, offCur, pbBuf, cbToWrite, NULL); + if (RT_SUCCESS(rc)) + { + offCur += cbToWrite; + cbLeft -= cbToWrite; + } + else + break; + } + } + } + + /* + * Done. + */ + RTMemTmpFree(pbBuf); + if (RT_SUCCESS(rc)) + return rc; + return RTErrInfoSet(pErrInfo, rc, pszLastOp); +} + + +/** + * Formats a 1.44MB floppy image. + * + * @returns IPRT status code. + * @param hVfsFile The image. + */ +RTDECL(int) RTFsFatVolFormat144(RTVFSFILE hVfsFile, bool fQuick) +{ + return RTFsFatVolFormat(hVfsFile, 0 /*offVol*/, 1474560, fQuick ? RTFSFATVOL_FMT_F_QUICK : RTFSFATVOL_FMT_F_FULL, + 512 /*cbSector*/, 1 /*cSectorsPerCluster*/, RTFSFATTYPE_FAT12, 2 /*cHeads*/, 18 /*cSectors*/, + 0xf0 /*bMedia*/, 224 /*cRootDirEntries*/, 0 /*cHiddenSectors*/, NULL /*pErrInfo*/); +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate} + */ +static DECLCALLBACK(int) rtVfsChainFatVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec, + PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg); + + /* + * Basic checks. + */ + if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE) + return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE; + if ( pElement->enmType != RTVFSOBJTYPE_VFS + && pElement->enmType != RTVFSOBJTYPE_DIR) + return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS; + if (pElement->cArgs > 1) + return VERR_VFS_CHAIN_AT_MOST_ONE_ARG; + + /* + * Parse the flag if present, save in pElement->uProvider. + */ + bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ; + if (pElement->cArgs > 0) + { + const char *psz = pElement->paArgs[0].psz; + if (*psz) + { + if (!strcmp(psz, "ro")) + fReadOnly = true; + else if (!strcmp(psz, "rw")) + fReadOnly = false; + else + { + *poffError = pElement->paArgs[0].offSpec; + return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument"); + } + } + } + + pElement->uProvider = fReadOnly; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate} + */ +static DECLCALLBACK(int) rtVfsChainFatVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec, + PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj, + PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec, poffError); + + int rc; + RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj); + if (hVfsFileIn != NIL_RTVFSFILE) + { + RTVFS hVfs; + rc = RTFsFatVolOpen(hVfsFileIn, pElement->uProvider != false, 0, &hVfs, pErrInfo); + RTVfsFileRelease(hVfsFileIn); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromVfs(hVfs); + RTVfsRelease(hVfs); + if (*phVfsObj != NIL_RTVFSOBJ) + return VINF_SUCCESS; + rc = VERR_VFS_CHAIN_CAST_FAILED; + } + } + else + rc = VERR_VFS_CHAIN_CAST_FAILED; + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement} + */ +static DECLCALLBACK(bool) rtVfsChainFatVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg, + PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement, + PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement) +{ + RT_NOREF(pProviderReg, pSpec, pReuseSpec); + if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider + || !pReuseElement->paArgs[0].uProvider) + return true; + return false; +} + + +/** VFS chain element 'file'. */ +static RTVFSCHAINELEMENTREG g_rtVfsChainFatVolReg = +{ + /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION, + /* fReserved = */ 0, + /* pszName = */ "fat", + /* ListEntry = */ { NULL, NULL }, + /* pszHelp = */ "Open a FAT file system, requires a file object on the left side.\n" + "First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n", + /* pfnValidate = */ rtVfsChainFatVol_Validate, + /* pfnInstantiate = */ rtVfsChainFatVol_Instantiate, + /* pfnCanReuseElement = */ rtVfsChainFatVol_CanReuseElement, + /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION +}; + +RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainFatVolReg, rtVfsChainFatVolReg); + diff --git a/src/VBox/Runtime/common/fs/isomaker.cpp b/src/VBox/Runtime/common/fs/isomaker.cpp new file mode 100644 index 00000000..8c75381d --- /dev/null +++ b/src/VBox/Runtime/common/fs/isomaker.cpp @@ -0,0 +1,7438 @@ +/* $Id: isomaker.cpp $ */ +/** @file + * IPRT - ISO Image Maker. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include "internal/iprt.h" +#include <iprt/fsisomaker.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/buildconfig.h> +#include <iprt/err.h> +#include <iprt/ctype.h> +#include <iprt/md5.h> +#include <iprt/file.h> +#include <iprt/list.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/path.h> +#include <iprt/string.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/zero.h> +#include <iprt/formats/iso9660.h> + +#include <internal/magics.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Asserts valid handle, returns @a a_rcRet if not. */ +#define RTFSISOMAKER_ASSERT_VALID_HANDLE_RET_EX(a_pThis, a_rcRet) \ + do { AssertPtrReturn(a_pThis, a_rcRet); \ + AssertReturn((a_pThis)->uMagic == RTFSISOMAKERINT_MAGIC, a_rcRet); \ + } while (0) + +/** Asserts valid handle, returns VERR_INVALID_HANDLE if not. */ +#define RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(a_pThis) RTFSISOMAKER_ASSERT_VALID_HANDLE_RET_EX(a_pThis, VERR_INVALID_HANDLE) + +/** The sector size. */ +#define RTFSISOMAKER_SECTOR_SIZE _2K +/** The sector offset mask. */ +#define RTFSISOMAKER_SECTOR_OFFSET_MASK (_2K - 1) +/** Maximum number of objects. */ +#define RTFSISOMAKER_MAX_OBJECTS _16M +/** Maximum number of objects per directory. */ +#define RTFSISOMAKER_MAX_OBJECTS_PER_DIR _256K /**< @todo check limit */ + +/** Number of bytes to store per dir record when using multiple extents. */ +#define RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE UINT32_C(0xfffff800) + +/** UTF-8 name buffer. */ +#define RTFSISOMAKER_MAX_NAME_BUF 768 + +/** Max symbolic link target length. */ +#define RTFSISOMAKER_MAX_SYMLINK_TARGET_LEN 260 + +/** TRANS.TBL left padding length. + * We keep the amount of padding low to avoid wasing memory when generating + * these long obsolete files. */ +#define RTFSISOMAKER_TRANS_TBL_LEFT_PAD 12 + +/** Tests if @a a_ch is in the set of d-characters. */ +#define RTFSISOMAKER_IS_IN_D_CHARS(a_ch) (RT_C_IS_UPPER(a_ch) || RT_C_IS_DIGIT(a_ch) || (a_ch) == '_') + +/** Tests if @a a_ch is in the set of d-characters when uppercased. */ +#define RTFSISOMAKER_IS_UPPER_IN_D_CHARS(a_ch) (RT_C_IS_ALNUM(a_ch) || (a_ch) == '_') + + +/** Calculates the path table record size given the name length. + * @note The root directory length is 1 (name byte is 0x00), we make sure this + * is the case in rtFsIsoMakerNormalizeNameForNamespace. */ +#define RTFSISOMAKER_CALC_PATHREC_SIZE(a_cbNameInDirRec) \ + ( RT_UOFFSETOF_DYN(ISO9660PATHREC, achDirId[(a_cbNameInDirRec) + ((a_cbNameInDirRec) & 1)]) ) + + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to an ISO maker object name space node. */ +typedef struct RTFSISOMAKERNAME *PRTFSISOMAKERNAME; +/** Pointer to a const ISO maker object name space node. */ +typedef struct RTFSISOMAKERNAME const *PCRTFSISOMAKERNAME; +/** Pointer to an ISO maker object name space node pointer. */ +typedef PRTFSISOMAKERNAME *PPRTFSISOMAKERNAME; + +/** Pointer to a common ISO image maker file system object. */ +typedef struct RTFSISOMAKEROBJ *PRTFSISOMAKEROBJ; +/** Pointer to a const common ISO image maker file system object. */ +typedef struct RTFSISOMAKEROBJ const *PCRTFSISOMAKEROBJ; + +/** Pointer to a ISO maker file object. */ +typedef struct RTFSISOMAKERFILE *PRTFSISOMAKERFILE; +/** Pointer to a const ISO maker file object. */ +typedef struct RTFSISOMAKERFILE const *PCRTFSISOMAKERFILE; + +/** + * Filesystem object type. + */ +typedef enum RTFSISOMAKEROBJTYPE +{ + RTFSISOMAKEROBJTYPE_INVALID = 0, + RTFSISOMAKEROBJTYPE_DIR, + RTFSISOMAKEROBJTYPE_FILE, + RTFSISOMAKEROBJTYPE_SYMLINK, + RTFSISOMAKEROBJTYPE_END +} RTFSISOMAKEROBJTYPE; + +/** + * Extra name space information required for directories. + */ +typedef struct RTFSISOMAKERNAMEDIR +{ + /** The location of the directory data. */ + uint64_t offDir; + /** The size of the directory. */ + uint32_t cbDir; + /** Number of children. */ + uint32_t cChildren; + /** Sorted array of children. */ + PPRTFSISOMAKERNAME papChildren; + /** The translate table file. */ + PRTFSISOMAKERFILE pTransTblFile; + + /** The offset in the path table (ISO-9660). + * This is set when finalizing the image. */ + uint32_t offPathTable; + /** The path table identifier of this directory (ISO-9660). + * This is set when finalizing the image. */ + uint16_t idPathTable; + /** The size of the first directory record (0x00 - '.'). */ + uint8_t cbDirRec00; + /** The size of the second directory record (0x01 - '..'). */ + uint8_t cbDirRec01; + /** Pointer to back to the namespace node this belongs to (for the finalized + * entry list). */ + PRTFSISOMAKERNAME pName; + /** Entry in the list of finalized directories. */ + RTLISTNODE FinalizedEntry; +} RTFSISOMAKERNAMEDIR; +/** Pointer to directory specfic namespace node info. */ +typedef RTFSISOMAKERNAMEDIR *PRTFSISOMAKERNAMEDIR; +/** Pointer to const directory specfic namespace node info. */ +typedef const RTFSISOMAKERNAMEDIR *PCRTFSISOMAKERNAMEDIR; + + +/** + * ISO maker object namespace node. + */ +typedef struct RTFSISOMAKERNAME +{ + /** Pointer to the file system object. */ + PRTFSISOMAKEROBJ pObj; + /** Pointer to the partent directory, NULL if root dir. */ + PRTFSISOMAKERNAME pParent; + + /** Pointer to the directory information if this is a directory, NULL if not a + * directory. This is allocated together with this structure, so it doesn't need + * freeing. */ + PRTFSISOMAKERNAMEDIR pDir; + + /** The name specified when creating this namespace node. Helps navigating + * the namespace when we mangle or otherwise change the names. + * Allocated together with of this structure, no spearate free necessary. */ + const char *pszSpecNm; + + /** Alternative rock ridge name. */ + char *pszRockRidgeNm; + /** Alternative TRANS.TBL name. */ + char *pszTransNm; + /** Length of pszSpecNm. */ + uint16_t cchSpecNm; + /** Length of pszRockRidgeNm. */ + uint16_t cchRockRidgeNm; + /** Length of pszTransNm. */ + uint16_t cchTransNm; + + /** The depth in the namespace tree of this name. */ + uint8_t uDepth; + /** Set if pszTransNm is allocated separately. Normally same as pszSpecNm. */ + bool fRockRidgeNmAlloced : 1; + /** Set if pszTransNm is allocated separately. Normally same as pszSpecNm. */ + bool fTransNmAlloced : 1; + /** Set if we need to emit an ER entry (root only). */ + bool fRockNeedER : 1; + /** Set if we need to emit a RR entry in the directory record. */ + bool fRockNeedRRInDirRec : 1; + /** Set if we need to emit a RR entry in the spill file. */ + bool fRockNeedRRInSpill : 1; + + /** The mode mask. + * Starts out as a copy of RTFSISOMAKEROBJ::fMode. */ + RTFMODE fMode; + /** The owner ID. + * Starts out as a copy of RTFSISOMAKEROBJ::uid. */ + RTUID uid; + /** The group ID. + * Starts out as a copy of RTFSISOMAKEROBJ::gid. */ + RTGID gid; + /** The device number if a character or block device. + * This is for Rock Ridge. */ + RTDEV Device; + /** The number of hardlinks to report in the file stats. + * This is for Rock Ridge. */ + uint32_t cHardlinks; + + /** The offset of the directory entry in the parent directory. */ + uint32_t offDirRec; + /** Size of the directory record (ISO-9660). + * This is set when the image is being finalized. */ + uint16_t cbDirRec; + /** Number of directory records needed to cover the entire file size. */ + uint16_t cDirRecs; + /** The total directory record size (cbDirRec * cDirRecs), including end of + * sector zero padding. */ + uint16_t cbDirRecTotal; + + /** Rock ridge flags (ISO9660RRIP_RR_F_XXX). */ + uint8_t fRockEntries; + /** Number of rock ridge data bytes in the directory record. Unaligned! */ + uint8_t cbRockInDirRec; + /** Rock ridge spill file data offset, UINT32_MAX if placed in dir record. */ + uint32_t offRockSpill; + /** Size of rock data in spill file. */ + uint16_t cbRockSpill; + + /** The number of bytes the name requires in the directory record. */ + uint16_t cbNameInDirRec; + /** The name length. */ + uint16_t cchName; + /** The name. */ + char szName[RT_FLEXIBLE_ARRAY]; +} RTFSISOMAKERNAME; + +/** + * A ISO maker namespace. + */ +typedef struct RTFSISOMAKERNAMESPACE +{ + /** The namespace root. */ + PRTFSISOMAKERNAME pRoot; + /** Total number of name nodes in the namespace. */ + uint32_t cNames; + /** Total number of directories in the namespace. */ + uint32_t cDirs; + /** The namespace selector (RTFSISOMAKER_NAMESPACE_XXX). */ + uint32_t fNamespace; + /** Offset into RTFSISOMAKERNAMESPACE of the name member. */ + uint32_t offName; + /** The configuration level for this name space. + * - For UDF and HFS namespaces this is either @c true or @c false. + * - For the primary ISO-9660 namespace this is 1, 2, or 3. + * - For the joliet namespace this 0 (joliet disabled), 1, 2, or 3. */ + uint8_t uLevel; + /** The rock ridge level: 1 - enabled; 2 - with ER tag. + * Linux behaves a little different when seeing the ER tag. */ + uint8_t uRockRidgeLevel; + /** The TRANS.TBL filename if enabled, NULL if disabled. + * When not NULL, this may be pointing to heap or g_szTransTbl. */ + char *pszTransTbl; + /** The system ID (ISO9660PRIMARYVOLDESC::achSystemId). Empty if NULL. + * When not NULL, this may be pointing to heap of g_szSystemId. */ + char *pszSystemId; + /** The volume ID / label (ISO9660PRIMARYVOLDESC::achVolumeId). + * A string representation of RTFSISOMAKERINT::ImageCreationTime if NULL. */ + char *pszVolumeId; + /** The volume set ID (ISO9660PRIMARYVOLDESC::achVolumeSetId). Empty if NULL. */ + char *pszVolumeSetId; + /** The publisher ID or (root) file reference (ISO9660PRIMARYVOLDESC::achPublisherId). Empty if NULL. */ + char *pszPublisherId; + /* The data preperer ID or (root) file reference (ISO9660PRIMARYVOLDESC::achDataPreparerId). Empty if NULL. */ + char *pszDataPreparerId; + /* The application ID or (root) file reference (ISO9660PRIMARYVOLDESC::achApplicationId). + * Defaults to g_szAppIdPrimaryIso or g_szAppIdJoliet. */ + char *pszApplicationId; + /** The copyright (root) file identifier (ISO9660PRIMARYVOLDESC::achCopyrightFileId). None if NULL. */ + char *pszCopyrightFileId; + /** The abstract (root) file identifier (ISO9660PRIMARYVOLDESC::achAbstractFileId). None if NULL. */ + char *pszAbstractFileId; + /** The bibliographic (root) file identifier (ISO9660PRIMARYVOLDESC::achBibliographicFileId). None if NULL. */ + char *pszBibliographicFileId; +} RTFSISOMAKERNAMESPACE; +/** Pointer to a namespace. */ +typedef RTFSISOMAKERNAMESPACE *PRTFSISOMAKERNAMESPACE; +/** Pointer to a const namespace. */ +typedef RTFSISOMAKERNAMESPACE const *PCRTFSISOMAKERNAMESPACE; + + +/** + * Common base structure for the file system objects. + * + * The times are shared across all namespaces, while the uid, gid and mode are + * duplicates in each namespace. + */ +typedef struct RTFSISOMAKEROBJ +{ + /** The linear list entry of the image content. */ + RTLISTNODE Entry; + /** The object index. */ + uint32_t idxObj; + /** The type of this object. */ + RTFSISOMAKEROBJTYPE enmType; + + /** The primary ISO-9660 name space name. */ + PRTFSISOMAKERNAME pPrimaryName; + /** The joliet name space name. */ + PRTFSISOMAKERNAME pJolietName; + /** The UDF name space name. */ + PRTFSISOMAKERNAME pUdfName; + /** The HFS name space name. */ + PRTFSISOMAKERNAME pHfsName; + + /** Birth (creation) time. */ + RTTIMESPEC BirthTime; + /** Attribute change time. */ + RTTIMESPEC ChangeTime; + /** Modification time. */ + RTTIMESPEC ModificationTime; + /** Accessed time. */ + RTTIMESPEC AccessedTime; + + /** Owner ID. */ + RTUID uid; + /** Group ID. */ + RTGID gid; + /** Attributes (unix permissions bits mainly). */ + RTFMODE fMode; + + /** Used to make sure things like the boot catalog stays in the image even if + * it's not mapped into any of the namespaces. */ + uint32_t cNotOrphan; +} RTFSISOMAKEROBJ; + + +/** + * File source type. + */ +typedef enum RTFSISOMAKERSRCTYPE +{ + RTFSISOMAKERSRCTYPE_INVALID = 0, + RTFSISOMAKERSRCTYPE_PATH, + RTFSISOMAKERSRCTYPE_VFS_FILE, + RTFSISOMAKERSRCTYPE_COMMON, + RTFSISOMAKERSRCTYPE_TRANS_TBL, + RTFSISOMAKERSRCTYPE_RR_SPILL, + RTFSISOMAKERSRCTYPE_END +} RTFSISOMAKERSRCTYPE; + +/** + * ISO maker file object. + */ +typedef struct RTFSISOMAKERFILE +{ + /** The common bit. */ + RTFSISOMAKEROBJ Core; + /** The file data size. */ + uint64_t cbData; + /** Byte offset of the data in the image. + * UINT64_MAX until the location is finalized. */ + uint64_t offData; + + /** The type of source object. */ + RTFSISOMAKERSRCTYPE enmSrcType; + /** The source data. */ + union + { + /** Path to the source file. + * Allocated together with this structure. */ + const char *pszSrcPath; + /** Source VFS file. */ + RTVFSFILE hVfsFile; + /** Source is a part of a common VFS file. */ + struct + { + /** The offset into the file */ + uint64_t offData; + /** The index of the common file. */ + uint32_t idxSrc; + } Common; + /** The directory the translation table belongs to. */ + PRTFSISOMAKERNAME pTransTblDir; + /** The namespace for a rock ridge spill file.. */ + PRTFSISOMAKERNAMESPACE pRockSpillNamespace; + } u; + + /** Boot info table to patch into the file. + * This is calculated during file finalization as it needs the file location. */ + PISO9660SYSLINUXINFOTABLE pBootInfoTable; + + /** Entry in the list of finalized directories. */ + RTLISTNODE FinalizedEntry; +} RTFSISOMAKERFILE; + + +/** + * ISO maker directory object. + * + * Unlike files, the allocation info is name space specific and lives in the + * corresponding RTFSISOMAKERNAMEDIR structures. + */ +typedef struct RTFSISOMAKERDIR +{ + /** The common bit. */ + RTFSISOMAKEROBJ Core; +} RTFSISOMAKERDIR; +/** Pointer to an ISO maker directory object. */ +typedef RTFSISOMAKERDIR *PRTFSISOMAKERDIR; + + +/** + * ISO maker symlink object. + */ +typedef struct RTFSISOMAKERSYMLINK +{ + /** The common bit. */ + RTFSISOMAKEROBJ Core; + /** The size of the rock ridge 'SL' records for this link. */ + uint16_t cbSlRockRidge; + /** The symbolic link target length. */ + uint16_t cchTarget; + /** The symbolic link target. */ + char szTarget[RT_FLEXIBLE_ARRAY]; +} RTFSISOMAKERSYMLINK; +/** Pointer to an ISO maker directory object. */ +typedef RTFSISOMAKERSYMLINK *PRTFSISOMAKERSYMLINK; +/** Pointer to a const ISO maker directory object. */ +typedef const RTFSISOMAKERSYMLINK *PCRTFSISOMAKERSYMLINK; + + + +/** + * Instance data for a ISO image maker. + */ +typedef struct RTFSISOMAKERINT +{ + /** Magic value (RTFSISOMAKERINT_MAGIC). */ + uint32_t uMagic; + /** Reference counter. */ + uint32_t volatile cRefs; + + /** Set after we've been fed the first bit of content. + * This means that the namespace configuration has been finalized and can no + * longer be changed because it's simply too much work to do adjustments + * after having started to add files. */ + bool fSeenContent; + /** Set once we've finalized the image structures. + * After this no more changes are allowed. */ + bool fFinalized; + + /** The primary ISO-9660 namespace. */ + RTFSISOMAKERNAMESPACE PrimaryIso; + /** The joliet namespace. */ + RTFSISOMAKERNAMESPACE Joliet; + /** The UDF namespace. */ + RTFSISOMAKERNAMESPACE Udf; + /** The hybrid HFS+ namespace. */ + RTFSISOMAKERNAMESPACE Hfs; + + /** The list of objects (RTFSISOMAKEROBJ). */ + RTLISTANCHOR ObjectHead; + /** Number of objects in the image (ObjectHead). + * This is used to number them, i.e. create RTFSISOMAKEROBJ::idxObj. */ + uint32_t cObjects; + + /** Amount of file data. */ + uint64_t cbData; + /** Number of volume descriptors. */ + uint32_t cVolumeDescriptors; + /** The image (trail) padding in bytes. */ + uint32_t cbImagePadding; + + /** The 'now' timestamp we use for the whole image. + * This way we'll save lots of RTTimeNow calls and have similar timestamps + * over the whole image. */ + RTTIMESPEC ImageCreationTime; + /** Indicates strict or non-strict attribute handling style. + * See RTFsIsoMakerSetAttributeStyle() for details. */ + bool fStrictAttributeStyle; + /** The default owner ID. */ + RTUID uidDefault; + /** The default group ID. */ + RTGID gidDefault; + /** The default file mode mask. */ + RTFMODE fDefaultFileMode; + /** The default file mode mask. */ + RTFMODE fDefaultDirMode; + + /** Forced file mode mask (permissions only). */ + RTFMODE fForcedFileMode; + /** Set if fForcedFileMode is active. */ + bool fForcedFileModeActive; + /** Set if fForcedDirMode is active. */ + bool fForcedDirModeActive; + /** Forced directory mode mask (permissions only). */ + RTFMODE fForcedDirMode; + + /** Number of common source files. */ + uint32_t cCommonSources; + /** Array of common source file handles. */ + PRTVFSFILE paCommonSources; + + /** @name Boot related stuff + * @{ */ + /** The boot catalog file. */ + PRTFSISOMAKERFILE pBootCatFile; + /** Per boot catalog entry data needed for updating offsets when finalizing. */ + struct + { + /** The type (ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY, + * ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER, + * ISO9660_ELTORITO_HEADER_ID_FINAL_SECTION_HEADER, + * ISO9660_ELTORITO_BOOT_INDICATOR_BOOTABLE or + * ISO9660_ELTORITO_BOOT_INDICATOR_NOT_BOOTABLE). */ + uint8_t bType; + /** Number of entries related to this one. This is zero for unused entries, + * 2 for the validation entry, 2+ for section headers, and 1 for images. */ + uint8_t cEntries; + /** The boot file. */ + PRTFSISOMAKERFILE pBootFile; + } aBootCatEntries[64]; + /** @} */ + + /** @name Finalized image stuff + * @{ */ + /** The finalized image size. */ + uint64_t cbFinalizedImage; + /** System area content (sectors 0 thur 15). This is NULL if the system area + * are all zeros, which is often the case. Hybrid ISOs have an MBR followed by + * a GUID partition table here, helping making the image bootable when + * transfered to a USB stick. */ + uint8_t *pbSysArea; + /** Number of non-zero system area bytes pointed to by pbSysArea. */ + size_t cbSysArea; + + /** Pointer to the buffer holding the volume descriptors. */ + uint8_t *pbVolDescs; + /** Pointer to the primary volume descriptor. */ + PISO9660PRIMARYVOLDESC pPrimaryVolDesc; + /** El Torito volume descriptor. */ + PISO9660BOOTRECORDELTORITO pElToritoDesc; + /** Pointer to the primary volume descriptor. */ + PISO9660SUPVOLDESC pJolietVolDesc; + /** Terminating ISO-9660 volume descriptor. */ + PISO9660VOLDESCHDR pTerminatorVolDesc; + + /** Finalized ISO-9660 directory structures. */ + struct RTFSISOMAKERFINALIZEDDIRS + { + /** The image byte offset of the first directory. */ + uint64_t offDirs; + /** The image byte offset of the little endian path table. + * This always follows offDirs. */ + uint64_t offPathTableL; + /** The image byte offset of the big endian path table. + * This always follows offPathTableL. */ + uint64_t offPathTableM; + /** The size of the path table. */ + uint32_t cbPathTable; + /** List of finalized directories for this namespace. + * The list is in path table order so it can be generated on the fly. The + * directories will be ordered in the same way. */ + RTLISTANCHOR FinalizedDirs; + /** Rock ridge spill file. */ + PRTFSISOMAKERFILE pRRSpillFile; + } + /** The finalized directory data for the primary ISO-9660 namespace. */ + PrimaryIsoDirs, + /** The finalized directory data for the joliet namespace. */ + JolietDirs; + + /** The image byte offset of the first file. */ + uint64_t offFirstFile; + /** Finalized file head (RTFSISOMAKERFILE). + * The list is ordered by disk location. Files are following the + * directories and path tables. */ + RTLISTANCHOR FinalizedFiles; + /** @} */ + +} RTFSISOMAKERINT; +/** Pointer to an ISO maker instance. */ +typedef RTFSISOMAKERINT *PRTFSISOMAKERINT; + +/** Pointer to the data for finalized ISO-9660 (primary / joliet) dirs. */ +typedef struct RTFSISOMAKERINT::RTFSISOMAKERFINALIZEDDIRS *PRTFSISOMAKERFINALIZEDDIRS; + + +/** + * Instance data of an ISO maker output file. + */ +typedef struct RTFSISOMAKEROUTPUTFILE +{ + /** The ISO maker (owns a reference). */ + PRTFSISOMAKERINT pIsoMaker; + /** The current file position. */ + uint64_t offCurPos; + /** Current file hint. */ + PRTFSISOMAKERFILE pFileHint; + /** Source file corresponding to pFileHint. + * This is used when dealing with a RTFSISOMAKERSRCTYPE_VFS_FILE or + * RTFSISOMAKERSRCTYPE_TRANS_TBL file. */ + RTVFSFILE hVfsSrcFile; + /** Current directory hint for the primary ISO namespace. */ + PRTFSISOMAKERNAMEDIR pDirHintPrimaryIso; + /** Current directory hint for the joliet namespace. */ + PRTFSISOMAKERNAMEDIR pDirHintJoliet; + /** Joliet directory child index hint. */ + uint32_t iChildPrimaryIso; + /** Joliet directory child index hint. */ + uint32_t iChildJoliet; +} RTFSISOMAKEROUTPUTFILE; +/** Pointer to the instance data of an ISO maker output file. */ +typedef RTFSISOMAKEROUTPUTFILE *PRTFSISOMAKEROUTPUTFILE; + + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Help for iterating over namespaces. + */ +static const struct +{ + /** The RTFSISOMAKER_NAMESPACE_XXX indicator. */ + uint32_t fNamespace; + /** Offset into RTFSISOMAKERINT of the namespace member. */ + uintptr_t offNamespace; + /** Offset into RTFSISOMAKERNAMESPACE of the name member. */ + uintptr_t offName; + /** Namespace name for debugging purposes. */ + const char *pszName; +} g_aRTFsIsoNamespaces[] = +{ + { RTFSISOMAKER_NAMESPACE_ISO_9660, RT_UOFFSETOF(RTFSISOMAKERINT, PrimaryIso), RT_UOFFSETOF(RTFSISOMAKEROBJ, pPrimaryName), "iso-9660" }, + { RTFSISOMAKER_NAMESPACE_JOLIET, RT_UOFFSETOF(RTFSISOMAKERINT, Joliet), RT_UOFFSETOF(RTFSISOMAKEROBJ, pJolietName), "joliet" }, + { RTFSISOMAKER_NAMESPACE_UDF, RT_UOFFSETOF(RTFSISOMAKERINT, Udf), RT_UOFFSETOF(RTFSISOMAKEROBJ, pUdfName), "udf" }, + { RTFSISOMAKER_NAMESPACE_HFS, RT_UOFFSETOF(RTFSISOMAKERINT, Hfs), RT_UOFFSETOF(RTFSISOMAKEROBJ, pHfsName), "hfs" }, +}; + +/** + * Translates a single namespace flag (RTFSISOMAKER_NAMESPACE_XXX) to an + * index into g_aRTFsIsoNamespaces. + */ +static const uint8_t g_aidxRTFsIsoNamespaceFlagToIdx[] = +{ + /*[0] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[RTFSISOMAKER_NAMESPACE_ISO_9660] = */ 0, + /*[RTFSISOMAKER_NAMESPACE_JOLIET] = */ 1, + /*[3] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[RTFSISOMAKER_NAMESPACE_UDF] = */ 2, + /*[5] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[6] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[7] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[RTFSISOMAKER_NAMESPACE_HFS] = */ 3, + /*[9] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[10] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[11] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[12] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[13] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[14] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), + /*[15] = */ RT_ELEMENTS(g_aRTFsIsoNamespaces), +}; + +/** The default translation table filename. */ +static const char g_szTransTbl[] = "TRANS.TBL"; +/** The default application ID for the primary ISO-9660 volume descriptor. */ +static char g_szAppIdPrimaryIso[64] = ""; +/** The default application ID for the joliet volume descriptor. */ +static char g_szAppIdJoliet[64] = ""; +/** The default system ID the primary ISO-9660 volume descriptor. */ +static char g_szSystemId[64] = ""; + + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtFsIsoMakerObjSetName(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKEROBJ pObj, + PRTFSISOMAKERNAME pParent, const char *pchSpec, size_t cchSpec, PPRTFSISOMAKERNAME ppNewName); +static int rtFsIsoMakerObjUnsetName(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKEROBJ pObj); +static int rtFsIsoMakerAddUnnamedDirWorker(PRTFSISOMAKERINT pThis, PCRTFSOBJINFO pObjInfo, PRTFSISOMAKERDIR *ppDir); +static int rtFsIsoMakerAddUnnamedFileWorker(PRTFSISOMAKERINT pThis, PCRTFSOBJINFO pObjInfo, size_t cbExtra, + PRTFSISOMAKERFILE *ppFile); +static int rtFsIsoMakerObjRemoveWorker(PRTFSISOMAKERINT pThis, PRTFSISOMAKEROBJ pObj); + +static ssize_t rtFsIsoMakerOutFile_RockRidgeGenSL(const char *pszTarget, uint8_t *pbBuf, size_t cbBuf); +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual); + + + +/** + * Creates an ISO maker instance. + * + * @returns IPRT status code. + * @param phIsoMaker Where to return the handle to the new ISO maker. + */ +RTDECL(int) RTFsIsoMakerCreate(PRTFSISOMAKER phIsoMaker) +{ + /* + * Do some integrity checks first. + */ + AssertReturn(g_aRTFsIsoNamespaces[g_aidxRTFsIsoNamespaceFlagToIdx[RTFSISOMAKER_NAMESPACE_ISO_9660]].fNamespace == RTFSISOMAKER_NAMESPACE_ISO_9660, + VERR_ISOMK_IPE_TABLE); + AssertReturn(g_aRTFsIsoNamespaces[g_aidxRTFsIsoNamespaceFlagToIdx[RTFSISOMAKER_NAMESPACE_JOLIET]].fNamespace == RTFSISOMAKER_NAMESPACE_JOLIET, + VERR_ISOMK_IPE_TABLE); + AssertReturn(g_aRTFsIsoNamespaces[g_aidxRTFsIsoNamespaceFlagToIdx[RTFSISOMAKER_NAMESPACE_UDF]].fNamespace == RTFSISOMAKER_NAMESPACE_UDF, + VERR_ISOMK_IPE_TABLE); + AssertReturn(g_aRTFsIsoNamespaces[g_aidxRTFsIsoNamespaceFlagToIdx[RTFSISOMAKER_NAMESPACE_HFS]].fNamespace == RTFSISOMAKER_NAMESPACE_HFS, + VERR_ISOMK_IPE_TABLE); + + if (g_szAppIdPrimaryIso[0] == '\0') + RTStrPrintf(g_szAppIdPrimaryIso, sizeof(g_szAppIdPrimaryIso), "IPRT ISO MAKER V%u.%u.%u R%s", + RTBldCfgVersionMajor(), RTBldCfgVersionMinor(), RTBldCfgVersionBuild(), RTBldCfgRevisionStr()); + if (g_szAppIdJoliet[0] == '\0') + RTStrPrintf(g_szAppIdJoliet, sizeof(g_szAppIdJoliet), + "IPRT ISO Maker v%s r%s", RTBldCfgVersion(), RTBldCfgRevisionStr()); + if (g_szSystemId[0] == '\0') + { + RTStrCopy(g_szSystemId, sizeof(g_szSystemId), RTBldCfgTargetDotArch()); + RTStrToUpper(g_szSystemId); + } + + /* + * Create the instance with defaults. + */ + int rc; + PRTFSISOMAKERINT pThis = (PRTFSISOMAKERINT)RTMemAllocZ(sizeof(*pThis)); + if (pThis) + { + pThis->uMagic = RTFSISOMAKERINT_MAGIC; + pThis->cRefs = 1; + //pThis->fSeenContent = false; + //pThis->fFinalized = false; + + pThis->PrimaryIso.fNamespace = RTFSISOMAKER_NAMESPACE_ISO_9660; + pThis->PrimaryIso.offName = RT_UOFFSETOF(RTFSISOMAKEROBJ, pPrimaryName); + pThis->PrimaryIso.uLevel = 3; /* 30 char names, large files */ + pThis->PrimaryIso.uRockRidgeLevel = 1; + pThis->PrimaryIso.pszTransTbl = (char *)g_szTransTbl; + pThis->PrimaryIso.pszSystemId = g_szSystemId; + //pThis->PrimaryIso.pszVolumeId = NULL; + //pThis->PrimaryIso.pszSetVolumeId = NULL; + //pThis->PrimaryIso.pszPublisherId = NULL; + //pThis->PrimaryIso.pszDataPreparerId = NULL; + pThis->PrimaryIso.pszApplicationId = g_szAppIdPrimaryIso; + //pThis->PrimaryIso.pszCopyrightFileId = NULL; + //pThis->PrimaryIso.pszAbstractFileId = NULL; + //pThis->PrimaryIso.pszBibliographicFileId = NULL; + + pThis->Joliet.fNamespace = RTFSISOMAKER_NAMESPACE_JOLIET; + pThis->Joliet.offName = RT_UOFFSETOF(RTFSISOMAKEROBJ, pJolietName); + pThis->Joliet.uLevel = 3; + //pThis->Joliet.uRockRidgeLevel = 0; + //pThis->Joliet.pszTransTbl = NULL; + //pThis->Joliet.pszSystemId = NULL; + //pThis->Joliet.pszVolumeId = NULL; + //pThis->Joliet.pszSetVolumeId = NULL; + //pThis->Joliet.pszPublisherId = NULL; + //pThis->Joliet.pszDataPreparerId = NULL; + pThis->Joliet.pszApplicationId = g_szAppIdJoliet; + //pThis->Joliet.pszCopyrightFileId = NULL; + //pThis->Joliet.pszAbstractFileId = NULL; + //pThis->Joliet.pszBibliographicFileId = NULL; + + pThis->Udf.fNamespace = RTFSISOMAKER_NAMESPACE_UDF; + pThis->Udf.offName = RT_UOFFSETOF(RTFSISOMAKEROBJ, pUdfName); + //pThis->Udf.uLevel = 0; + //pThis->Udf.uRockRidgeLevel = 0; + //pThis->Udf.pszTransTbl = NULL; + //pThis->Udf.uRockRidgeLevel = 0; + //pThis->Udf.pszTransTbl = NULL; + //pThis->Udf.pszSystemId = NULL; + //pThis->Udf.pszVolumeId = NULL; + //pThis->Udf.pszSetVolumeId = NULL; + //pThis->Udf.pszPublisherId = NULL; + //pThis->Udf.pszDataPreparerId = NULL; + //pThis->Udf.pszApplicationId = NULL; + //pThis->Udf.pszCopyrightFileId = NULL; + //pThis->Udf.pszAbstractFileId = NULL; + //pThis->Udf.pszBibliographicFileId = NULL; + + pThis->Hfs.fNamespace = RTFSISOMAKER_NAMESPACE_HFS; + pThis->Hfs.offName = RT_UOFFSETOF(RTFSISOMAKEROBJ, pHfsName); + //pThis->Hfs.uLevel = 0; + //pThis->Hfs.uRockRidgeLevel = 0; + //pThis->Hfs.pszTransTbl = NULL; + //pThis->Hfs.pszSystemId = NULL; + //pThis->Hfs.pszVolumeId = NULL; + //pThis->Hfs.pszSetVolumeId = NULL; + //pThis->Hfs.pszPublisherId = NULL; + //pThis->Hfs.pszDataPreparerId = NULL; + //pThis->Hfs.pszApplicationId = NULL; + //pThis->Hfs.pszCopyrightFileId = NULL; + //pThis->Hfs.pszAbstractFileId = NULL; + //pThis->Hfs.pszBibliographicFileId = NULL; + + RTListInit(&pThis->ObjectHead); + //pThis->cObjects = 0; + //pThis->cbData = 0; + + pThis->cVolumeDescriptors = 3; /* primary, secondary joliet, terminator. */ + pThis->cbImagePadding = 150 * RTFSISOMAKER_SECTOR_SIZE; + + //pThis->fStrictAttributeStyle = false; + //pThis->uidDefault = 0; + //pThis->gidDefault = 0; + pThis->fDefaultFileMode = 0444 | RTFS_TYPE_FILE | RTFS_DOS_ARCHIVED | RTFS_DOS_READONLY; + pThis->fDefaultDirMode = 0555 | RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_DOS_READONLY; + + //pThis->fForcedFileMode = 0; + //pThis->fForcedFileModeActive = false; + //pThis->fForcedDirModeActive = false; + //pThis->fForcedDirMode = 0; + + //pThis->cCommonSources = 0; + //pThis->paCommonSources = NULL; + + //pThis->pBootCatFile = NULL; + + pThis->cbFinalizedImage = UINT64_MAX; + //pThis->pbSysArea = NULL; + //pThis->cbSysArea = 0; + //pThis->pbVolDescs = NULL; + //pThis->pPrimaryVolDesc = NULL; + //pThis->pElToritoDesc = NULL; + //pThis->pJolietVolDesc = NULL; + + pThis->PrimaryIsoDirs.offDirs = UINT64_MAX; + pThis->PrimaryIsoDirs.offPathTableL = UINT64_MAX; + pThis->PrimaryIsoDirs.offPathTableM = UINT64_MAX; + pThis->PrimaryIsoDirs.cbPathTable = 0; + RTListInit(&pThis->PrimaryIsoDirs.FinalizedDirs); + //pThis->PrimaryIsoDirs.pRRSpillFile = NULL; + + pThis->JolietDirs.offDirs = UINT64_MAX; + pThis->JolietDirs.offPathTableL = UINT64_MAX; + pThis->JolietDirs.offPathTableM = UINT64_MAX; + pThis->JolietDirs.cbPathTable = 0; + RTListInit(&pThis->JolietDirs.FinalizedDirs); + //pThis->JolietDirs.pRRSpillFile = NULL; + + pThis->offFirstFile = UINT64_MAX; + RTListInit(&pThis->FinalizedFiles); + + RTTimeNow(&pThis->ImageCreationTime); + + /* + * Add the root directory node with idObj == 0. + */ + PRTFSISOMAKERDIR pDirRoot; + rc = rtFsIsoMakerAddUnnamedDirWorker(pThis, NULL /*pObjInfo*/, &pDirRoot); + if (RT_SUCCESS(rc)) + { + *phIsoMaker = pThis; + return VINF_SUCCESS; + } + + RTMemFree(pThis); + } + else + rc = VERR_NO_MEMORY; + return rc; +} + + +/** + * Frees an object. + * + * This is a worker for rtFsIsoMakerDestroy and RTFsIsoMakerObjRemove. + * + * @param pObj The object to free. + */ +DECLINLINE(void) rtFsIsoMakerObjDestroy(PRTFSISOMAKEROBJ pObj) +{ + if (pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + switch (pFile->enmSrcType) + { + case RTFSISOMAKERSRCTYPE_PATH: + pFile->u.pszSrcPath = NULL; + break; + + case RTFSISOMAKERSRCTYPE_TRANS_TBL: + pFile->u.pTransTblDir = NULL; + break; + + case RTFSISOMAKERSRCTYPE_VFS_FILE: + RTVfsFileRelease(pFile->u.hVfsFile); + pFile->u.hVfsFile = NIL_RTVFSFILE; + break; + + case RTFSISOMAKERSRCTYPE_COMMON: + case RTFSISOMAKERSRCTYPE_RR_SPILL: + break; + + case RTFSISOMAKERSRCTYPE_INVALID: + case RTFSISOMAKERSRCTYPE_END: + AssertFailed(); + break; + + /* no default, want warnings */ + } + if (pFile->pBootInfoTable) + { + RTMemFree(pFile->pBootInfoTable); + pFile->pBootInfoTable = NULL; + } + } + + RTMemFree(pObj); +} + + +/** + * Frees a namespace node. + * + * This is a worker for rtFsIsoMakerDestroyTree and rtFsIsoMakerObjUnsetName. + * + * @param pName The node to free. + */ +DECLINLINE(void) rtFsIsoMakerDestroyName(PRTFSISOMAKERNAME pName) +{ + if (pName->fRockRidgeNmAlloced) + { + RTMemFree(pName->pszRockRidgeNm); + pName->pszRockRidgeNm = NULL; + } + if (pName->fTransNmAlloced) + { + RTMemFree(pName->pszTransNm); + pName->pszTransNm = NULL; + } + PRTFSISOMAKERNAMEDIR pDir = pName->pDir; + if (pDir != NULL) + { + Assert(pDir->cChildren == 0); + RTMemFree(pDir->papChildren); + pDir->papChildren = NULL; + } + RTMemFree(pName); +} + + +/** + * Destroys a namespace. + * + * @param pNamespace The namespace to destroy. + */ +static void rtFsIsoMakerDestroyTree(PRTFSISOMAKERNAMESPACE pNamespace) +{ + /* + * Recursively destroy the tree first. + */ + PRTFSISOMAKERNAME pCur = pNamespace->pRoot; + if (pCur) + { + Assert(!pCur->pParent); + for (;;) + { + if ( pCur->pDir + && pCur->pDir->cChildren) + pCur = pCur->pDir->papChildren[pCur->pDir->cChildren - 1]; + else + { + PRTFSISOMAKERNAME pNext = pCur->pParent; + rtFsIsoMakerDestroyName(pCur); + + /* Unlink from parent, we're the last entry. */ + if (pNext) + { + Assert(pNext->pDir->cChildren > 0); + pNext->pDir->cChildren--; + Assert(pNext->pDir->papChildren[pNext->pDir->cChildren] == pCur); + pNext->pDir->papChildren[pNext->pDir->cChildren] = NULL; + pCur = pNext; + } + else + { + Assert(pNamespace->pRoot == pCur); + break; + } + } + } + pNamespace->pRoot = NULL; + } + + /* + * Free the translation table filename if allocated. + */ + if (pNamespace->pszTransTbl) + { + if (pNamespace->pszTransTbl != g_szTransTbl) + RTStrFree(pNamespace->pszTransTbl); + pNamespace->pszTransTbl = NULL; + } + + /* + * Free string IDs. + */ + if (pNamespace->pszSystemId) + { + if (pNamespace->pszSystemId != g_szSystemId) + RTStrFree(pNamespace->pszSystemId); + pNamespace->pszSystemId = NULL; + } + + if (pNamespace->pszVolumeId) + { + RTStrFree(pNamespace->pszVolumeId); + pNamespace->pszVolumeId = NULL; + } + + if (pNamespace->pszVolumeSetId) + { + RTStrFree(pNamespace->pszVolumeSetId); + pNamespace->pszVolumeSetId = NULL; + } + + if (pNamespace->pszPublisherId) + { + RTStrFree(pNamespace->pszPublisherId); + pNamespace->pszPublisherId = NULL; + } + + if (pNamespace->pszDataPreparerId) + { + RTStrFree(pNamespace->pszDataPreparerId); + pNamespace->pszDataPreparerId = NULL; + } + + if (pNamespace->pszApplicationId) + { + if ( pNamespace->pszApplicationId != g_szAppIdPrimaryIso + && pNamespace->pszApplicationId != g_szAppIdJoliet) + RTStrFree(pNamespace->pszApplicationId); + pNamespace->pszApplicationId = NULL; + } + + if (pNamespace->pszCopyrightFileId) + { + RTStrFree(pNamespace->pszCopyrightFileId); + pNamespace->pszCopyrightFileId = NULL; + } + + if (pNamespace->pszAbstractFileId) + { + RTStrFree(pNamespace->pszAbstractFileId); + pNamespace->pszAbstractFileId = NULL; + } + + if (pNamespace->pszBibliographicFileId) + { + RTStrFree(pNamespace->pszBibliographicFileId); + pNamespace->pszBibliographicFileId = NULL; + } +} + + +/** + * Destroys an ISO maker instance. + * + * @param pThis The ISO maker instance to destroy. + */ +static void rtFsIsoMakerDestroy(PRTFSISOMAKERINT pThis) +{ + rtFsIsoMakerDestroyTree(&pThis->PrimaryIso); + rtFsIsoMakerDestroyTree(&pThis->Joliet); + rtFsIsoMakerDestroyTree(&pThis->Udf); + rtFsIsoMakerDestroyTree(&pThis->Hfs); + + PRTFSISOMAKEROBJ pCur; + PRTFSISOMAKEROBJ pNext; + RTListForEachSafe(&pThis->ObjectHead, pCur, pNext, RTFSISOMAKEROBJ, Entry) + { + RTListNodeRemove(&pCur->Entry); + rtFsIsoMakerObjDestroy(pCur); + } + + if (pThis->paCommonSources) + { + RTMemFree(pThis->paCommonSources); + pThis->paCommonSources = NULL; + } + + if (pThis->pbVolDescs) + { + RTMemFree(pThis->pbVolDescs); + pThis->pbVolDescs = NULL; + } + + if (pThis->pbSysArea) + { + RTMemFree(pThis->pbSysArea); + pThis->pbSysArea = NULL; + } + + pThis->uMagic = ~RTFSISOMAKERINT_MAGIC; + RTMemFree(pThis); +} + + +/** + * Retains a references to an ISO maker instance. + * + * @returns New reference count on success, UINT32_MAX if invalid handle. + * @param hIsoMaker The ISO maker handle. + */ +RTDECL(uint32_t) RTFsIsoMakerRetain(RTFSISOMAKER hIsoMaker) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + AssertPtrReturn(pThis, UINT32_MAX); + AssertReturn(pThis->uMagic == RTFSISOMAKERINT_MAGIC, UINT32_MAX); + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs > 1); + Assert(cRefs < _64K); + return cRefs; +} + + +/** + * Releases a references to an ISO maker instance. + * + * @returns New reference count on success, UINT32_MAX if invalid handle. + * @param hIsoMaker The ISO maker handle. NIL is ignored. + */ +RTDECL(uint32_t) RTFsIsoMakerRelease(RTFSISOMAKER hIsoMaker) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + uint32_t cRefs; + if (pThis == NIL_RTFSISOMAKER) + cRefs = 0; + else + { + AssertPtrReturn(pThis, UINT32_MAX); + AssertReturn(pThis->uMagic == RTFSISOMAKERINT_MAGIC, UINT32_MAX); + cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < _64K); + if (!cRefs) + rtFsIsoMakerDestroy(pThis); + } + return cRefs; +} + + +/** + * Sets the ISO-9660 level. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param uIsoLevel The level, 1-3. + */ +RTDECL(int) RTFsIsoMakerSetIso9660Level(RTFSISOMAKER hIsoMaker, uint8_t uIsoLevel) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(uIsoLevel <= 3, VERR_INVALID_PARAMETER); + AssertReturn(uIsoLevel > 0, VERR_INVALID_PARAMETER); /* currently not possible to disable this */ + AssertReturn(!pThis->fSeenContent, VERR_WRONG_ORDER); + + pThis->PrimaryIso.uLevel = uIsoLevel; + return VINF_SUCCESS; +} + + +/** + * Gets the ISO-9660 level. + * + * @returns The level, UINT8_MAX if invalid handle. + * @param hIsoMaker The ISO maker handle. + */ +RTDECL(uint8_t) RTFsIsoMakerGetIso9660Level(RTFSISOMAKER hIsoMaker) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET_EX(pThis, UINT8_MAX); + return pThis->PrimaryIso.uLevel; +} + + +/** + * Sets the joliet level. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param uJolietLevel The joliet UCS-2 level 1-3, or 0 to disable + * joliet. + */ +RTDECL(int) RTFsIsoMakerSetJolietUcs2Level(RTFSISOMAKER hIsoMaker, uint8_t uJolietLevel) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(uJolietLevel <= 3, VERR_INVALID_PARAMETER); + AssertReturn(!pThis->fSeenContent, VERR_WRONG_ORDER); + + if (pThis->Joliet.uLevel != uJolietLevel) + { + if (uJolietLevel == 0) + pThis->cVolumeDescriptors--; + else if (pThis->Joliet.uLevel == 0) + pThis->cVolumeDescriptors++; + pThis->Joliet.uLevel = uJolietLevel; + } + return VINF_SUCCESS; +} + + +/** + * Sets the rock ridge support level (on the primary ISO-9660 namespace). + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param uLevel 0 if disabled, 1 to just enable, 2 to enable and + * write the ER tag. + */ +RTDECL(int) RTFsIsoMakerSetRockRidgeLevel(RTFSISOMAKER hIsoMaker, uint8_t uLevel) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(uLevel <= 2, VERR_INVALID_PARAMETER); + AssertReturn( !pThis->fSeenContent + || (uLevel >= pThis->PrimaryIso.uRockRidgeLevel && pThis->PrimaryIso.uRockRidgeLevel > 0), VERR_WRONG_ORDER); + AssertReturn(!pThis->fSeenContent, VERR_WRONG_ORDER); + + pThis->PrimaryIso.uRockRidgeLevel = uLevel; + return VINF_SUCCESS; +} + + +/** + * Sets the rock ridge support level on the joliet namespace (experimental). + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param uLevel 0 if disabled, 1 to just enable, 2 to enable and + * write the ER tag. + */ +RTDECL(int) RTFsIsoMakerSetJolietRockRidgeLevel(RTFSISOMAKER hIsoMaker, uint8_t uLevel) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(uLevel <= 2, VERR_INVALID_PARAMETER); + AssertReturn( !pThis->fSeenContent + || (uLevel >= pThis->Joliet.uRockRidgeLevel && pThis->Joliet.uRockRidgeLevel > 0), VERR_WRONG_ORDER); + + pThis->Joliet.uRockRidgeLevel = uLevel; + return VINF_SUCCESS; +} + + +/** + * Changes the file attribute (mode, owner, group) inherit style (from source). + * + * The strict style will use the exact attributes from the source, where as the + * non-strict (aka rational and default) style will use 0 for the owner and + * group IDs and normalize the mode bits along the lines of 'chmod a=rX', + * stripping set-uid/gid bitson files but preserving sticky ones on directories. + * + * When disabling strict style, the default dir and file modes will be restored + * to default values. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param fStrict Indicates strict (true) or non-strict (false) + * style. + */ +RTDECL(int) RTFsIsoMakerSetAttribInheritStyle(RTFSISOMAKER hIsoMaker, bool fStrict) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + + pThis->fStrictAttributeStyle = fStrict; + if (!fStrict) + { + pThis->fDefaultFileMode = 0444 | RTFS_TYPE_FILE | RTFS_DOS_ARCHIVED | RTFS_DOS_READONLY; + pThis->fDefaultDirMode = 0555 | RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | RTFS_DOS_READONLY; + } + + return VINF_SUCCESS; +} + + +/** + * Sets the default file mode settings. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param fMode The default file mode. + */ +RTDECL(int) RTFsIsoMakerSetDefaultFileMode(RTFSISOMAKER hIsoMaker, RTFMODE fMode) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + Assert(!(fMode & ~RTFS_UNIX_ALL_PERMS)); + + pThis->fDefaultFileMode &= ~RTFS_UNIX_ALL_PERMS; + pThis->fDefaultFileMode |= fMode & RTFS_UNIX_ALL_PERMS; + return VINF_SUCCESS; +} + + +/** + * Sets the default dir mode settings. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param fMode The default dir mode. + */ +RTDECL(int) RTFsIsoMakerSetDefaultDirMode(RTFSISOMAKER hIsoMaker, RTFMODE fMode) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + Assert(!(fMode & ~RTFS_UNIX_ALL_PERMS)); + + pThis->fDefaultDirMode &= ~RTFS_UNIX_ALL_PERMS; + pThis->fDefaultDirMode |= fMode & RTFS_UNIX_ALL_PERMS; + return VINF_SUCCESS; +} + + +/** + * Sets the forced file mode, if @a fForce is true also the default mode is set. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param fMode The file mode. + * @param fForce Indicate whether forced mode is active or not. + */ +RTDECL(int) RTFsIsoMakerSetForcedFileMode(RTFSISOMAKER hIsoMaker, RTFMODE fMode, bool fForce) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + Assert(!(fMode & ~RTFS_UNIX_ALL_PERMS)); + + pThis->fForcedFileMode = fMode & RTFS_UNIX_ALL_PERMS; + pThis->fForcedFileModeActive = fForce; + if (fForce) + { + pThis->fDefaultFileMode &= ~RTFS_UNIX_ALL_PERMS; + pThis->fDefaultFileMode |= fMode & RTFS_UNIX_ALL_PERMS; + } + return VINF_SUCCESS; +} + + +/** + * Sets the forced dir mode, if @a fForce is true also the default mode is set. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param fMode The dir mode. + * @param fForce Indicate whether forced mode is active or not. + */ +RTDECL(int) RTFsIsoMakerSetForcedDirMode(RTFSISOMAKER hIsoMaker, RTFMODE fMode, bool fForce) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + Assert(!(fMode & ~RTFS_UNIX_ALL_PERMS)); + + pThis->fForcedDirModeActive = fForce; + pThis->fForcedDirMode = fMode & RTFS_UNIX_ALL_PERMS; + if (fForce) + { + pThis->fDefaultDirMode &= ~RTFS_UNIX_ALL_PERMS; + pThis->fDefaultDirMode |= fMode & RTFS_UNIX_ALL_PERMS; + } + return VINF_SUCCESS; +} + + +/** + * Sets the content of the system area, i.e. the first 32KB of the image. + * + * This can be used to put generic boot related stuff. + * + * @note Other settings may overwrite parts of the content (yet to be + * determined which). + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pvContent The content to put in the system area. + * @param cbContent The size of the content. + * @param off The offset into the system area. + */ +RTDECL(int) RTFsIsoMakerSetSysAreaContent(RTFSISOMAKER hIsoMaker, void const *pvContent, size_t cbContent, uint32_t off) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + AssertReturn(cbContent > 0, VERR_OUT_OF_RANGE); + AssertReturn(cbContent <= _32K, VERR_OUT_OF_RANGE); + AssertReturn(off < _32K, VERR_OUT_OF_RANGE); + size_t cbSysArea = off + cbContent; + AssertReturn(cbSysArea <= _32K, VERR_OUT_OF_RANGE); + + /* + * Adjust the allocation and copy over the new/additional content. + */ + if (pThis->cbSysArea < cbSysArea) + { + void *pvNew = RTMemRealloc(pThis->pbSysArea, cbSysArea); + AssertReturn(pvNew, VERR_NO_MEMORY); + pThis->pbSysArea = (uint8_t *)pvNew; + memset(&pThis->pbSysArea[pThis->cbSysArea], 0, cbSysArea - pThis->cbSysArea); + } + + memcpy(&pThis->pbSysArea[off], pvContent, cbContent); + + return VINF_SUCCESS; +} + + +/** + * Sets a string property in one or more namespaces. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param enmStringProp The string property to set. + * @param fNamespaces The namespaces to set it in. + * @param pszValue The value to set it to. NULL is treated like an + * empty string. The value will be silently truncated + * to fit the available space. + */ +RTDECL(int) RTFsIsoMakerSetStringProp(RTFSISOMAKER hIsoMaker, RTFSISOMAKERSTRINGPROP enmStringProp, + uint32_t fNamespaces, const char *pszValue) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn( enmStringProp > RTFSISOMAKERSTRINGPROP_INVALID + && enmStringProp < RTFSISOMAKERSTRINGPROP_END, VERR_INVALID_PARAMETER); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + if (pszValue) + { + AssertPtrReturn(pszValue, VERR_INVALID_POINTER); + if (*pszValue == '\0') + pszValue = NULL; + } + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Work the namespaces. + */ + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + /* Get a pointer to the field. */ + char **ppszValue; + switch (enmStringProp) + { + case RTFSISOMAKERSTRINGPROP_SYSTEM_ID: ppszValue = &pNamespace->pszSystemId; break; + case RTFSISOMAKERSTRINGPROP_VOLUME_ID: ppszValue = &pNamespace->pszVolumeId; break; + case RTFSISOMAKERSTRINGPROP_VOLUME_SET_ID: ppszValue = &pNamespace->pszVolumeSetId; break; + case RTFSISOMAKERSTRINGPROP_PUBLISHER_ID: ppszValue = &pNamespace->pszPublisherId; break; + case RTFSISOMAKERSTRINGPROP_DATA_PREPARER_ID: ppszValue = &pNamespace->pszDataPreparerId; break; + case RTFSISOMAKERSTRINGPROP_APPLICATION_ID: ppszValue = &pNamespace->pszApplicationId; break; + case RTFSISOMAKERSTRINGPROP_COPYRIGHT_FILE_ID: ppszValue = &pNamespace->pszCopyrightFileId; break; + case RTFSISOMAKERSTRINGPROP_ABSTRACT_FILE_ID: ppszValue = &pNamespace->pszAbstractFileId; break; + case RTFSISOMAKERSTRINGPROP_BIBLIOGRAPHIC_FILE_ID: ppszValue = &pNamespace->pszBibliographicFileId; break; + default: AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + /* Free the old value. */ + char *pszOld = *ppszValue; + if ( pszOld + && pszOld != g_szAppIdPrimaryIso + && pszOld != g_szAppIdJoliet + && pszOld != g_szSystemId) + RTStrFree(pszOld); + + /* Set the new value. */ + if (!pszValue) + *ppszValue = NULL; + else + { + *ppszValue = RTStrDup(pszValue); + AssertReturn(*ppszValue, VERR_NO_STR_MEMORY); + } + } + } + return VINF_SUCCESS; +} + + +/** + * Specifies image padding. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param cSectors Number of sectors to pad the image with. + */ +RTDECL(int) RTFsIsoMakerSetImagePadding(RTFSISOMAKER hIsoMaker, uint32_t cSectors) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(cSectors <= _64K, VERR_OUT_OF_RANGE); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + pThis->cbImagePadding = cSectors * RTFSISOMAKER_SECTOR_SIZE; + return VINF_SUCCESS; +} + + + + + +/* + * + * Name space related internals. + * Name space related internals. + * Name space related internals. + * + */ + + +/** + * Gets the pointer to the name member for the given namespace. + * + * @returns Pointer to name member. + * @param pObj The object to find a name member in. + * @param pNamespace The namespace which name to calculate. + */ +DECLINLINE(PPRTFSISOMAKERNAME) rtFsIsoMakerObjGetNameForNamespace(PRTFSISOMAKEROBJ pObj, PCRTFSISOMAKERNAMESPACE pNamespace) +{ + return (PPRTFSISOMAKERNAME)((uintptr_t)pObj + pNamespace->offName); +} + + +/** + * Locates a child object by its namespace name. + * + * @returns Pointer to the child if found, NULL if not. + * @param pDirObj The directory object to search. + * @param pszEntry The (namespace) entry name. + * @param cchEntry The length of the name. + */ +static PRTFSISOMAKERNAME rtFsIsoMakerFindObjInDir(PRTFSISOMAKERNAME pDirObj, const char *pszEntry, size_t cchEntry) +{ + if (pDirObj) + { + PRTFSISOMAKERNAMEDIR pDir = pDirObj->pDir; + AssertReturn(pDir, NULL); + + uint32_t i = pDir->cChildren; + while (i-- > 0) + { + PRTFSISOMAKERNAME pChild = pDir->papChildren[i]; + if ( pChild->cchName == cchEntry + && RTStrNICmp(pChild->szName, pszEntry, cchEntry) == 0) + return pChild; + } + } + return NULL; +} + + +/** + * Compares the two names according to ISO-9660 directory sorting rules. + * + * As long as we don't want to do case insensitive joliet sorting, this works + * for joliet names to, I think. + * + * @returns 0 if equal, -1 if pszName1 comes first, 1 if pszName2 comes first. + * @param pszName1 The first name. + * @param pszName2 The second name. + */ +DECLINLINE(int) rtFsIsoMakerCompareIso9660Names(const char *pszName1, const char *pszName2) +{ + for (;;) + { + char const ch1 = *pszName1++; + char const ch2 = *pszName2++; + if (ch1 == ch2) + { + if (ch1) + { /* likely */ } + else + return 0; + } + else if (ch1 == ';' || ch2 == ';') + return ch1 == ';' ? -1 : 1; + else if (ch1 == '.' || ch2 == '.') + return ch1 == '.' ? -1 : 1; + else + return (unsigned char)ch1 < (unsigned char)ch2 ? -1 : 1; + } +} + + +/** + * Finds the index into papChildren where the given name should be inserted. + * + * @returns Index of the given name. + * @param pNamespace The namspace. + * @param pParent The parent namespace node. + * @param pszName The name. + */ +static uint32_t rtFsIsoMakerFindInsertIndex(PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKERNAME pParent, const char *pszName) +{ + uint32_t idxRet = pParent->pDir->cChildren; + if (idxRet > 0) + { + /* + * The idea is to do binary search using a namespace specific compare + * function. However, it looks like we can get away with using the + * same compare function for all namespaces. + */ + uint32_t idxStart = 0; + uint32_t idxEnd = idxRet; + PPRTFSISOMAKERNAME papChildren = pParent->pDir->papChildren; + switch (pNamespace->fNamespace) + { + case RTFSISOMAKER_NAMESPACE_ISO_9660: + case RTFSISOMAKER_NAMESPACE_JOLIET: + case RTFSISOMAKER_NAMESPACE_UDF: + case RTFSISOMAKER_NAMESPACE_HFS: + for (;;) + { + idxRet = idxStart + (idxEnd - idxStart) / 2; + PRTFSISOMAKERNAME pCur = papChildren[idxRet]; + int iDiff = rtFsIsoMakerCompareIso9660Names(pszName, pCur->szName); + if (iDiff < 0) + { + if (idxRet > idxStart) + idxEnd = idxRet; + else + break; + } + else + { + idxRet++; + if ( iDiff != 0 + && idxRet < idxEnd) + idxStart = idxRet; + else + break; + } + } + break; + + default: + AssertFailed(); + break; + } + } + return idxRet; +} + + + +/** + * Locates a child entry by its specified name. + * + * @returns Pointer to the child if found, NULL if not. + * @param pDirName The directory name to search. + * @param pszEntry The (specified) entry name. + * @param cchEntry The length of the name. + */ +static PRTFSISOMAKERNAME rtFsIsoMakerFindEntryInDirBySpec(PRTFSISOMAKERNAME pDirName, const char *pszEntry, size_t cchEntry) +{ + if (pDirName) + { + PRTFSISOMAKERNAMEDIR pDir = pDirName->pDir; + AssertReturn(pDir, NULL); + + uint32_t i = pDir->cChildren; + while (i-- > 0) + { + PRTFSISOMAKERNAME pChild = pDir->papChildren[i]; + if ( pChild->cchSpecNm == cchEntry + && RTStrNICmp(pChild->pszSpecNm, pszEntry, cchEntry) == 0) + return pChild; + } + } + return NULL; +} + + +/** + * Locates a subdir object in any namespace by its specified name. + * + * This is used to avoid having one instance of RTFSISOMAKERDIR in each + * namespace for the same directory. + * + * @returns Pointer to the subdir object if found, NULL if not. + * @param pDirObj The directory object to search. + * @param pszEntry The (specified) entry name. + * @param cchEntry The length of the name. + * @param fSkipNamespaces Namespaces to skip. + * @sa rtFsIsoMakerFindEntryInDirBySpec + */ +static PRTFSISOMAKERDIR rtFsIsoMakerFindSubdirBySpec(PRTFSISOMAKERDIR pDirObj, const char *pszEntry, size_t cchEntry, + uint32_t fSkipNamespaces) +{ + AssertReturn(pDirObj, NULL); + AssertReturn(pDirObj->Core.enmType == RTFSISOMAKEROBJTYPE_DIR, NULL); + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (!(fSkipNamespaces & g_aRTFsIsoNamespaces[i].fNamespace)) + { + PRTFSISOMAKERNAME pDirName = *(PPRTFSISOMAKERNAME)((uintptr_t)pDirObj + g_aRTFsIsoNamespaces[i].offName); + if (pDirName) + { + PRTFSISOMAKERNAMEDIR pDir = pDirName->pDir; + AssertStmt(pDir, continue); + + uint32_t iChild = pDir->cChildren; + while (iChild-- > 0) + { + PRTFSISOMAKERNAME pChild = pDir->papChildren[iChild]; + if ( pChild->cchSpecNm == cchEntry + && pChild->pDir != NULL + && RTStrNICmp(pChild->pszSpecNm, pszEntry, cchEntry) == 0) + return (PRTFSISOMAKERDIR)pChild->pObj; + } + } + } + return NULL; +} + + +/** + * Walks the given path by specified object names in a namespace. + * + * @returns IPRT status code. + * @param pNamespace The namespace to walk the path in. + * @param pszPath The path to walk. + * @param ppName Where to return the name node that the path ends with. + */ +static int rtFsIsoMakerWalkPathBySpec(PRTFSISOMAKERNAMESPACE pNamespace, const char *pszPath, PPRTFSISOMAKERNAME ppName) +{ + *ppName = NULL; + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_INVALID_NAME); + + /* + * Deal with the special case of the root. + */ + while (RTPATH_IS_SLASH(*pszPath)) + pszPath++; + AssertReturn(*pszPath, VERR_ISOMK_IPE_EMPTY_PATH); + + PRTFSISOMAKERNAME pCur = pNamespace->pRoot; + if (!pCur) + return *pszPath ? VERR_PATH_NOT_FOUND : VERR_FILE_NOT_FOUND; + if (!*pszPath) + { + *ppName = pCur; + return VINF_SUCCESS; + } + + /* + * Now, do the rest of the path. + */ + for (;;) + { + /* + * Find the end of the component. + */ + char ch; + size_t cchComponent = 0; + while ((ch = pszPath[cchComponent]) != '\0' && !RTPATH_IS_SLASH(ch)) + cchComponent++; + if (!cchComponent) + { + *ppName = pCur; + return VINF_SUCCESS; + } + + size_t offNext = cchComponent; + while (RTPATH_IS_SLASH(ch)) + ch = pszPath[++offNext]; + + /* + * Deal with dot and dot-dot. + */ + if (cchComponent == 1 && pszPath[0] == '.') + { /* nothing to do */ } + else if (cchComponent == 2 && pszPath[0] == '.' && pszPath[1] == '.') + { + if (pCur->pParent) + pCur = pCur->pParent; + } + /* + * Look up the name. + */ + else + { + PRTFSISOMAKERNAME pChild = rtFsIsoMakerFindEntryInDirBySpec(pCur, pszPath, cchComponent); + if (!pChild) + return pszPath[offNext] ? VERR_PATH_NOT_FOUND : VERR_FILE_NOT_FOUND; + if ( (offNext > cchComponent) + && !pChild->pDir) + return VERR_NOT_A_DIRECTORY; + pCur = pChild; + } + + /* + * Skip ahead in the path. + */ + pszPath += offNext; + } +} + + +/** + * Copy and convert a name to valid ISO-9660 (d-characters only). + * + * Worker for rtFsIsoMakerNormalizeNameForNamespace. ASSUMES it deals with + * dots. + * + * @returns Length of the resulting string. + * @param pszDst The output buffer. + * @param cchDstMax The maximum number of (d-chars) to put in the output + * buffer. + * @param pchSrc The UTF-8 source string (not neccessarily terminated). + * @param cchSrc The maximum number of chars to copy from the source + * string. + */ +static size_t rtFsIsoMakerCopyIso9660Name(char *pszDst, size_t cchDstMax, const char *pchSrc, size_t cchSrc) +{ + const char *pchSrcIn = pchSrc; + size_t offDst = 0; + while ((size_t)(pchSrc - pchSrcIn) < cchSrc) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pchSrc, &uc); + if (RT_SUCCESS(rc)) + { + if ( uc < 128 + && RTFSISOMAKER_IS_UPPER_IN_D_CHARS((char)uc)) + { + pszDst[offDst++] = RT_C_TO_UPPER((char)uc); + if (offDst >= cchDstMax) + break; + } + } + } + pszDst[offDst] = '\0'; + return offDst; +} + + +/** + * Normalizes a name for the primary ISO-9660 namespace. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pParent The parent directory. NULL if root. + * @param pchSrc The specified name to normalize (not necessarily zero + * terminated). + * @param cchSrc The length of the specified name. + * @param fIsDir Indicates whether it's a directory or file (like). + * @param pszDst The output buffer. Must be at least 32 bytes. + * @param cbDst The size of the output buffer. + * @param pcchDst Where to return the length of the returned string (i.e. + * not counting the terminator). + * @param pcbInDirRec Where to return the name size in the directory record. + */ +static int rtFsIsoMakerNormalizeNameForPrimaryIso9660(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAME pParent, + const char *pchSrc, size_t cchSrc, bool fIsDir, + char *pszDst, size_t cbDst, size_t *pcchDst, size_t *pcbInDirRec) +{ + AssertReturn(cbDst > ISO9660_MAX_NAME_LEN + 2, VERR_ISOMK_IPE_BUFFER_SIZE); + + /* Skip leading dots. */ + while (cchSrc > 0 && *pchSrc == '.') + pchSrc++, cchSrc--; + if (!cchSrc) + { + pchSrc = "DOTS"; + cchSrc = 4; + } + + /* + * Produce a first name. + */ + uint8_t const uIsoLevel = pThis->PrimaryIso.uLevel; + size_t cchDst; + size_t offDstDot; + if (fIsDir) + offDstDot = cchDst = rtFsIsoMakerCopyIso9660Name(pszDst, uIsoLevel >= 2 ? ISO9660_MAX_NAME_LEN : 8, + pchSrc, cchSrc); + else + { + /* Look for the last dot and try preserve the extension when doing the conversion. */ + size_t offLastDot = cchSrc; + for (size_t off = 0; off < cchSrc; off++) + if (pchSrc[off] == '.') + offLastDot = off; + + if (offLastDot == cchSrc) + offDstDot = cchDst = rtFsIsoMakerCopyIso9660Name(pszDst, uIsoLevel >= 2 ? ISO9660_MAX_NAME_LEN : 8, + pchSrc, cchSrc); + else + { + const char * const pchSrcExt = &pchSrc[offLastDot + 1]; + size_t const cchSrcExt = cchSrc - offLastDot - 1; + if (uIsoLevel < 2) + { + cchDst = rtFsIsoMakerCopyIso9660Name(pszDst, 8, pchSrc, cchSrc); + offDstDot = cchDst; + pszDst[cchDst++] = '.'; + cchDst += rtFsIsoMakerCopyIso9660Name(&pszDst[cchDst], 3, pchSrcExt, cchSrcExt); + } + else + { + size_t cchDstExt = rtFsIsoMakerCopyIso9660Name(pszDst, ISO9660_MAX_NAME_LEN - 2, pchSrcExt, cchSrcExt); + if (cchDstExt > 0) + { + size_t cchBasename = rtFsIsoMakerCopyIso9660Name(pszDst, ISO9660_MAX_NAME_LEN - 2, + pchSrc, offLastDot); + if (cchBasename + 1 + cchDstExt <= ISO9660_MAX_NAME_LEN) + cchDst = cchBasename; + else + cchDst = ISO9660_MAX_NAME_LEN - 1 - RT_MIN(cchDstExt, 4); + offDstDot = cchDst; + pszDst[cchDst++] = '.'; + cchDst += rtFsIsoMakerCopyIso9660Name(&pszDst[cchDst], ISO9660_MAX_NAME_LEN - 1 - cchDst, + pchSrcExt, cchSrcExt); + } + else + offDstDot = cchDst = rtFsIsoMakerCopyIso9660Name(pszDst, ISO9660_MAX_NAME_LEN, pchSrc, cchSrc); + } + } + } + + /* Append version if not directory */ + if (!fIsDir) + { + pszDst[cchDst++] = ';'; + pszDst[cchDst++] = '1'; + pszDst[cchDst] = '\0'; + } + + /* + * Unique name? + */ + if (!rtFsIsoMakerFindObjInDir(pParent, pszDst, cchDst)) + { + *pcchDst = cchDst; + *pcbInDirRec = cchDst; + return VINF_SUCCESS; + } + + /* + * Mangle the name till we've got a unique one. + */ + size_t const cchMaxBasename = (uIsoLevel >= 2 ? ISO9660_MAX_NAME_LEN : 8) - (cchDst - offDstDot); + size_t cchInserted = 0; + for (uint32_t i = 0; i < _32K; i++) + { + /* Add a numberic infix. */ + char szOrd[64]; + size_t cchOrd = RTStrFormatU32(szOrd, sizeof(szOrd), i + 1, 10, -1, -1, 0 /*fFlags*/); + Assert((ssize_t)cchOrd > 0); + + /* Do we need to shuffle the suffix? */ + if (cchOrd > cchInserted) + { + if (offDstDot < cchMaxBasename) + { + memmove(&pszDst[offDstDot + 1], &pszDst[offDstDot], cchDst + 1 - offDstDot); + cchDst++; + offDstDot++; + } + cchInserted = cchOrd; + } + + /* Insert the new infix and try again. */ + memcpy(&pszDst[offDstDot - cchOrd], szOrd, cchOrd); + if (!rtFsIsoMakerFindObjInDir(pParent, pszDst, cchDst)) + { + *pcchDst = cchDst; + *pcbInDirRec = cchDst; + return VINF_SUCCESS; + } + } + AssertFailed(); + return VERR_DUPLICATE; +} + + +/** + * Normalizes a name for the specified name space. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace which rules to normalize it according to. + * @param pParent The parent directory. NULL if root. + * @param pchSrc The specified name to normalize (not necessarily zero + * terminated). + * @param cchSrc The length of the specified name. + * @param fIsDir Indicates whether it's a directory or file (like). + * @param pszDst The output buffer. Must be at least 32 bytes. + * @param cbDst The size of the output buffer. + * @param pcchDst Where to return the length of the returned string (i.e. + * not counting the terminator). + * @param pcbInDirRec Where to return the name size in the directory record. + */ +static int rtFsIsoMakerNormalizeNameForNamespace(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, + PRTFSISOMAKERNAME pParent, const char *pchSrc, size_t cchSrc, bool fIsDir, + char *pszDst, size_t cbDst, size_t *pcchDst, size_t *pcbInDirRec) +{ + if (cchSrc > 0) + { + /* + * Check that the object doesn't already exist. + */ + AssertReturn(!rtFsIsoMakerFindEntryInDirBySpec(pParent, pchSrc, cchSrc), VERR_ALREADY_EXISTS); + switch (pNamespace->fNamespace) + { + /* + * This one is a lot of work, so separate function. + */ + case RTFSISOMAKER_NAMESPACE_ISO_9660: + return rtFsIsoMakerNormalizeNameForPrimaryIso9660(pThis, pParent, pchSrc, cchSrc, fIsDir, + pszDst, cbDst, pcchDst, pcbInDirRec); + + /* + * At the moment we don't give darn about UCS-2 limitations here... + */ + case RTFSISOMAKER_NAMESPACE_JOLIET: + { +/** @todo Joliet name limit and check for duplicates. */ + AssertReturn(cbDst > cchSrc, VERR_BUFFER_OVERFLOW); + memcpy(pszDst, pchSrc, cchSrc); + pszDst[cchSrc] = '\0'; + *pcchDst = cchSrc; + *pcbInDirRec = RTStrCalcUtf16Len(pszDst) * sizeof(RTUTF16); + return VINF_SUCCESS; + } + + case RTFSISOMAKER_NAMESPACE_UDF: + case RTFSISOMAKER_NAMESPACE_HFS: + AssertFailedReturn(VERR_NOT_IMPLEMENTED); + + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + } + else + { + /* + * Root special case. + * + * For ISO-9660 and joliet, we enter it with a length of 1 byte. The + * value byte value is zero. The path tables we generate won't be + * accepted by windows unless we do this. + */ + *pszDst = '\0'; + *pcchDst = 0; + *pcbInDirRec = pNamespace->fNamespace & (RTFSISOMAKER_NAMESPACE_ISO_9660 | RTFSISOMAKER_NAMESPACE_JOLIET) ? 1 : 0; + AssertReturn(!pParent, VERR_ISOMK_IPE_NAMESPACE_3); + return VINF_SUCCESS; + } +} + + +/** + * Creates a TRANS.TBL file object for a newly named directory. + * + * The file is associated with the namespace node for the directory. The file + * will be generated on the fly from the directory object. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace. + * @param pDirName The new name space node for the directory. + */ +static int rtFsIsoMakerAddTransTblFileToNewDir(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, + PRTFSISOMAKERNAME pDirName) +{ + /* + * Create a file object for it. + */ + PRTFSISOMAKERFILE pFile; + int rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, NULL, 0, &pFile); + if (RT_SUCCESS(rc)) + { + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_TRANS_TBL; + pFile->u.pTransTblDir = pDirName; + pFile->pBootInfoTable = NULL; + pDirName->pDir->pTransTblFile = pFile; + + /* + * Add it to the directory. + */ + PRTFSISOMAKERNAME pTransTblNm; + rc = rtFsIsoMakerObjSetName(pThis, pNamespace, &pFile->Core, pDirName, + pNamespace->pszTransTbl, strlen(pNamespace->pszTransTbl), &pTransTblNm); + if (RT_SUCCESS(rc)) + { + pTransTblNm->cchTransNm = 0; + return VINF_SUCCESS; + } + + /* + * Bail. + */ + pDirName->pDir->pTransTblFile = NULL; + rtFsIsoMakerObjRemoveWorker(pThis, &pFile->Core); + } + return rc; +} + + +/** + * Sets the name of an object in a namespace. + * + * If the object is already named in the name space, it will first be removed + * from that namespace. Should we run out of memory or into normalization + * issues after removing it, its original state will _not_ be restored. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace. + * @param pObj The object to name. + * @param pParent The parent namespace entry + * @param pchSpec The specified name (not necessarily terminated). + * @param cchSpec The specified name length. + * @param ppNewName Where to return the name entry. Optional. + */ +static int rtFsIsoMakerObjSetName(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKEROBJ pObj, + PRTFSISOMAKERNAME pParent, const char *pchSpec, size_t cchSpec, PPRTFSISOMAKERNAME ppNewName) +{ + Assert(cchSpec < _32K); + + /* + * If this is a file, check the size against the ISO level. + * This ASSUMES that only files which size we already know will be 4GB+ sized. + */ + if ( (pNamespace->fNamespace & RTFSISOMAKER_NAMESPACE_ISO_9660) + && pNamespace->uLevel < 3 + && pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + if (pFile->cbData >= _4G) + return VERR_ISOMK_FILE_TOO_BIG_REQ_ISO_LEVEL_3; + } + + /* + * If this is a symbolic link, refuse to add it to a namespace that isn't + * configured to support symbolic links. + */ + if ( pObj->enmType == RTFSISOMAKEROBJTYPE_SYMLINK + && (pNamespace->fNamespace & (RTFSISOMAKER_NAMESPACE_ISO_9660 | RTFSISOMAKER_NAMESPACE_JOLIET)) + && pNamespace->uRockRidgeLevel == 0) + return VERR_ISOMK_SYMLINK_REQ_ROCK_RIDGE; + + /* + * If the object is already named, unset that name before continuing. + */ + if (*rtFsIsoMakerObjGetNameForNamespace(pObj, pNamespace)) + { + int rc = rtFsIsoMakerObjUnsetName(pThis, pNamespace, pObj); + if (RT_FAILURE(rc)) + return rc; + } + + /* + * To avoid need to revert anything, make sure papChildren in the parent is + * large enough. If root object, make sure we haven't got a root already. + */ + if (pParent) + { + AssertReturn(pParent->pDir, VERR_ISOMK_IPE_NAMESPACE_1); + uint32_t cChildren = pParent->pDir->cChildren; + if (cChildren & 31) + { /* likely */ } + else + { + AssertReturn(cChildren < RTFSISOMAKER_MAX_OBJECTS_PER_DIR, VERR_TOO_MUCH_DATA); + void *pvNew = RTMemRealloc(pParent->pDir->papChildren, (cChildren + 32) * sizeof(pParent->pDir->papChildren[0])); + AssertReturn(pvNew, VERR_NO_MEMORY); + pParent->pDir->papChildren = (PPRTFSISOMAKERNAME)pvNew; + } + } + else + AssertReturn(pNamespace->pRoot == NULL, VERR_ISOMK_IPE_NAMESPACE_2); + + /* + * Normalize the name for this namespace. + */ + size_t cchName = 0; + size_t cbNameInDirRec = 0; + char szName[RTFSISOMAKER_MAX_NAME_BUF]; + int rc = rtFsIsoMakerNormalizeNameForNamespace(pThis, pNamespace, pParent, pchSpec, cchSpec, + pObj->enmType == RTFSISOMAKEROBJTYPE_DIR, + szName, sizeof(szName), &cchName, &cbNameInDirRec); + if (RT_SUCCESS(rc)) + { + Assert(cbNameInDirRec > 0); + + size_t cbName = sizeof(RTFSISOMAKERNAME) + + cchName + 1 + + cchSpec + 1; + if (pObj->enmType == RTFSISOMAKEROBJTYPE_DIR) + cbName = RT_ALIGN_Z(cbName, 8) + sizeof(RTFSISOMAKERNAMEDIR); + PRTFSISOMAKERNAME pName = (PRTFSISOMAKERNAME)RTMemAllocZ(cbName); + if (pName) + { + pName->pObj = pObj; + pName->pParent = pParent; + pName->cbNameInDirRec = (uint16_t)cbNameInDirRec; + pName->cchName = (uint16_t)cchName; + + char *pszDst = &pName->szName[cchName + 1]; + memcpy(pszDst, pchSpec, cchSpec); + pszDst[cchSpec] = '\0'; + pName->pszSpecNm = pszDst; + pName->pszRockRidgeNm = pszDst; + pName->pszTransNm = pszDst; + pName->cchSpecNm = (uint16_t)cchSpec; + pName->cchRockRidgeNm = (uint16_t)cchSpec; + pName->cchTransNm = (uint16_t)cchSpec; + pName->uDepth = pParent ? pParent->uDepth + 1 : 0; + pName->fRockRidgeNmAlloced = false; + pName->fTransNmAlloced = false; + pName->fRockNeedER = false; + pName->fRockNeedRRInDirRec = false; + pName->fRockNeedRRInSpill = false; + + pName->fMode = pObj->fMode; + pName->uid = pObj->uid; + pName->gid = pObj->gid; + pName->Device = 0; + pName->cHardlinks = 1; + pName->offDirRec = UINT32_MAX; + pName->cbDirRec = 0; + pName->cDirRecs = 1; + pName->cbDirRecTotal = 0; + pName->fRockEntries = 0; + pName->cbRockInDirRec = 0; + pName->offRockSpill = UINT32_MAX; + pName->cbRockSpill = 0; + + memcpy(pName->szName, szName, cchName); + pName->szName[cchName] = '\0'; + + if (pObj->enmType != RTFSISOMAKEROBJTYPE_DIR) + pName->pDir = NULL; + else + { + size_t offDir = RT_UOFFSETOF(RTFSISOMAKERNAME, szName) + cchName + 1 + cchSpec + 1; + offDir = RT_ALIGN_Z(offDir, 8); + PRTFSISOMAKERNAMEDIR pDir = (PRTFSISOMAKERNAMEDIR)((uintptr_t)pName + offDir); + pDir->offDir = UINT64_MAX; + pDir->cbDir = 0; + pDir->cChildren = 0; + pDir->papChildren = NULL; + pDir->pTransTblFile = NULL; + pDir->pName = pName; + pDir->offPathTable = UINT32_MAX; + pDir->idPathTable = UINT16_MAX; + pDir->cbDirRec00 = 0; + pDir->cbDirRec01 = 0; + RTListInit(&pDir->FinalizedEntry); + pName->pDir = pDir; + + /* Create the TRANS.TBL file object and enter it into this directory as the first entry. */ + if (pNamespace->pszTransTbl) + { + rc = rtFsIsoMakerAddTransTblFileToNewDir(pThis, pNamespace, pName); + if (RT_FAILURE(rc)) + { + RTMemFree(pName); + return rc; + } + } + } + + /* + * Do the linking and stats. We practice insertion sorting. + */ + if (pParent) + { + uint32_t idxName = rtFsIsoMakerFindInsertIndex(pNamespace, pParent, pName->szName); + uint32_t cChildren = pParent->pDir->cChildren; + if (idxName < cChildren) + memmove(&pParent->pDir->papChildren[idxName + 1], &pParent->pDir->papChildren[idxName], + (cChildren - idxName) * sizeof(pParent->pDir->papChildren[0])); + pParent->pDir->papChildren[idxName] = pName; + pParent->pDir->cChildren++; + } + else + pNamespace->pRoot = pName; + *rtFsIsoMakerObjGetNameForNamespace(pObj, pNamespace) = pName; + pNamespace->cNames++; + + /* + * Done. + */ + if (ppNewName) + *ppNewName = pName; + return VINF_SUCCESS; + } + } + return rc; +} + + +/** + * Walks the path up to the parent, creating missing directories as needed. + * + * As usual, we walk the specified names rather than the mangled ones. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace to walk. + * @param pszPath The path to walk. + * @param ppParent Where to return the pointer to the parent + * namespace node. + * @param ppszEntry Where to return the pointer to the final name component. + * @param pcchEntry Where to return the length of the final name component. + */ +static int rtFsIsoMakerCreatePathToParent(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, const char *pszPath, + PPRTFSISOMAKERNAME ppParent, const char **ppszEntry, size_t *pcchEntry) +{ + *ppParent = NULL; /* shut up gcc */ + *ppszEntry = NULL; /* shut up gcc */ + *pcchEntry = 0; /* shut up gcc */ + + int rc; + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_ISOMK_IPE_ROOT_SLASH); + + /* + * Deal with the special case of the root. + */ + while (RTPATH_IS_SLASH(*pszPath)) + pszPath++; + AssertReturn(*pszPath, VERR_ISOMK_IPE_EMPTY_PATH); /* We should not be called on a root path. */ + + PRTFSISOMAKERNAME pParent = pNamespace->pRoot; + if (!pParent) + { + PRTFSISOMAKERDIR pDir = RTListGetFirst(&pThis->ObjectHead, RTFSISOMAKERDIR, Core.Entry); +#ifdef RT_STRICT + Assert(pDir); + Assert(pDir->Core.idxObj == 0); + Assert(pDir->Core.enmType == RTFSISOMAKEROBJTYPE_DIR); + Assert(*rtFsIsoMakerObjGetNameForNamespace(&pDir->Core, pNamespace) == NULL); +#endif + + rc = rtFsIsoMakerObjSetName(pThis, pNamespace, &pDir->Core, NULL /*pParent*/, "", 0, &pParent); + AssertRCReturn(rc, rc); + pParent = pNamespace->pRoot; + AssertReturn(pParent, VERR_ISOMK_IPE_NAMESPACE_4); + } + + /* + * Now, do the rest of the path. + */ + for (;;) + { + /* + * Find the end of the component and see if its the final one or not. + */ + char ch; + size_t cchComponent = 0; + while ((ch = pszPath[cchComponent]) != '\0' && !RTPATH_IS_SLASH(ch)) + cchComponent++; + AssertReturn(cchComponent > 0, VERR_ISOMK_IPE_EMPTY_COMPONENT); + + size_t offNext = cchComponent; + while (RTPATH_IS_SLASH(ch)) + ch = pszPath[++offNext]; + + if (ch == '\0') + { + /* + * Final component. Make sure it is not dot or dot-dot before returning. + */ + AssertReturn( pszPath[0] != '.' + || cchComponent > 2 + || ( cchComponent == 2 + && pszPath[1] != '.'), + VERR_INVALID_NAME); + + *ppParent = pParent; + *ppszEntry = pszPath; + *pcchEntry = cchComponent; + return VINF_SUCCESS; + } + + /* + * Deal with dot and dot-dot. + */ + if (cchComponent == 1 && pszPath[0] == '.') + { /* nothing to do */ } + else if (cchComponent == 2 && pszPath[0] == '.' && pszPath[1] == '.') + { + if (pParent->pParent) + pParent = pParent->pParent; + } + /* + * Look it up. + */ + else + { + PRTFSISOMAKERNAME pChild = rtFsIsoMakerFindEntryInDirBySpec(pParent, pszPath, cchComponent); + if (pChild) + { + if (pChild->pDir) + pParent = pChild; + else + return VERR_NOT_A_DIRECTORY; + } + else + { + /* Try see if we've got a directory with the same spec name in a different namespace. + (We don't want to waste heap by creating a directory instance per namespace.) */ + PRTFSISOMAKERDIR pChildObj = rtFsIsoMakerFindSubdirBySpec((PRTFSISOMAKERDIR)pParent->pObj, + pszPath, cchComponent, pNamespace->fNamespace); + if (pChildObj) + { + PPRTFSISOMAKERNAME ppChildName = rtFsIsoMakerObjGetNameForNamespace(&pChildObj->Core, pNamespace); + if (!*ppChildName) + { + rc = rtFsIsoMakerObjSetName(pThis, pNamespace, &pChildObj->Core, pParent, pszPath, cchComponent, &pChild); + if (RT_FAILURE(rc)) + return rc; + AssertReturn(pChild != NULL, VERR_ISOMK_IPE_NAMESPACE_5); + } + } + /* If we didn't have luck in other namespaces, create a new directory. */ + if (!pChild) + { + rc = rtFsIsoMakerAddUnnamedDirWorker(pThis, NULL /*pObjInfo*/, &pChildObj); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerObjSetName(pThis, pNamespace, &pChildObj->Core, pParent, pszPath, cchComponent, &pChild); + if (RT_FAILURE(rc)) + return rc; + AssertReturn(pChild != NULL, VERR_ISOMK_IPE_NAMESPACE_5); + } + pParent = pChild; + } + } + + /* + * Skip ahead in the path. + */ + pszPath += offNext; + } +} + + +/** + * Worker for RTFsIsoMakerObjSetPath that operates on a single namespace. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace to name it in. + * @param pObj The filesystem object to name. + * @param pszPath The path to the entry in the namespace. + */ +static int rtFsIsoMakerObjSetPathInOne(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, + PRTFSISOMAKEROBJ pObj, const char *pszPath) +{ + AssertReturn(*rtFsIsoMakerObjGetNameForNamespace(pObj, pNamespace) == NULL, VERR_WRONG_ORDER); + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_ISOMK_IPE_ROOT_SLASH); + + /* + * Figure out where the parent is. + * This will create missing parent name space entries and directory nodes. + */ + PRTFSISOMAKERNAME pParent; + const char *pszEntry; + size_t cchEntry; + int rc; + if (pszPath[1] != '\0') + rc = rtFsIsoMakerCreatePathToParent(pThis, pNamespace, pszPath, &pParent, &pszEntry, &cchEntry); + else + { + /* + * Special case for the root directory. + */ + Assert(pObj->enmType == RTFSISOMAKEROBJTYPE_DIR); + AssertReturn(pNamespace->pRoot == NULL, VERR_WRONG_ORDER); + pszEntry = "/"; + cchEntry = 0; + pParent = NULL; + rc = VINF_SUCCESS; + } + + /* + * Do the job on the final path component. + */ + if (RT_SUCCESS(rc)) + { + AssertReturn(!RTPATH_IS_SLASH(pszEntry[cchEntry]) || pObj->enmType == RTFSISOMAKEROBJTYPE_DIR, + VERR_NOT_A_DIRECTORY); + rc = rtFsIsoMakerObjSetName(pThis, pNamespace, pObj, pParent, pszEntry, cchEntry, NULL); + } + return rc; +} + + +/** + * Removes an object from the given namespace. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param pNamespace The namespace. + * @param pObj The object to name. + */ +static int rtFsIsoMakerObjUnsetName(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKEROBJ pObj) +{ + LogFlow(("rtFsIsoMakerObjUnsetName: idxObj=#%#x\n", pObj->idxObj)); + + /* + * First check if there is anything to do here at all. + */ + PPRTFSISOMAKERNAME ppName = rtFsIsoMakerObjGetNameForNamespace(pObj, pNamespace); + PRTFSISOMAKERNAME pName = *ppName; + if (!pName) + return VINF_SUCCESS; + + /* + * We don't support this on the root. + */ + AssertReturn(pName->pParent, VERR_ACCESS_DENIED); + + /* + * If this is a directory, we're in for some real fun here as we need to + * unset the names of all the children too. + */ + PRTFSISOMAKERNAMEDIR pDir = pName->pDir; + if (pDir) + { + uint32_t iChild = pDir->cChildren; + while (iChild-- > 0) + { + int rc = rtFsIsoMakerObjUnsetName(pThis, pNamespace, pDir->papChildren[iChild]->pObj); + if (RT_FAILURE(rc)) + return rc; + } + AssertReturn(pDir->cChildren == 0, VERR_DIR_NOT_EMPTY); + } + + /* + * Unlink the pName from the parent. + */ + pDir = pName->pParent->pDir; + uint32_t iChild = pDir->cChildren; + while (iChild-- > 0) + if (pDir->papChildren[iChild] == pName) + { + uint32_t cToMove = pDir->cChildren - iChild - 1; + if (cToMove > 0) + memmove(&pDir->papChildren[iChild], &pDir->papChildren[iChild + 1], cToMove * sizeof(pDir->papChildren[0])); + pDir->cChildren--; + pNamespace->cNames--; + + /* + * NULL the name member in the object and free the structure. + */ + *ppName = NULL; + RTMemFree(pName); + + return VINF_SUCCESS; + } + + /* Not found. This can't happen. */ + AssertFailed(); + return VERR_ISOMK_IPE_NAMESPACE_6; +} + + + + + + +/* + * + * Object level config + * Object level config + * Object level config + * + */ + + +/** + * Translates an object index number to an object pointer, slow path. + * + * @returns Pointer to object, NULL if not found. + * @param pThis The ISO maker instance. + * @param idxObj The object index too resolve. + */ +DECL_NO_INLINE(static, PRTFSISOMAKEROBJ) rtFsIsoMakerIndexToObjSlow(PRTFSISOMAKERINT pThis, uint32_t idxObj) +{ + PRTFSISOMAKEROBJ pObj; + RTListForEachReverse(&pThis->ObjectHead, pObj, RTFSISOMAKEROBJ, Entry) + { + if (pObj->idxObj == idxObj) + return pObj; + } + return NULL; +} + + +/** + * Translates an object index number to an object pointer. + * + * @returns Pointer to object, NULL if not found. + * @param pThis The ISO maker instance. + * @param idxObj The object index too resolve. + */ +DECLINLINE(PRTFSISOMAKEROBJ) rtFsIsoMakerIndexToObj(PRTFSISOMAKERINT pThis, uint32_t idxObj) +{ + PRTFSISOMAKEROBJ pObj = RTListGetLast(&pThis->ObjectHead, RTFSISOMAKEROBJ, Entry); + if (!pObj || RT_LIKELY(pObj->idxObj == idxObj)) + return pObj; + return rtFsIsoMakerIndexToObjSlow(pThis, idxObj); +} + + +/** + * Resolves a path into a object ID. + * + * This will be doing the looking up using the specified object names rather + * than the version adjusted and mangled according to the namespace setup. + * + * @returns The object ID corresponding to @a pszPath, or UINT32_MAX if not + * found or invalid parameters. + * @param hIsoMaker The ISO maker instance. + * @param fNamespaces The namespace to resolve @a pszPath in. It's + * possible to specify multiple namespaces here, of + * course, but that's inefficient. + * @param pszPath The path to the object. + */ +RTDECL(uint32_t) RTFsIsoMakerGetObjIdxForPath(RTFSISOMAKER hIsoMaker, uint32_t fNamespaces, const char *pszPath) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET_EX(pThis, UINT32_MAX); + + /* + * Do the searching. + */ + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->pRoot) + { + PRTFSISOMAKERNAME pName; + int rc = rtFsIsoMakerWalkPathBySpec(pNamespace, pszPath, &pName); + if (RT_SUCCESS(rc)) + return pName->pObj->idxObj; + } + } + + return UINT32_MAX; +} + + +/** + * Removes the specified object from the image. + * + * This is a worker for RTFsIsoMakerObjRemove and + * rtFsIsoMakerFinalizeRemoveOrphans. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker instance. + * @param pObj The object to remove from the image. + */ +static int rtFsIsoMakerObjRemoveWorker(PRTFSISOMAKERINT pThis, PRTFSISOMAKEROBJ pObj) +{ + /* + * Don't allow removing trans.tbl files and the boot catalog. + */ + if (pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + AssertReturn(pFile->enmSrcType != RTFSISOMAKERSRCTYPE_TRANS_TBL, VERR_ACCESS_DENIED); + AssertReturn(pFile != pThis->pBootCatFile, VERR_ACCESS_DENIED); + } + + /* + * Remove the object from all name spaces. + */ + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + int rc2 = rtFsIsoMakerObjUnsetName(pThis, pNamespace, pObj); + if (RT_SUCCESS(rc2) || RT_FAILURE(rc)) + continue; + rc = rc2; + } + + /* + * If that succeeded, remove the object itself. + */ + if (RT_SUCCESS(rc)) + { + RTListNodeRemove(&pObj->Entry); + if (pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + uint64_t cbData = ((PRTFSISOMAKERFILE)pObj)->cbData; + pThis->cbData -= RT_ALIGN_64(cbData, RTFSISOMAKER_SECTOR_SIZE); + } + pThis->cObjects--; + rtFsIsoMakerObjDestroy(pObj); + } + return rc; +} + + +/** + * Removes the specified object from the image. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker instance. + * @param idxObj The index of the object to remove. + */ +RTDECL(int) RTFsIsoMakerObjRemove(RTFSISOMAKER hIsoMaker, uint32_t idxObj) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + AssertReturn( pObj->enmType != RTFSISOMAKEROBJTYPE_FILE + || ((PRTFSISOMAKERFILE)pObj)->enmSrcType != RTFSISOMAKERSRCTYPE_RR_SPILL, VERR_ACCESS_DENIED); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Call worker. + */ + return rtFsIsoMakerObjRemoveWorker(pThis, pObj); +} + + +/** + * Sets the path (name) of an object in the selected namespaces. + * + * The name will be transformed as necessary. + * + * The initial implementation does not allow this function to be called more + * than once on an object. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index of to name. + * @param fNamespaces The namespaces to apply the path to + * (RTFSISOMAKER_NAMESPACE_XXX). + * @param pszPath The path. + */ +RTDECL(int) RTFsIsoMakerObjSetPath(RTFSISOMAKER hIsoMaker, uint32_t idxObj, uint32_t fNamespaces, const char *pszPath) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_INVALID_NAME); + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Execute requested actions. + */ + uint32_t cAdded = 0; + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + int rc2 = rtFsIsoMakerObjSetPathInOne(pThis, pNamespace, pObj, pszPath); + if (RT_SUCCESS(rc2)) + cAdded++; + else if (RT_SUCCESS(rc) || rc == VERR_ISOMK_SYMLINK_REQ_ROCK_RIDGE) + rc = rc2; + } + } + return rc != VERR_ISOMK_SYMLINK_REQ_ROCK_RIDGE || cAdded == 0 ? rc : VINF_ISOMK_SYMLINK_REQ_ROCK_RIDGE; +} + + +/** + * Sets the name of an object in the selected namespaces, placing it under the + * given directory. + * + * The name will be transformed as necessary. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index of to name. + * @param idxParentObj The parent directory object. + * @param fNamespaces The namespaces to apply the path to + * (RTFSISOMAKER_NAMESPACE_XXX). + * @param pszName The name. + */ +RTDECL(int) RTFsIsoMakerObjSetNameAndParent(RTFSISOMAKER hIsoMaker, uint32_t idxObj, uint32_t idxParentObj, + uint32_t fNamespaces, const char *pszName) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + AssertPtrReturn(pszName, VERR_INVALID_POINTER); + size_t cchName = strlen(pszName); + AssertReturn(cchName > 0, VERR_INVALID_NAME); + AssertReturn(memchr(pszName, '/', cchName) == NULL, VERR_INVALID_NAME); + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + PRTFSISOMAKEROBJ pParentObj = rtFsIsoMakerIndexToObj(pThis, idxParentObj); + AssertReturn(pParentObj, VERR_OUT_OF_RANGE); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Execute requested actions. + */ + uint32_t cAdded = 0; + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + PRTFSISOMAKERNAME pParentName = *rtFsIsoMakerObjGetNameForNamespace(pParentObj, pNamespace); + if (pParentName) + { + int rc2 = rtFsIsoMakerObjSetName(pThis, pNamespace, pObj, pParentName, pszName, cchName, NULL /*ppNewName*/); + if (RT_SUCCESS(rc2)) + cAdded++; + else if (RT_SUCCESS(rc) || rc == VERR_ISOMK_SYMLINK_REQ_ROCK_RIDGE) + rc = rc2; + } + } + } + return rc != VERR_ISOMK_SYMLINK_REQ_ROCK_RIDGE || cAdded == 0 ? rc : VINF_ISOMK_SYMLINK_REQ_ROCK_RIDGE; +} + + +/** + * Changes the rock ridge name for the object in the selected namespaces. + * + * The object must already be enetered into the namespaces by + * RTFsIsoMakerObjSetNameAndParent, RTFsIsoMakerObjSetPath or similar. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index of to name. + * @param fNamespaces The namespaces to apply the path to + * (RTFSISOMAKER_NAMESPACE_XXX). + * @param pszRockName The rock ridge name. Passing NULL will restore + * it back to the specified name, while an empty + * string will restore it to the namespace name. + */ +RTDECL(int) RTFsIsoMakerObjSetRockName(RTFSISOMAKER hIsoMaker, uint32_t idxObj, uint32_t fNamespaces, const char *pszRockName) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + size_t cchRockName; + if (pszRockName) + { + AssertPtrReturn(pszRockName, VERR_INVALID_POINTER); + cchRockName = strlen(pszRockName); + AssertReturn(cchRockName < _1K, VERR_FILENAME_TOO_LONG); + AssertReturn(memchr(pszRockName, '/', cchRockName) == NULL, VERR_INVALID_NAME); + } + else + cchRockName = 0; + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Execute requested actions. + */ + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if ( pNamespace->uLevel > 0 + && pNamespace->uRockRidgeLevel > 0) + { + PRTFSISOMAKERNAME pName = *rtFsIsoMakerObjGetNameForNamespace(pObj, pNamespace); + if (pName) + { + /* Free the old rock ridge name. */ + if (pName->fRockRidgeNmAlloced) + { + RTMemFree(pName->pszRockRidgeNm); + pName->pszRockRidgeNm = NULL; + pName->fRockRidgeNmAlloced = false; + } + + /* Set new rock ridge name. */ + if (cchRockName > 0) + { + pName->pszRockRidgeNm = (char *)RTMemDup(pszRockName, cchRockName + 1); + if (!pName->pszRockRidgeNm) + { + pName->pszRockRidgeNm = (char *)pName->pszSpecNm; + pName->cchRockRidgeNm = pName->cchSpecNm; + return VERR_NO_MEMORY; + } + pName->cchRockRidgeNm = (uint16_t)cchRockName; + pName->fRockRidgeNmAlloced = true; + } + else if (pszRockName == NULL) + { + pName->pszRockRidgeNm = (char *)pName->pszSpecNm; + pName->cchRockRidgeNm = pName->cchSpecNm; + } + else + { + pName->pszRockRidgeNm = pName->szName; + pName->cchRockRidgeNm = pName->cchName; + } + } + } + } + return VINF_SUCCESS; +} + + +/** + * Enables or disable syslinux boot info table patching of a file. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index. + * @param fEnable Whether to enable or disable patching. + */ +RTDECL(int) RTFsIsoMakerObjEnableBootInfoTablePatching(RTFSISOMAKER hIsoMaker, uint32_t idxObj, bool fEnable) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + AssertReturn(pObj->enmType == RTFSISOMAKEROBJTYPE_FILE, VERR_WRONG_TYPE); + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + AssertReturn( pFile->enmSrcType == RTFSISOMAKERSRCTYPE_PATH + || pFile->enmSrcType == RTFSISOMAKERSRCTYPE_VFS_FILE + || pFile->enmSrcType == RTFSISOMAKERSRCTYPE_COMMON, + VERR_WRONG_TYPE); + + /* + * Do the job. + */ + if (fEnable) + { + if (!pFile->pBootInfoTable) + { + pFile->pBootInfoTable = (PISO9660SYSLINUXINFOTABLE)RTMemAllocZ(sizeof(*pFile->pBootInfoTable)); + AssertReturn(pFile->pBootInfoTable, VERR_NO_MEMORY); + } + } + else if (pFile->pBootInfoTable) + { + RTMemFree(pFile->pBootInfoTable); + pFile->pBootInfoTable = NULL; + } + return VINF_SUCCESS; +} + + +/** + * Gets the data size of an object. + * + * Currently only supported on file objects. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index. + * @param pcbData Where to return the size. + */ +RTDECL(int) RTFsIsoMakerObjQueryDataSize(RTFSISOMAKER hIsoMaker, uint32_t idxObj, uint64_t *pcbData) +{ + /* + * Validate and translate input. + */ + AssertPtrReturn(pcbData, VERR_INVALID_POINTER); + *pcbData = UINT64_MAX; + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + + /* + * Do the job. + */ + if (pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + if ( pFile->enmSrcType != RTFSISOMAKERSRCTYPE_TRANS_TBL + && pFile->enmSrcType != RTFSISOMAKERSRCTYPE_RR_SPILL) + { + *pcbData = ((PRTFSISOMAKERFILE)pObj)->cbData; + return VINF_SUCCESS; + } + } + return VERR_WRONG_TYPE; +} + + +/** + * Initalizes the common part of a file system object and links it into global + * chain. + * + * @returns IPRT status code + * @param pThis The ISO maker instance. + * @param pObj The common object. + * @param enmType The object type. + * @param pObjInfo The object information (typically source). + * Optional. + */ +static int rtFsIsoMakerInitCommonObj(PRTFSISOMAKERINT pThis, PRTFSISOMAKEROBJ pObj, + RTFSISOMAKEROBJTYPE enmType, PCRTFSOBJINFO pObjInfo) +{ + Assert(!pThis->fFinalized); + AssertReturn(pThis->cObjects < RTFSISOMAKER_MAX_OBJECTS, VERR_OUT_OF_RANGE); + + pObj->enmType = enmType; + pObj->pPrimaryName = NULL; + pObj->pJolietName = NULL; + pObj->pUdfName = NULL; + pObj->pHfsName = NULL; + pObj->idxObj = pThis->cObjects++; + pObj->cNotOrphan = 0; + if (pObjInfo) + { + pObj->BirthTime = pObjInfo->BirthTime; + pObj->ChangeTime = pObjInfo->ChangeTime; + pObj->ModificationTime = pObjInfo->ModificationTime; + pObj->AccessedTime = pObjInfo->AccessTime; + pObj->fMode = pObjInfo->Attr.fMode; + if (!pThis->fStrictAttributeStyle) + { + if (enmType == RTFSISOMAKEROBJTYPE_DIR) + pObj->fMode = (pObjInfo->Attr.fMode & ~07222) | 0555; + else + { + pObj->fMode = (pObjInfo->Attr.fMode & ~00222) | 0444; + if (pObj->fMode & 0111) + pObj->fMode |= 0111; + } + pObj->uid = pThis->uidDefault; + pObj->gid = pThis->gidDefault; + } + else + { + pObj->fMode = pObjInfo->Attr.fMode; + pObj->uid = pObjInfo->Attr.u.Unix.uid != NIL_RTUID ? pObjInfo->Attr.u.Unix.uid : pThis->uidDefault; + pObj->gid = pObjInfo->Attr.u.Unix.gid != NIL_RTGID ? pObjInfo->Attr.u.Unix.gid : pThis->gidDefault; + } + if (enmType == RTFSISOMAKEROBJTYPE_DIR ? pThis->fForcedDirModeActive : pThis->fForcedFileModeActive) + pObj->fMode = (pObj->fMode & ~RTFS_UNIX_ALL_PERMS) + | (enmType == RTFSISOMAKEROBJTYPE_DIR ? pThis->fForcedDirMode : pThis->fForcedFileMode); + } + else + { + pObj->BirthTime = pThis->ImageCreationTime; + pObj->ChangeTime = pThis->ImageCreationTime; + pObj->ModificationTime = pThis->ImageCreationTime; + pObj->AccessedTime = pThis->ImageCreationTime; + pObj->fMode = enmType == RTFSISOMAKEROBJTYPE_DIR ? pThis->fDefaultDirMode : pThis->fDefaultFileMode; + pObj->uid = pThis->uidDefault; + pObj->gid = pThis->gidDefault; + } + + RTListAppend(&pThis->ObjectHead, &pObj->Entry); + return VINF_SUCCESS; +} + + +/** + * Internal function for adding an unnamed directory. + * + * @returns IPRT status code. + * @param pThis The ISO make instance. + * @param pObjInfo Pointer to object attributes, must be set to + * UNIX. The size and hardlink counts are ignored. + * Optional. + * @param ppDir Where to return the directory. + */ +static int rtFsIsoMakerAddUnnamedDirWorker(PRTFSISOMAKERINT pThis, PCRTFSOBJINFO pObjInfo, PRTFSISOMAKERDIR *ppDir) +{ + PRTFSISOMAKERDIR pDir = (PRTFSISOMAKERDIR)RTMemAllocZ(sizeof(*pDir)); + AssertReturn(pDir, VERR_NO_MEMORY); + int rc = rtFsIsoMakerInitCommonObj(pThis, &pDir->Core, RTFSISOMAKEROBJTYPE_DIR, pObjInfo); + if (RT_SUCCESS(rc)) + { + *ppDir = pDir; + return VINF_SUCCESS; + } + RTMemFree(pDir); + return rc; + +} + + +/** + * Adds an unnamed directory to the image. + * + * The directory must explictly be entered into the desired namespaces. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pObjInfo Pointer to object attributes, must be set to + * UNIX. The size and hardlink counts are ignored. + * Optional. + * @param pidxObj Where to return the configuration index of the + * directory. + * @sa RTFsIsoMakerAddDir, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddUnnamedDir(RTFSISOMAKER hIsoMaker, PCRTFSOBJINFO pObjInfo, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + if (pObjInfo) + { + AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER); + AssertReturn(pObjInfo->Attr.enmAdditional == RTFSOBJATTRADD_UNIX, VERR_INVALID_PARAMETER); + AssertReturn(RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode), VERR_INVALID_FLAGS); + } + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + PRTFSISOMAKERDIR pDir; + int rc = rtFsIsoMakerAddUnnamedDirWorker(pThis, pObjInfo, &pDir); + *pidxObj = RT_SUCCESS(rc) ? pDir->Core.idxObj : UINT32_MAX; + return rc; +} + + +/** + * Adds a directory to the image in all namespaces and default attributes. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pszDir The path (UTF-8) to the directory in the ISO. + * + * @param pidxObj Where to return the configuration index of the + * directory. Optional. + * @sa RTFsIsoMakerAddUnnamedDir, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddDir(RTFSISOMAKER hIsoMaker, const char *pszDir, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszDir, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszDir), VERR_INVALID_NAME); + + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedDir(hIsoMaker, NULL /*pObjInfo*/, &idxObj); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerObjSetPath(hIsoMaker, idxObj, RTFSISOMAKER_NAMESPACE_ALL, pszDir); + if (RT_SUCCESS(rc)) + { + if (pidxObj) + *pidxObj = idxObj; + } + else + RTFsIsoMakerObjRemove(hIsoMaker, idxObj); + } + return rc; +} + + +/** + * Internal function for adding an unnamed file. + * + * @returns IPRT status code. + * @param pThis The ISO make instance. + * @param pObjInfo Object information. Optional. + * @param cbExtra Extra space for additional data (e.g. source + * path string copy). + * @param ppFile Where to return the file. + */ +static int rtFsIsoMakerAddUnnamedFileWorker(PRTFSISOMAKERINT pThis, PCRTFSOBJINFO pObjInfo, size_t cbExtra, + PRTFSISOMAKERFILE *ppFile) +{ + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)RTMemAllocZ(sizeof(*pFile) + cbExtra); + AssertReturn(pFile, VERR_NO_MEMORY); + int rc = rtFsIsoMakerInitCommonObj(pThis, &pFile->Core, RTFSISOMAKEROBJTYPE_FILE, pObjInfo); + if (RT_SUCCESS(rc)) + { + pFile->cbData = pObjInfo ? pObjInfo->cbObject : 0; + pThis->cbData += RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE); + pFile->offData = UINT64_MAX; + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_INVALID; + pFile->u.pszSrcPath = NULL; + pFile->pBootInfoTable = NULL; + RTListInit(&pFile->FinalizedEntry); + + *ppFile = pFile; + return VINF_SUCCESS; + } + RTMemFree(pFile); + return rc; + +} + + +/** + * Adds an unnamed file to the image that's backed by a host file. + * + * The file must explictly be entered into the desired namespaces. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pszSrcFile The source file path. VFS chain spec allowed. + * @param pidxObj Where to return the configuration index of the + * directory. + * @sa RTFsIsoMakerAddFile, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddUnnamedFileWithSrcPath(RTFSISOMAKER hIsoMaker, const char *pszSrcFile, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + *pidxObj = UINT32_MAX; + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Check that the source file exists and is a file. + */ + uint32_t offError = 0; + RTFSOBJINFO ObjInfo; + int rc = RTVfsChainQueryInfo(pszSrcFile, &ObjInfo, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK, &offError, NULL); + AssertMsgRCReturn(rc, ("%s -> %Rrc offError=%u\n", pszSrcFile, rc, offError), rc); + AssertMsgReturn(RTFS_IS_FILE(ObjInfo.Attr.fMode), ("%#x - %s\n", ObjInfo.Attr.fMode, pszSrcFile), VERR_NOT_A_FILE); + + /* + * Create a file object for it. + */ + size_t const cbSrcFile = strlen(pszSrcFile) + 1; + PRTFSISOMAKERFILE pFile; + rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, &ObjInfo, cbSrcFile, &pFile); + if (RT_SUCCESS(rc)) + { + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_PATH; + pFile->u.pszSrcPath = (char *)memcpy(pFile + 1, pszSrcFile, cbSrcFile); + + *pidxObj = pFile->Core.idxObj; + } + return rc; +} + + +/** + * Adds an unnamed file to the image that's backed by a VFS file. + * + * The file must explictly be entered into the desired namespaces. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param hVfsFileSrc The source file handle. + * @param pidxObj Where to return the configuration index of the + * directory. + * @sa RTFsIsoMakerAddUnnamedFileWithSrcPath, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddUnnamedFileWithVfsFile(RTFSISOMAKER hIsoMaker, RTVFSFILE hVfsFileSrc, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + *pidxObj = UINT32_MAX; + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Get the VFS file info. This implicitly validates the handle. + */ + RTFSOBJINFO ObjInfo; + int rc = RTVfsFileQueryInfo(hVfsFileSrc, &ObjInfo, RTFSOBJATTRADD_UNIX); + AssertMsgRCReturn(rc, ("RTVfsFileQueryInfo(%p) -> %Rrc\n", hVfsFileSrc, rc), rc); + + /* + * Retain a reference to the file. + */ + uint32_t cRefs = RTVfsFileRetain(hVfsFileSrc); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a file object for it. + */ + PRTFSISOMAKERFILE pFile; + rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, &ObjInfo, 0, &pFile); + if (RT_SUCCESS(rc)) + { + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_VFS_FILE; + pFile->u.hVfsFile = hVfsFileSrc; + + *pidxObj = pFile->Core.idxObj; + } + else + RTVfsFileRelease(hVfsFileSrc); + return rc; +} + + +/** + * Adds an unnamed file to the image that's backed by a portion of a common + * source file. + * + * The file must explictly be entered into the desired namespaces. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param idxCommonSrc The common source file index. + * @param offData The offset of the data in the source file. + * @param cbData The file size. + * @param pObjInfo Pointer to file info. Optional. + * @param pidxObj Where to return the configuration index of the + * directory. + * @sa RTFsIsoMakerAddUnnamedFileWithSrcPath, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddUnnamedFileWithCommonSrc(RTFSISOMAKER hIsoMaker, uint32_t idxCommonSrc, + uint64_t offData, uint64_t cbData, PCRTFSOBJINFO pObjInfo, uint32_t *pidxObj) +{ + /* + * Validate and fake input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + *pidxObj = UINT32_MAX; + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + AssertReturn(idxCommonSrc < pThis->cCommonSources, VERR_INVALID_PARAMETER); + AssertReturn(offData < (uint64_t)RTFOFF_MAX, VERR_OUT_OF_RANGE); + AssertReturn(cbData < (uint64_t)RTFOFF_MAX, VERR_OUT_OF_RANGE); + AssertReturn(offData + cbData < (uint64_t)RTFOFF_MAX, VERR_OUT_OF_RANGE); + RTFSOBJINFO ObjInfo; + if (!pObjInfo) + { + ObjInfo.cbObject = cbData; + ObjInfo.cbAllocated = cbData; + ObjInfo.BirthTime = pThis->ImageCreationTime; + ObjInfo.ChangeTime = pThis->ImageCreationTime; + ObjInfo.ModificationTime = pThis->ImageCreationTime; + ObjInfo.AccessTime = pThis->ImageCreationTime; + ObjInfo.Attr.fMode = pThis->fDefaultFileMode; + ObjInfo.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + ObjInfo.Attr.u.Unix.uid = NIL_RTUID; + ObjInfo.Attr.u.Unix.gid = NIL_RTGID; + ObjInfo.Attr.u.Unix.cHardlinks = 1; + ObjInfo.Attr.u.Unix.INodeIdDevice = 0; + ObjInfo.Attr.u.Unix.INodeId = 0; + ObjInfo.Attr.u.Unix.fFlags = 0; + ObjInfo.Attr.u.Unix.GenerationId = 0; + ObjInfo.Attr.u.Unix.Device = 0; + pObjInfo = &ObjInfo; + } + else + { + AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER); + AssertReturn(pObjInfo->Attr.enmAdditional == RTFSOBJATTRADD_UNIX, VERR_WRONG_TYPE); + AssertReturn((uint64_t)pObjInfo->cbObject == cbData, VERR_INVALID_PARAMETER); + } + + /* + * Create a file object for it. + */ + PRTFSISOMAKERFILE pFile; + int rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, pObjInfo, 0, &pFile); + if (RT_SUCCESS(rc)) + { + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_COMMON; + pFile->u.Common.idxSrc = idxCommonSrc; + pFile->u.Common.offData = offData; + + *pidxObj = pFile->Core.idxObj; + } + return rc; +} + + +/** + * Adds a common source file. + * + * Using RTFsIsoMakerAddUnnamedFileWithCommonSrc a sections common source file + * can be referenced to make up other files. The typical use case is when + * importing data from an existing ISO. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param hVfsFile VFS handle of the common source. (A reference + * is added, none consumed.) + * @param pidxCommonSrc Where to return the assigned common source + * index. This is used to reference the file. + * @sa RTFsIsoMakerAddUnnamedFileWithCommonSrc + */ +RTDECL(int) RTFsIsoMakerAddCommonSourceFile(RTFSISOMAKER hIsoMaker, RTVFSFILE hVfsFile, uint32_t *pidxCommonSrc) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxCommonSrc, VERR_INVALID_POINTER); + *pidxCommonSrc = UINT32_MAX; + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Resize the common source array if necessary. + */ + if ((pThis->cCommonSources & 15) == 0) + { + void *pvNew = RTMemRealloc(pThis->paCommonSources, (pThis->cCommonSources + 16) * sizeof(pThis->paCommonSources[0])); + AssertReturn(pvNew, VERR_NO_MEMORY); + pThis->paCommonSources = (PRTVFSFILE)pvNew; + } + + /* + * Retain a reference to the source file, thereby validating the handle. + * Then add it to the array. + */ + uint32_t cRefs = RTVfsFileRetain(hVfsFile); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + uint32_t idx = pThis->cCommonSources++; + pThis->paCommonSources[idx] = hVfsFile; + + *pidxCommonSrc = idx; + return VINF_SUCCESS; +} + + +/** + * Adds a file that's backed by a host file to the image in all namespaces and + * with attributes taken from the source file. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pszFile The path to the file in the image. + * @param pszSrcFile The source file path. VFS chain spec allowed. + * @param pidxObj Where to return the configuration index of the file. + * Optional + * @sa RTFsIsoMakerAddFileWithVfsFile, + * RTFsIsoMakerAddUnnamedFileWithSrcPath + */ +RTDECL(int) RTFsIsoMakerAddFileWithSrcPath(RTFSISOMAKER hIsoMaker, const char *pszFile, const char *pszSrcFile, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszFile, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszFile), VERR_INVALID_NAME); + + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedFileWithSrcPath(hIsoMaker, pszSrcFile, &idxObj); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerObjSetPath(hIsoMaker, idxObj, RTFSISOMAKER_NAMESPACE_ALL, pszFile); + if (RT_SUCCESS(rc)) + { + if (pidxObj) + *pidxObj = idxObj; + } + else + RTFsIsoMakerObjRemove(hIsoMaker, idxObj); + } + return rc; +} + + +/** + * Adds a file that's backed by a VFS file to the image in all namespaces and + * with attributes taken from the source file. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pszFile The path to the file in the image. + * @param hVfsFileSrc The source file handle. + * @param pidxObj Where to return the configuration index of the file. + * Optional. + * @sa RTFsIsoMakerAddUnnamedFileWithVfsFile, + * RTFsIsoMakerAddFileWithSrcPath + */ +RTDECL(int) RTFsIsoMakerAddFileWithVfsFile(RTFSISOMAKER hIsoMaker, const char *pszFile, RTVFSFILE hVfsFileSrc, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszFile, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszFile), VERR_INVALID_NAME); + + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedFileWithVfsFile(hIsoMaker, hVfsFileSrc, &idxObj); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerObjSetPath(hIsoMaker, idxObj, RTFSISOMAKER_NAMESPACE_ALL, pszFile); + if (RT_SUCCESS(rc)) + { + if (pidxObj) + *pidxObj = idxObj; + } + else + RTFsIsoMakerObjRemove(hIsoMaker, idxObj); + } + return rc; +} + + +/** + * Adds an unnamed symbolic link to the image. + * + * The symlink must explictly be entered into the desired namespaces. Please + * note that it is not possible to enter a symbolic link into an ISO 9660 + * namespace where rock ridge extensions are disabled, since symbolic links + * depend on rock ridge. For HFS and UDF there is no such requirement. + * + * Will fail if no namespace is configured that supports symlinks. + * + * @returns IPRT status code + * @retval VERR_ISOMK_SYMLINK_SUPPORT_DISABLED if not supported. + * @param hIsoMaker The ISO maker handle. + * @param pObjInfo Pointer to object attributes, must be set to + * UNIX. The size and hardlink counts are ignored. + * Optional. + * @param pszTarget The symbolic link target (UTF-8). + * @param pidxObj Where to return the configuration index of the + * directory. + * @sa RTFsIsoMakerAddSymlink, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddUnnamedSymlink(RTFSISOMAKER hIsoMaker, PCRTFSOBJINFO pObjInfo, const char *pszTarget, uint32_t *pidxObj) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + if (pObjInfo) + { + AssertPtrReturn(pObjInfo, VERR_INVALID_POINTER); + AssertReturn(pObjInfo->Attr.enmAdditional == RTFSOBJATTRADD_UNIX, VERR_INVALID_PARAMETER); + AssertReturn(RTFS_IS_SYMLINK(pObjInfo->Attr.fMode), VERR_INVALID_FLAGS); + } + AssertPtrReturn(pszTarget, VERR_INVALID_POINTER); + size_t cchTarget = strlen(pszTarget); + AssertReturn(cchTarget > 0, VERR_INVALID_NAME); + AssertReturn(cchTarget < RTFSISOMAKER_MAX_SYMLINK_TARGET_LEN, VERR_FILENAME_TOO_LONG); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Check that symlinks are supported by some namespace. + */ + AssertReturn( (pThis->PrimaryIso.uLevel > 0 && pThis->PrimaryIso.uRockRidgeLevel > 0) + || (pThis->Joliet.uLevel > 0 && pThis->Joliet.uRockRidgeLevel > 0) + || pThis->Udf.uLevel > 0 + || pThis->Hfs.uLevel > 0, + VERR_ISOMK_SYMLINK_SUPPORT_DISABLED); + + /* + * Calculate the size of the SL entries. + */ + uint8_t abTmp[_2K + RTFSISOMAKER_MAX_SYMLINK_TARGET_LEN * 3]; + ssize_t cbSlRockRidge = rtFsIsoMakerOutFile_RockRidgeGenSL(pszTarget, abTmp, sizeof(abTmp)); + AssertReturn(cbSlRockRidge > 0, (int)cbSlRockRidge); + + /* + * Do the adding. + */ + PRTFSISOMAKERSYMLINK pSymlink = (PRTFSISOMAKERSYMLINK)RTMemAllocZ(RT_UOFFSETOF_DYN(RTFSISOMAKERSYMLINK, szTarget[cchTarget + 1])); + AssertReturn(pSymlink, VERR_NO_MEMORY); + int rc = rtFsIsoMakerInitCommonObj(pThis, &pSymlink->Core, RTFSISOMAKEROBJTYPE_SYMLINK, pObjInfo); + if (RT_SUCCESS(rc)) + { + pSymlink->cchTarget = (uint16_t)cchTarget; + pSymlink->cbSlRockRidge = (uint16_t)cbSlRockRidge; + memcpy(pSymlink->szTarget, pszTarget, cchTarget); + pSymlink->szTarget[cchTarget] = '\0'; + + *pidxObj = pSymlink->Core.idxObj; + return VINF_SUCCESS; + } + RTMemFree(pSymlink); + return rc; +} + + +/** + * Adds a directory to the image in all namespaces and default attributes. + * + * Will fail if no namespace is configured that supports symlinks. + * + * @returns IPRT status code + * @param hIsoMaker The ISO maker handle. + * @param pszSymlink The path (UTF-8) to the symlink in the ISO. + * @param pszTarget The symlink target (UTF-8). + * @param pidxObj Where to return the configuration index of the + * directory. Optional. + * @sa RTFsIsoMakerAddUnnamedSymlink, RTFsIsoMakerObjSetPath + */ +RTDECL(int) RTFsIsoMakerAddSymlink(RTFSISOMAKER hIsoMaker, const char *pszSymlink, const char *pszTarget, uint32_t *pidxObj) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszSymlink, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszSymlink), VERR_INVALID_NAME); + + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedSymlink(hIsoMaker, NULL /*pObjInfo*/, pszTarget, &idxObj); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerObjSetPath(hIsoMaker, idxObj, RTFSISOMAKER_NAMESPACE_ALL, pszSymlink); + if (RT_SUCCESS(rc)) + { + if (pidxObj) + *pidxObj = idxObj; + } + else + RTFsIsoMakerObjRemove(hIsoMaker, idxObj); + } + return rc; + +} + + + +/* + * + * Name space level object config. + * Name space level object config. + * Name space level object config. + * + */ + + +/** + * Modifies the mode mask for a given path in one or more namespaces. + * + * The mode mask is used by rock ridge, UDF and HFS. + * + * @returns IPRT status code. + * @retval VWRN_NOT_FOUND if the path wasn't found in any of the specified + * namespaces. + * + * @param hIsoMaker The ISO maker handler. + * @param pszPath The path which mode mask should be modified. + * @param fNamespaces The namespaces to set it in. + * @param fSet The mode bits to set. + * @param fUnset The mode bits to clear (applied first). + * @param fFlags Reserved, MBZ. + * @param pcHits Where to return number of paths found. Optional. + */ +RTDECL(int) RTFsIsoMakerSetPathMode(RTFSISOMAKER hIsoMaker, const char *pszPath, uint32_t fNamespaces, + RTFMODE fSet, RTFMODE fUnset, uint32_t fFlags, uint32_t *pcHits) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_INVALID_NAME); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(!(fSet & ~07777), VERR_INVALID_PARAMETER); + AssertReturn(!(fUnset & ~07777), VERR_INVALID_PARAMETER); + AssertReturn(!fFlags, VERR_INVALID_FLAGS); + AssertPtrNullReturn(pcHits, VERR_INVALID_POINTER); + + /* + * Make the changes namespace by namespace. + */ + uint32_t cHits = 0; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + PRTFSISOMAKERNAME pName; + int rc = rtFsIsoMakerWalkPathBySpec(pNamespace, pszPath, &pName); + if (RT_SUCCESS(rc)) + { + pName->fMode = (pName->fMode & ~fUnset) | fSet; + cHits++; + } + } + } + + if (pcHits) + *pcHits = cHits; + if (cHits > 0) + return VINF_SUCCESS; + return VWRN_NOT_FOUND; +} + + +/** + * Modifies the owner ID for a given path in one or more namespaces. + * + * The owner ID is used by rock ridge, UDF and HFS. + * + * @returns IPRT status code. + * @retval VWRN_NOT_FOUND if the path wasn't found in any of the specified + * namespaces. + * + * @param hIsoMaker The ISO maker handler. + * @param pszPath The path which mode mask should be modified. + * @param fNamespaces The namespaces to set it in. + * @param idOwner The new owner ID to set. + * @param pcHits Where to return number of paths found. Optional. + */ +RTDECL(int) RTFsIsoMakerSetPathOwnerId(RTFSISOMAKER hIsoMaker, const char *pszPath, uint32_t fNamespaces, + RTUID idOwner, uint32_t *pcHits) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_INVALID_NAME); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + AssertPtrNullReturn(pcHits, VERR_INVALID_POINTER); + + /* + * Make the changes namespace by namespace. + */ + uint32_t cHits = 0; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + PRTFSISOMAKERNAME pName; + int rc = rtFsIsoMakerWalkPathBySpec(pNamespace, pszPath, &pName); + if (RT_SUCCESS(rc)) + { + pName->uid = idOwner; + cHits++; + } + } + } + + if (pcHits) + *pcHits = cHits; + if (cHits > 0) + return VINF_SUCCESS; + return VWRN_NOT_FOUND; +} + + +/** + * Modifies the group ID for a given path in one or more namespaces. + * + * The group ID is used by rock ridge, UDF and HFS. + * + * @returns IPRT status code. + * @retval VWRN_NOT_FOUND if the path wasn't found in any of the specified + * namespaces. + * + * @param hIsoMaker The ISO maker handler. + * @param pszPath The path which mode mask should be modified. + * @param fNamespaces The namespaces to set it in. + * @param idGroup The new group ID to set. + * @param pcHits Where to return number of paths found. Optional. + */ +RTDECL(int) RTFsIsoMakerSetPathGroupId(RTFSISOMAKER hIsoMaker, const char *pszPath, uint32_t fNamespaces, + RTGID idGroup, uint32_t *pcHits) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertPtrReturn(pszPath, VERR_INVALID_POINTER); + AssertReturn(RTPATH_IS_SLASH(*pszPath), VERR_INVALID_NAME); + AssertReturn(!(fNamespaces & ~RTFSISOMAKER_NAMESPACE_VALID_MASK), VERR_INVALID_FLAGS); + AssertPtrNullReturn(pcHits, VERR_INVALID_POINTER); + + /* + * Make the changes namespace by namespace. + */ + uint32_t cHits = 0; + for (uint32_t i = 0; i < RT_ELEMENTS(g_aRTFsIsoNamespaces); i++) + if (fNamespaces & g_aRTFsIsoNamespaces[i].fNamespace) + { + PRTFSISOMAKERNAMESPACE pNamespace = (PRTFSISOMAKERNAMESPACE)((uintptr_t)pThis + g_aRTFsIsoNamespaces[i].offNamespace); + if (pNamespace->uLevel > 0) + { + PRTFSISOMAKERNAME pName; + int rc = rtFsIsoMakerWalkPathBySpec(pNamespace, pszPath, &pName); + if (RT_SUCCESS(rc)) + { + pName->gid = idGroup; + cHits++; + } + } + } + + if (pcHits) + *pcHits = cHits; + if (cHits > 0) + return VINF_SUCCESS; + return VWRN_NOT_FOUND; +} + + + + + + +/* + * + * El Torito Booting. + * El Torito Booting. + * El Torito Booting. + * El Torito Booting. + * + */ + +/** + * Ensures that we've got a boot catalog file. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerEnsureBootCatFile(PRTFSISOMAKERINT pThis) +{ + if (pThis->pBootCatFile) + return VINF_SUCCESS; + + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* Create a VFS memory file for backing up the file. */ + RTVFSFILE hVfsFile; + int rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, RTFSISOMAKER_SECTOR_SIZE, &hVfsFile); + if (RT_SUCCESS(rc)) + { + /* Create an unnamed VFS backed file and mark it as non-orphaned. */ + PRTFSISOMAKERFILE pFile; + rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, NULL, 0, &pFile); + if (RT_SUCCESS(rc)) + { + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_VFS_FILE; + pFile->u.hVfsFile = hVfsFile; + pFile->Core.cNotOrphan = 1; + + /* Save file pointer and allocate a volume descriptor. */ + pThis->pBootCatFile = pFile; + pThis->cVolumeDescriptors++; + + return VINF_SUCCESS; + } + RTVfsFileRelease(hVfsFile); + } + return rc; +} + + +/** + * Queries the configuration index of the boot catalog file object. + * + * The boot catalog file is created as necessary, thus this have to be a query + * rather than a getter since object creation may fail. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param pidxObj Where to return the configuration index. + */ +RTDECL(int) RTFsIsoMakerQueryObjIdxForBootCatalog(RTFSISOMAKER hIsoMaker, uint32_t *pidxObj) +{ + /* + * Validate input. + */ + AssertPtrReturn(pidxObj, VERR_INVALID_POINTER); + *pidxObj = UINT32_MAX; + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + + /* + * Do the job. + */ + int rc = rtFsIsoMakerEnsureBootCatFile(pThis); + if (RT_SUCCESS(rc)) + *pidxObj = pThis->pBootCatFile->Core.idxObj; + return rc; +} + + +/** + * Sets the boot catalog backing file. + * + * The content of the given file will be discarded and replaced with the boot + * catalog, the naming and file attributes (other than size) will be retained. + * + * This API exists mainly to assist when importing ISOs. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxObj The configuration index of the file. + */ +RTDECL(int) RTFsIsoMakerBootCatSetFile(RTFSISOMAKER hIsoMaker, uint32_t idxObj) +{ + /* + * Validate and translate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + + PRTFSISOMAKEROBJ pObj = rtFsIsoMakerIndexToObj(pThis, idxObj); + AssertReturn(pObj, VERR_OUT_OF_RANGE); + AssertReturn(pObj->enmType == RTFSISOMAKEROBJTYPE_FILE, VERR_WRONG_TYPE); + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + AssertReturn( pFile->enmSrcType == RTFSISOMAKERSRCTYPE_PATH + || pFile->enmSrcType == RTFSISOMAKERSRCTYPE_COMMON + || pFile->enmSrcType == RTFSISOMAKERSRCTYPE_VFS_FILE, + VERR_WRONG_TYPE); + + /* + * To reduce the possible combinations here, make sure there is a boot cat + * file that we're "replacing". + */ + int rc = rtFsIsoMakerEnsureBootCatFile(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Grab a reference to the boot cat memory VFS so we can destroy it + * later using regular destructors. + */ + PRTFSISOMAKERFILE pOldFile = pThis->pBootCatFile; + RTVFSFILE hVfsFile = pOldFile->u.hVfsFile; + uint32_t cRefs = RTVfsFileRetain(hVfsFile); + if (cRefs != UINT32_MAX) + { + /* + * Try remove the existing boot file. + */ + pOldFile->Core.cNotOrphan--; + pThis->pBootCatFile = NULL; + rc = rtFsIsoMakerObjRemoveWorker(pThis, &pOldFile->Core); + if (RT_SUCCESS(rc)) + { + /* + * Just morph pFile into a boot catalog file. + */ + if (pFile->enmSrcType == RTFSISOMAKERSRCTYPE_VFS_FILE) + { + RTVfsFileRelease(pFile->u.hVfsFile); + pFile->u.hVfsFile = NIL_RTVFSFILE; + } + + pThis->cbData -= RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE); + pFile->cbData = 0; + pFile->Core.cNotOrphan++; + pFile->enmSrcType = RTFSISOMAKERSRCTYPE_VFS_FILE; + pFile->u.hVfsFile = hVfsFile; + + pThis->pBootCatFile = pFile; + + return VINF_SUCCESS; + } + + pThis->pBootCatFile = pOldFile; + pOldFile->Core.cNotOrphan++; + RTVfsFileRelease(hVfsFile); + } + else + rc = VERR_ISOMK_IPE_BOOT_CAT_FILE; + } + return rc; +} + + +/** + * Set the validation entry of the boot catalog (this is the first entry). + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idPlatform The platform ID + * (ISO9660_ELTORITO_PLATFORM_ID_XXX). + * @param pszString CD/DVD-ROM identifier. Optional. + */ +RTDECL(int) RTFsIsoMakerBootCatSetValidationEntry(RTFSISOMAKER hIsoMaker, uint8_t idPlatform, const char *pszString) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + size_t cchString = 0; + if (pszString) + { + cchString = RTStrCalcLatin1Len(pszString); + AssertReturn(cchString < RT_SIZEOFMEMB(ISO9660ELTORITOVALIDATIONENTRY, achId), VERR_OUT_OF_RANGE); + } + + /* + * Make sure we've got a boot file. + */ + int rc = rtFsIsoMakerEnsureBootCatFile(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Construct the entry data. + */ + ISO9660ELTORITOVALIDATIONENTRY Entry; + Entry.bHeaderId = ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY; + Entry.bPlatformId = idPlatform; + Entry.u16Reserved = 0; + RT_ZERO(Entry.achId); + if (cchString) + { + char *pszTmp = Entry.achId; + rc = RTStrToLatin1Ex(pszString, RTSTR_MAX, &pszTmp, sizeof(Entry.achId), NULL); + AssertRC(rc); + } + Entry.u16Checksum = 0; + Entry.bKey1 = ISO9660_ELTORITO_KEY_BYTE_1; + Entry.bKey2 = ISO9660_ELTORITO_KEY_BYTE_2; + + /* Calc checksum. */ + uint16_t uSum = 0; + uint16_t const *pu16Src = (uint16_t const *)&Entry; + uint16_t cLeft = sizeof(Entry) / sizeof(uint16_t); + while (cLeft-- > 0) + { + uSum += RT_LE2H_U16(*pu16Src); + pu16Src++; + } + Entry.u16Checksum = RT_H2LE_U16((uint16_t)0 - uSum); + + /* + * Write the entry and update our internal tracker. + */ + rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, 0, &Entry, sizeof(Entry), NULL); + if (RT_SUCCESS(rc)) + { + pThis->aBootCatEntries[0].bType = ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY; + pThis->aBootCatEntries[0].cEntries = 2; + } + } + return rc; +} + + +/** + * Set the validation entry of the boot catalog (this is the first entry). + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxBootCat The boot catalog entry. Zero and two are + * invalid. Must be less than 63. + * @param idxImageObj The configuration index of the boot image. + * @param bBootMediaType The media type and flag (not for entry 1) + * (ISO9660_ELTORITO_BOOT_MEDIA_TYPE_XXX, + * ISO9660_ELTORITO_BOOT_MEDIA_F_XXX). + * @param bSystemType The partitiona table system ID. + * @param fBootable Whether it's a bootable entry or if we just want + * the BIOS to setup the emulation without booting + * it. + * @param uLoadSeg The load address divided by 0x10 (i.e. the real + * mode segment number). + * @param cSectorsToLoad Number of emulated sectors to load. + * @param bSelCritType The selection criteria type, if none pass + * ISO9660_ELTORITO_SEL_CRIT_TYPE_NONE. + * @param pvSelCritData Pointer to the selection criteria data. + * @param cbSelCritData Size of the selection criteria data. + */ +RTDECL(int) RTFsIsoMakerBootCatSetSectionEntry(RTFSISOMAKER hIsoMaker, uint32_t idxBootCat, uint32_t idxImageObj, + uint8_t bBootMediaType, uint8_t bSystemType, bool fBootable, + uint16_t uLoadSeg, uint16_t cSectorsToLoad, + uint8_t bSelCritType, void const *pvSelCritData, size_t cbSelCritData) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)rtFsIsoMakerIndexToObj(pThis, idxImageObj); + AssertReturn(pFile, VERR_OUT_OF_RANGE); + AssertReturn((bBootMediaType & ISO9660_ELTORITO_BOOT_MEDIA_TYPE_MASK) <= ISO9660_ELTORITO_BOOT_MEDIA_TYPE_HARD_DISK, + VERR_INVALID_PARAMETER); + AssertReturn(!(bBootMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_MASK) || idxBootCat != 1, + VERR_INVALID_PARAMETER); + + AssertReturn(idxBootCat != 0 && idxBootCat != 2 && idxBootCat < RT_ELEMENTS(pThis->aBootCatEntries) - 1U, VERR_OUT_OF_RANGE); + + size_t cExtEntries = 0; + if (bSelCritType == ISO9660_ELTORITO_SEL_CRIT_TYPE_NONE) + AssertReturn(cbSelCritData == 0, VERR_INVALID_PARAMETER); + else + { + AssertReturn(idxBootCat > 2, VERR_INVALID_PARAMETER); + if (cbSelCritData > 0) + { + AssertPtrReturn(pvSelCritData, VERR_INVALID_POINTER); + + if (cbSelCritData <= RT_SIZEOFMEMB(ISO9660ELTORITOSECTIONENTRY, abSelectionCriteria)) + cExtEntries = 0; + else + { + cExtEntries = (cbSelCritData - RT_SIZEOFMEMB(ISO9660ELTORITOSECTIONENTRY, abSelectionCriteria) + + RT_SIZEOFMEMB(ISO9660ELTORITOSECTIONENTRYEXT, abSelectionCriteria) - 1) + / RT_SIZEOFMEMB(ISO9660ELTORITOSECTIONENTRYEXT, abSelectionCriteria); + AssertReturn(cExtEntries + 1 < RT_ELEMENTS(pThis->aBootCatEntries) - 1, VERR_TOO_MUCH_DATA); + } + } + } + + /* + * Make sure we've got a boot file. + */ + int rc = rtFsIsoMakerEnsureBootCatFile(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Construct the entry. + */ + union + { + ISO9660ELTORITOSECTIONENTRY Entry; + ISO9660ELTORITOSECTIONENTRYEXT ExtEntry; + } u; + u.Entry.bBootIndicator = fBootable ? ISO9660_ELTORITO_BOOT_INDICATOR_BOOTABLE + : ISO9660_ELTORITO_BOOT_INDICATOR_NOT_BOOTABLE; + u.Entry.bBootMediaType = bBootMediaType; + u.Entry.uLoadSeg = RT_H2LE_U16(uLoadSeg); + u.Entry.bSystemType = cExtEntries == 0 + ? bSystemType & ~ISO9660_ELTORITO_BOOT_MEDIA_F_CONTINUATION + : bSystemType | ISO9660_ELTORITO_BOOT_MEDIA_F_CONTINUATION; + u.Entry.bUnused = 0; + u.Entry.cEmulatedSectorsToLoad = RT_H2LE_U16(cSectorsToLoad); + u.Entry.offBootImage = 0; + u.Entry.bSelectionCriteriaType = bSelCritType; + RT_ZERO(u.Entry.abSelectionCriteria); + if (cbSelCritData > 0) + memcpy(u.Entry.abSelectionCriteria, pvSelCritData, RT_MIN(cbSelCritData, sizeof(u.Entry.abSelectionCriteria))); + + /* + * Write it and update our internal tracker. + */ + rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, ISO9660_ELTORITO_ENTRY_SIZE * idxBootCat, + &u.Entry, sizeof(u.Entry), NULL); + if (RT_SUCCESS(rc)) + { + if (pThis->aBootCatEntries[idxBootCat].pBootFile != pFile) + { + if (pThis->aBootCatEntries[idxBootCat].pBootFile) + pThis->aBootCatEntries[idxBootCat].pBootFile->Core.cNotOrphan--; + pFile->Core.cNotOrphan++; + pThis->aBootCatEntries[idxBootCat].pBootFile = pFile; + } + + pThis->aBootCatEntries[idxBootCat].bType = u.Entry.bBootIndicator; + pThis->aBootCatEntries[idxBootCat].cEntries = 1; + } + + /* + * Do add further extension entries with selection criteria. + */ + if (cExtEntries) + { + uint8_t const *pbSrc = (uint8_t const *)pvSelCritData; + size_t cbSrc = cbSelCritData; + pbSrc += sizeof(u.Entry.abSelectionCriteria); + cbSrc -= sizeof(u.Entry.abSelectionCriteria); + + while (cbSrc > 0) + { + u.ExtEntry.bExtensionId = ISO9660_ELTORITO_SECTION_ENTRY_EXT_ID; + if (cbSrc > sizeof(u.ExtEntry.abSelectionCriteria)) + { + u.ExtEntry.fFlags = ISO9660_ELTORITO_SECTION_ENTRY_EXT_F_MORE; + memcpy(u.ExtEntry.abSelectionCriteria, pbSrc, sizeof(u.ExtEntry.abSelectionCriteria)); + pbSrc += sizeof(u.ExtEntry.abSelectionCriteria); + cbSrc -= sizeof(u.ExtEntry.abSelectionCriteria); + } + else + { + u.ExtEntry.fFlags = 0; + RT_ZERO(u.ExtEntry.abSelectionCriteria); + memcpy(u.ExtEntry.abSelectionCriteria, pbSrc, cbSrc); + cbSrc = 0; + } + + idxBootCat++; + rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, ISO9660_ELTORITO_ENTRY_SIZE * idxBootCat, + &u.Entry, sizeof(u.Entry), NULL); + if (RT_FAILURE(rc)) + break; + + /* update the internal tracker. */ + if (pThis->aBootCatEntries[idxBootCat].pBootFile) + { + pThis->aBootCatEntries[idxBootCat].pBootFile->Core.cNotOrphan--; + pThis->aBootCatEntries[idxBootCat].pBootFile = NULL; + } + + pThis->aBootCatEntries[idxBootCat].bType = ISO9660_ELTORITO_SECTION_ENTRY_EXT_ID; + pThis->aBootCatEntries[idxBootCat].cEntries = 1; + } + } + } + return rc; +} + + +/** + * Set the validation entry of the boot catalog (this is the first entry). + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + * @param idxBootCat The boot catalog entry. + * @param cEntries Number of entries in the section. + * @param idPlatform The platform ID + * (ISO9660_ELTORITO_PLATFORM_ID_XXX). + * @param pszString Section identifier or something. Optional. + */ +RTDECL(int) RTFsIsoMakerBootCatSetSectionHeaderEntry(RTFSISOMAKER hIsoMaker, uint32_t idxBootCat, uint32_t cEntries, + uint8_t idPlatform, const char *pszString) +{ + /* + * Validate input. + */ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + + AssertReturn(idxBootCat >= 2 && idxBootCat < RT_ELEMENTS(pThis->aBootCatEntries) - 1U, VERR_OUT_OF_RANGE); + AssertReturn(cEntries < RT_ELEMENTS(pThis->aBootCatEntries) - 2U - 1U, VERR_OUT_OF_RANGE); + AssertReturn(idxBootCat + cEntries + 1 < RT_ELEMENTS(pThis->aBootCatEntries), VERR_OUT_OF_RANGE); + + size_t cchString = 0; + if (pszString) + { + cchString = RTStrCalcLatin1Len(pszString); + AssertReturn(cchString < RT_SIZEOFMEMB(ISO9660ELTORITOVALIDATIONENTRY, achId), VERR_OUT_OF_RANGE); + } + + /* + * Make sure we've got a boot file. + */ + int rc = rtFsIsoMakerEnsureBootCatFile(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Construct the entry data. + */ + ISO9660ELTORITOSECTIONHEADER Entry; + Entry.bHeaderId = ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER; + Entry.bPlatformId = idPlatform; + Entry.cEntries = RT_H2LE_U16(cEntries); + RT_ZERO(Entry.achSectionId); + if (cchString) + { + char *pszTmp = Entry.achSectionId; + rc = RTStrToLatin1Ex(pszString, RTSTR_MAX, &pszTmp, sizeof(Entry.achSectionId), NULL); + AssertRC(rc); + } + + /* + * Write the entry and update our internal tracker. + */ + rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, ISO9660_ELTORITO_ENTRY_SIZE * idxBootCat, + &Entry, sizeof(Entry), NULL); + if (RT_SUCCESS(rc)) + { + if (pThis->aBootCatEntries[idxBootCat].pBootFile != NULL) + { + pThis->aBootCatEntries[idxBootCat].pBootFile->Core.cNotOrphan--; + pThis->aBootCatEntries[idxBootCat].pBootFile = NULL; + } + + pThis->aBootCatEntries[idxBootCat].bType = ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER; + pThis->aBootCatEntries[idxBootCat].cEntries = cEntries + 1; + } + } + return rc; +} + + + + + +/* + * + * Image finalization. + * Image finalization. + * Image finalization. + * + */ + + +/** + * Remove any orphaned object from the disk. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerFinalizeRemoveOrphans(PRTFSISOMAKERINT pThis) +{ + for (;;) + { + uint32_t cRemoved = 0; + PRTFSISOMAKEROBJ pCur; + PRTFSISOMAKEROBJ pNext; + RTListForEachSafe(&pThis->ObjectHead, pCur, pNext, RTFSISOMAKEROBJ, Entry) + { + if ( pCur->pPrimaryName + || pCur->pJolietName + || pCur->pUdfName + || pCur->pHfsName + || pCur->cNotOrphan > 0) + { /* likely */ } + else + { + Log4(("rtFsIsoMakerFinalizeRemoveOrphans: %#x cbData=%#RX64\n", pCur->idxObj, + pCur->enmType == RTFSISOMAKEROBJTYPE_FILE ? ((PRTFSISOMAKERFILE)(pCur))->cbData : 0)); + int rc = rtFsIsoMakerObjRemoveWorker(pThis, pCur); + if (RT_SUCCESS(rc)) + cRemoved++; + else + return rc; + } + } + if (!cRemoved) + return VINF_SUCCESS; + } +} + + +/** + * Finalizes the El Torito boot stuff, part 1. + * + * This includes generating the boot catalog data and fixing the location of all + * related image files. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerFinalizeBootStuffPart1(PRTFSISOMAKERINT pThis) +{ + /* + * Anything? + */ + if (!pThis->pBootCatFile) + return VINF_SUCCESS; + + /* + * Validate the boot catalog file. + */ + AssertReturn(pThis->aBootCatEntries[0].bType == ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY, + VERR_ISOMK_BOOT_CAT_NO_VALIDATION_ENTRY); + AssertReturn(pThis->aBootCatEntries[1].pBootFile != NULL, VERR_ISOMK_BOOT_CAT_NO_DEFAULT_ENTRY); + + /* Check any sections following the default one. */ + uint32_t cEntries = 2; + while ( cEntries < RT_ELEMENTS(pThis->aBootCatEntries) - 1U + && pThis->aBootCatEntries[cEntries].cEntries > 0) + { + AssertReturn(pThis->aBootCatEntries[cEntries].bType == ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER, + VERR_ISOMK_BOOT_CAT_EXPECTED_SECTION_HEADER); + for (uint32_t i = 1; i < pThis->aBootCatEntries[cEntries].cEntries; i++) + AssertReturn(pThis->aBootCatEntries[cEntries].pBootFile != NULL, + pThis->aBootCatEntries[cEntries].cEntries == 0 + ? VERR_ISOMK_BOOT_CAT_EMPTY_ENTRY : VERR_ISOMK_BOOT_CAT_INVALID_SECTION_SIZE); + cEntries += pThis->aBootCatEntries[cEntries].cEntries; + } + + /* Save for size setting. */ + uint32_t const cEntriesInFile = cEntries + 1; + + /* Check that the remaining entries are empty. */ + while (cEntries < RT_ELEMENTS(pThis->aBootCatEntries)) + { + AssertReturn(pThis->aBootCatEntries[cEntries].cEntries == 0, VERR_ISOMK_BOOT_CAT_ERRATIC_ENTRY); + cEntries++; + } + + /* + * Fixate the size of the boot catalog file. + */ + pThis->pBootCatFile->cbData = cEntriesInFile * ISO9660_ELTORITO_ENTRY_SIZE; + pThis->cbData += RT_ALIGN_32(cEntriesInFile * ISO9660_ELTORITO_ENTRY_SIZE, RTFSISOMAKER_SECTOR_SIZE); + + /* + * Move up the boot images and boot catalog to the start of the image. + */ + for (uint32_t i = RT_ELEMENTS(pThis->aBootCatEntries) - 2; i > 0; i--) + if (pThis->aBootCatEntries[i].pBootFile) + { + RTListNodeRemove(&pThis->aBootCatEntries[i].pBootFile->Core.Entry); + RTListPrepend(&pThis->ObjectHead, &pThis->aBootCatEntries[i].pBootFile->Core.Entry); + } + + /* The boot catalog comes first. */ + RTListNodeRemove(&pThis->pBootCatFile->Core.Entry); + RTListPrepend(&pThis->ObjectHead, &pThis->pBootCatFile->Core.Entry); + + return VINF_SUCCESS; +} + + +/** + * Finalizes the El Torito boot stuff, part 1. + * + * This includes generating the boot catalog data and fixing the location of all + * related image files. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerFinalizeBootStuffPart2(PRTFSISOMAKERINT pThis) +{ + /* + * Anything? + */ + if (!pThis->pBootCatFile) + return VINF_SUCCESS; + + /* + * Fill in the descriptor. + */ + PISO9660BOOTRECORDELTORITO pDesc = pThis->pElToritoDesc; + pDesc->Hdr.bDescType = ISO9660VOLDESC_TYPE_BOOT_RECORD; + pDesc->Hdr.bDescVersion = ISO9660PRIMARYVOLDESC_VERSION; + memcpy(pDesc->Hdr.achStdId, ISO9660VOLDESC_STD_ID, sizeof(pDesc->Hdr.achStdId)); + memcpy(pDesc->achBootSystemId, RT_STR_TUPLE(ISO9660BOOTRECORDELTORITO_BOOT_SYSTEM_ID)); + pDesc->offBootCatalog = RT_H2LE_U32((uint32_t)(pThis->pBootCatFile->offData / RTFSISOMAKER_SECTOR_SIZE)); + + /* + * Update the image file locations. + */ + uint32_t cEntries = 2; + for (uint32_t i = 1; i < RT_ELEMENTS(pThis->aBootCatEntries) - 1; i++) + if (pThis->aBootCatEntries[i].pBootFile) + { + uint32_t off = pThis->aBootCatEntries[i].pBootFile->offData / RTFSISOMAKER_SECTOR_SIZE; + off = RT_H2LE_U32(off); + int rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, + i * ISO9660_ELTORITO_ENTRY_SIZE + RT_UOFFSETOF(ISO9660ELTORITOSECTIONENTRY, offBootImage), + &off, sizeof(off), NULL /*pcbWritten*/); + AssertRCReturn(rc, rc); + if (i == cEntries) + cEntries = i + 1; + } + + /* + * Write end section. + */ + ISO9660ELTORITOSECTIONHEADER Entry; + Entry.bHeaderId = ISO9660_ELTORITO_HEADER_ID_FINAL_SECTION_HEADER; + Entry.bPlatformId = ISO9660_ELTORITO_PLATFORM_ID_X86; + Entry.cEntries = 0; + RT_ZERO(Entry.achSectionId); + int rc = RTVfsFileWriteAt(pThis->pBootCatFile->u.hVfsFile, cEntries * ISO9660_ELTORITO_ENTRY_SIZE, + &Entry, sizeof(Entry), NULL /*pcbWritten*/); + AssertRCReturn(rc, rc); + + return VINF_SUCCESS; +} + + +/** + * Gathers the dirs for an ISO-9660 namespace (e.g. primary or joliet). + * + * @param pNamespace The namespace. + * @param pFinalizedDirs The finalized directory structure. The + * FinalizedDirs will be worked here. + */ +static void rtFsIsoMakerFinalizeGatherDirs(PRTFSISOMAKERNAMESPACE pNamespace, PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs) +{ + RTListInit(&pFinalizedDirs->FinalizedDirs); + + /* + * Enter the root directory (if we got one). + */ + if (!pNamespace->pRoot) + return; + PRTFSISOMAKERNAMEDIR pCurDir = pNamespace->pRoot->pDir; + RTListAppend(&pFinalizedDirs->FinalizedDirs, &pCurDir->FinalizedEntry); + do + { + /* + * Scan pCurDir and add directories. We don't need to sort anything + * here because the directory is already in path table compatible order. + */ + uint32_t cLeft = pCurDir->cChildren; + PPRTFSISOMAKERNAME ppChild = pCurDir->papChildren; + while (cLeft-- > 0) + { + PRTFSISOMAKERNAME pChild = *ppChild++; + if (pChild->pDir) + RTListAppend(&pFinalizedDirs->FinalizedDirs, &pChild->pDir->FinalizedEntry); + } + + /* + * Advance to the next directory. + */ + pCurDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pCurDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + } while (pCurDir); +} + + +/** + * Allocates space in the rock ridge spill file. + * + * @returns Spill file offset, UINT32_MAX on failure. + * @param pRRSpillFile The spill file. + * @param cbRock Number of bytes to allocate. + */ +static uint32_t rtFsIsoMakerFinalizeAllocRockRidgeSpill(PRTFSISOMAKERFILE pRRSpillFile, uint32_t cbRock) +{ + uint32_t off = pRRSpillFile->cbData; + if (ISO9660_SECTOR_SIZE - (pRRSpillFile->cbData & ISO9660_SECTOR_OFFSET_MASK) >= cbRock) + { /* likely */ } + else + { + off |= ISO9660_SECTOR_OFFSET_MASK; + off++; + AssertLogRelReturn(off > 0, UINT32_MAX); + pRRSpillFile->cbData = off; + } + pRRSpillFile->cbData += RT_ALIGN_32(cbRock, 4); + return off; +} + + +/** + * Finalizes a directory entry (i.e. namespace node). + * + * This calculates the directory record size. + * + * @returns IPRT status code. + * @param pFinalizedDirs . + * @param pName The directory entry to finalize. + * @param offInDir The offset in the directory of this record. + * @param uRockRidgeLevel This is the rock ridge level. + * @param fIsRoot Set if this is the root. + */ +static int rtFsIsoMakerFinalizeIsoDirectoryEntry(PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs, PRTFSISOMAKERNAME pName, + uint32_t offInDir, uint8_t uRockRidgeLevel, bool fIsRoot) +{ + /* Set directory and translation table offsets. (These are for + helping generating data blocks later.) */ + pName->offDirRec = offInDir; + + /* Calculate the minimal directory record size. */ + size_t cbDirRec = RT_UOFFSETOF(ISO9660DIRREC, achFileId) + pName->cbNameInDirRec + !(pName->cbNameInDirRec & 1); + AssertReturn(cbDirRec <= UINT8_MAX, VERR_FILENAME_TOO_LONG); + + pName->cbDirRec = (uint8_t)cbDirRec; + pName->cDirRecs = 1; + if (pName->pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pName->pObj; + if (pFile->cbData > UINT32_MAX) + pName->cDirRecs = (pFile->cbData + RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE - 1) / RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE; + } + + /* + * Calculate the size of the rock ridge bits we need. + */ + if (uRockRidgeLevel > 0) + { + uint16_t cbRock = 0; + uint8_t fFlags = 0; + + /* Level two starts with a 'RR' entry. */ + if (uRockRidgeLevel >= 2) + cbRock += sizeof(ISO9660RRIPRR); + + /* We always do 'PX' and 'TF' w/ 4 timestamps. */ + cbRock += sizeof(ISO9660RRIPPX) + + RT_UOFFSETOF(ISO9660RRIPTF, abPayload) + 4 * sizeof(ISO9660RECTIMESTAMP); + fFlags |= ISO9660RRIP_RR_F_PX | ISO9660RRIP_RR_F_TF; + + /* Devices needs 'PN'. */ + if ( RTFS_IS_DEV_BLOCK(pName->pObj->fMode) + || RTFS_IS_DEV_CHAR(pName->pObj->fMode)) + { + cbRock += sizeof(ISO9660RRIPPN); + fFlags |= ISO9660RRIP_RR_F_PN; + } + + /* Usually we need a 'NM' entry too. */ + if ( pName->pszRockRidgeNm != pName->szName + && pName->cchRockRidgeNm > 0 + && ( pName->cbNameInDirRec != 1 + || (uint8_t)pName->szName[0] > (uint8_t)0x01) ) + { + uint16_t cchNm = pName->cchRockRidgeNm; + while (cchNm > ISO9660RRIPNM_MAX_NAME_LEN) + { + cbRock += (uint16_t)RT_UOFFSETOF(ISO9660RRIPNM, achName) + ISO9660RRIPNM_MAX_NAME_LEN; + cchNm -= ISO9660RRIPNM_MAX_NAME_LEN; + } + cbRock += (uint16_t)RT_UOFFSETOF(ISO9660RRIPNM, achName) + cchNm; + fFlags |= ISO9660RRIP_RR_F_NM; + } + + /* Symbolic links needs a 'SL' entry. */ + if (pName->pObj->enmType == RTFSISOMAKEROBJTYPE_SYMLINK) + { + PRTFSISOMAKERSYMLINK pSymlink = (PRTFSISOMAKERSYMLINK)pName->pObj; + cbRock += pSymlink->cbSlRockRidge; + fFlags |= ISO9660RRIP_RR_F_SL; + } + + /* + * Decide where stuff goes. The '.' record of the root dir is special. + */ + pName->fRockEntries = fFlags; + if (!fIsRoot) + { + if (pName->cbDirRec + cbRock < UINT8_MAX) + { + pName->cbRockInDirRec = cbRock; + pName->cbRockSpill = 0; + pName->fRockNeedRRInDirRec = uRockRidgeLevel >= 2; + pName->fRockNeedRRInSpill = false; + } + else if (pName->cbDirRec + sizeof(ISO9660SUSPCE) < UINT8_MAX) + { + /* Try fit the 'RR' entry in the directory record, but don't bother with anything else. */ + if (uRockRidgeLevel >= 2 && pName->cbDirRec + sizeof(ISO9660SUSPCE) + sizeof(ISO9660RRIPRR) < UINT8_MAX) + { + pName->cbRockInDirRec = (uint16_t)(sizeof(ISO9660SUSPCE) + sizeof(ISO9660RRIPRR)); + cbRock -= sizeof(ISO9660RRIPRR); + pName->cbRockSpill = cbRock; + pName->fRockNeedRRInDirRec = true; + pName->fRockNeedRRInSpill = false; + } + else + { + pName->cbRockInDirRec = (uint16_t)sizeof(ISO9660SUSPCE); + pName->cbRockSpill = cbRock; + pName->fRockNeedRRInDirRec = false; + pName->fRockNeedRRInSpill = uRockRidgeLevel >= 2; + } + pName->offRockSpill = rtFsIsoMakerFinalizeAllocRockRidgeSpill(pFinalizedDirs->pRRSpillFile, cbRock); + AssertReturn(pName->offRockSpill != UINT32_MAX, VERR_ISOMK_RR_SPILL_FILE_FULL); + } + else + { + LogRel(("RTFsIsoMaker: no space for 'CE' entry: cbDirRec=%#x bytes, name=%s (%#x bytes)\n", + pName->cbDirRec, pName->szName, pName->cbNameInDirRec)); + return VERR_ISOMK_RR_NO_SPACE_FOR_CE; + } + } + else + { + /* The root starts with a 'SP' record to indicate that SUSP is being used, + this is always in the directory record. If we add a 'ER' record (big) too, + we put all but 'SP' and 'ER' in the spill file too keep things simple. */ + if (uRockRidgeLevel < 2) + { + Assert(!(fFlags & (ISO9660RRIP_RR_F_NM | ISO9660RRIP_RR_F_SL | ISO9660RRIP_RR_F_CL | ISO9660RRIP_RR_F_PL | ISO9660RRIP_RR_F_RE))); + cbRock += sizeof(ISO9660SUSPSP); + Assert(pName->cbDirRec + cbRock < UINT8_MAX); + pName->cbRockInDirRec = cbRock ; + pName->cbRockSpill = 0; + pName->fRockNeedER = false; + pName->fRockNeedRRInDirRec = false; + pName->fRockNeedRRInSpill = false; + } + else + { + pName->cbRockInDirRec = (uint16_t)(sizeof(ISO9660SUSPSP) + sizeof(ISO9660SUSPCE)); + pName->fRockNeedER = true; + pName->fRockNeedRRInSpill = true; + pName->fRockNeedRRInDirRec = false; + cbRock += ISO9660_RRIP_ER_LEN; + pName->cbRockSpill = cbRock; + pName->offRockSpill = rtFsIsoMakerFinalizeAllocRockRidgeSpill(pFinalizedDirs->pRRSpillFile, cbRock); + } + } + pName->cbDirRec += pName->cbRockInDirRec + (pName->cbRockInDirRec & 1); + Assert(pName->cbDirRec < UINT8_MAX); + } + + pName->cbDirRecTotal = pName->cbDirRec * pName->cDirRecs; + return VINF_SUCCESS; +} + + +/** + * Finalizes either a primary and secondary ISO namespace. + * + * @returns IPRT status code + * @param pThis The ISO maker instance. + * @param pNamespace The namespace. + * @param pFinalizedDirs The finalized directories structure for the + * namespace. + * @param poffData The data offset. We will allocate blocks for the + * directories and the path tables. + */ +static int rtFsIsoMakerFinalizeDirectoriesInIsoNamespace(PRTFSISOMAKERINT pThis, PRTFSISOMAKERNAMESPACE pNamespace, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs, uint64_t *poffData) +{ + int rc; + + /* The directory data comes first, so take down it's offset. */ + pFinalizedDirs->offDirs = *poffData; + + /* + * Reset the rock ridge spill file (in case we allow finalizing more than once) + * and create a new spill file if rock ridge is enabled. The directory entry + * finalize function uses this as a clue that rock ridge is enabled. + */ + if (pFinalizedDirs->pRRSpillFile) + { + pFinalizedDirs->pRRSpillFile->Core.cNotOrphan = 0; + rtFsIsoMakerObjRemoveWorker(pThis, &pFinalizedDirs->pRRSpillFile->Core); + pFinalizedDirs->pRRSpillFile = NULL; + } + if (pNamespace->uRockRidgeLevel > 0) + { + rc = rtFsIsoMakerAddUnnamedFileWorker(pThis, NULL, 0, &pFinalizedDirs->pRRSpillFile); + AssertRCReturn(rc, rc); + pFinalizedDirs->pRRSpillFile->enmSrcType = RTFSISOMAKERSRCTYPE_RR_SPILL; + pFinalizedDirs->pRRSpillFile->u.pRockSpillNamespace = pNamespace; + pFinalizedDirs->pRRSpillFile->Core.cNotOrphan = 1; + } + + uint16_t idPathTable = 1; + uint32_t cbPathTable = 0; + if (pNamespace->pRoot) + { + /* + * Precalc the directory record size for the root directory. + */ + rc = rtFsIsoMakerFinalizeIsoDirectoryEntry(pFinalizedDirs, pNamespace->pRoot, 0 /*offInDir*/, + pNamespace->uRockRidgeLevel, true /*fIsRoot*/); + AssertRCReturn(rc, rc); + + /* + * Work thru the directories. + */ + PRTFSISOMAKERNAMEDIR pCurDir; + RTListForEach(&pFinalizedDirs->FinalizedDirs, pCurDir, RTFSISOMAKERNAMEDIR, FinalizedEntry) + { + PRTFSISOMAKERNAME pCurName = pCurDir->pName; + PRTFSISOMAKERNAME pParentName = pCurName->pParent ? pCurName->pParent : pCurName; + + /* We don't do anything special for the special '.' and '..' directory + entries, instead we use the directory entry in the parent directory + with a 1 byte name (00 or 01). */ + Assert(pCurName->cbDirRec != 0); + Assert(pParentName->cbDirRec != 0); + pCurDir->cbDirRec00 = pCurName->cbDirRec - pCurName->cbNameInDirRec - !(pCurName->cbNameInDirRec & 1) + 1; + pCurDir->cbDirRec01 = pParentName->cbDirRec - pParentName->cbNameInDirRec - !(pParentName->cbNameInDirRec & 1) + 1; + + uint32_t offInDir = (uint32_t)pCurDir->cbDirRec00 + pCurDir->cbDirRec01; + + /* Finalize the directory entries. */ + uint32_t cSubDirs = 0; + uint32_t cbTransTbl = 0; + uint32_t cLeft = pCurDir->cChildren; + PPRTFSISOMAKERNAME ppChild = pCurDir->papChildren; + while (cLeft-- > 0) + { + PRTFSISOMAKERNAME pChild = *ppChild++; + rc = rtFsIsoMakerFinalizeIsoDirectoryEntry(pFinalizedDirs, pChild, offInDir, + pNamespace->uRockRidgeLevel, false /*fIsRoot*/); + AssertRCReturn(rc, rc); + + if ((RTFSISOMAKER_SECTOR_SIZE - (offInDir & RTFSISOMAKER_SECTOR_OFFSET_MASK)) < pChild->cbDirRecTotal) + { + Assert(ppChild[-1] == pChild && &ppChild[-1] != pCurDir->papChildren); + if ( pChild->cDirRecs == 1 + || pChild->cDirRecs <= RTFSISOMAKER_SECTOR_SIZE / pChild->cbDirRec) + { + ppChild[-2]->cbDirRecTotal += RTFSISOMAKER_SECTOR_SIZE - (offInDir & RTFSISOMAKER_SECTOR_OFFSET_MASK); + offInDir = (offInDir | RTFSISOMAKER_SECTOR_OFFSET_MASK) + 1; /* doesn't fit, skip to next sector. */ + Log4(("rtFsIsoMakerFinalizeDirectoriesInIsoNamespace: zero padding dir rec @%#x: %#x -> %#x; offset %#x -> %#x\n", + ppChild[-2]->offDirRec, ppChild[-2]->cbDirRec, ppChild[-2]->cbDirRecTotal, pChild->offDirRec, offInDir)); + pChild->offDirRec = offInDir; + } + /* else: too complicated and ulikely, so whatever. */ + } + + offInDir += pChild->cbDirRecTotal; + if (pChild->cchTransNm) + cbTransTbl += 2 /* type & space*/ + + RT_MAX(pChild->cchName, RTFSISOMAKER_TRANS_TBL_LEFT_PAD) + + 1 /* tab */ + + pChild->cchTransNm + + 1 /* newline */; + + if (RTFS_IS_DIRECTORY(pChild->fMode)) + cSubDirs++; + } + + /* Set the directory size and location, advancing the data offset. */ + pCurDir->cbDir = offInDir; + pCurDir->offDir = *poffData; + *poffData += RT_ALIGN_32(offInDir, RTFSISOMAKER_SECTOR_SIZE); + + /* Set the translation table file size. */ + if (pCurDir->pTransTblFile) + { + pCurDir->pTransTblFile->cbData = cbTransTbl; + pThis->cbData += RT_ALIGN_32(cbTransTbl, RTFSISOMAKER_SECTOR_SIZE); + } + + /* Add to the path table size calculation. */ + pCurDir->offPathTable = cbPathTable; + pCurDir->idPathTable = idPathTable++; + cbPathTable += RTFSISOMAKER_CALC_PATHREC_SIZE(pCurName->cbNameInDirRec); + + /* Set the hardlink count. */ + pCurName->cHardlinks = cSubDirs + 2; + + Log4(("rtFsIsoMakerFinalizeDirectoriesInIsoNamespace: idxObj=#%#x cbDir=%#08x cChildren=%#05x %s\n", + pCurDir->pName->pObj->idxObj, pCurDir->cbDir, pCurDir->cChildren, pCurDir->pName->szName)); + } + } + + /* + * Remove rock ridge spill file if we haven't got any spill. + * If we have, round the size up to a whole sector to avoid the slow path + * when reading from it. + */ + if (pFinalizedDirs->pRRSpillFile) + { + if (pFinalizedDirs->pRRSpillFile->cbData > 0) + { + pFinalizedDirs->pRRSpillFile->cbData = RT_ALIGN_64(pFinalizedDirs->pRRSpillFile->cbData, ISO9660_SECTOR_SIZE); + pThis->cbData += pFinalizedDirs->pRRSpillFile->cbData; + } + else + { + rc = rtFsIsoMakerObjRemoveWorker(pThis, &pFinalizedDirs->pRRSpillFile->Core); + if (RT_SUCCESS(rc)) + pFinalizedDirs->pRRSpillFile = NULL; + } + } + + /* + * Calculate the path table offsets and move past them. + */ + pFinalizedDirs->cbPathTable = cbPathTable; + pFinalizedDirs->offPathTableL = *poffData; + *poffData += RT_ALIGN_64(cbPathTable, RTFSISOMAKER_SECTOR_SIZE); + + pFinalizedDirs->offPathTableM = *poffData; + *poffData += RT_ALIGN_64(cbPathTable, RTFSISOMAKER_SECTOR_SIZE); + + return VINF_SUCCESS; +} + + + +/** + * Finalizes directories and related stuff. + * + * This will not generate actual directory data, but calculate the size of it + * once it's generated. Ditto for the path tables. The exception is the rock + * ridge spill file, which will be generated in memory. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param poffData The data offset (in/out). + */ +static int rtFsIsoMakerFinalizeDirectories(PRTFSISOMAKERINT pThis, uint64_t *poffData) +{ + /* + * Locate the directories, width first, inserting them in the finalized lists so + * we can process them efficiently. + */ + rtFsIsoMakerFinalizeGatherDirs(&pThis->PrimaryIso, &pThis->PrimaryIsoDirs); + rtFsIsoMakerFinalizeGatherDirs(&pThis->Joliet, &pThis->JolietDirs); + + /* + * Process the primary ISO and joliet namespaces. + */ + int rc = rtFsIsoMakerFinalizeDirectoriesInIsoNamespace(pThis, &pThis->PrimaryIso, &pThis->PrimaryIsoDirs, poffData); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerFinalizeDirectoriesInIsoNamespace(pThis, &pThis->Joliet, &pThis->JolietDirs, poffData); + if (RT_SUCCESS(rc)) + { + /* + * Later: UDF, HFS. + */ + } + return rc; +} + + +/** + * Finalizes data allocations. + * + * This will set the RTFSISOMAKERFILE::offData members. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + * @param poffData The data offset (in/out). + */ +static int rtFsIsoMakerFinalizeData(PRTFSISOMAKERINT pThis, uint64_t *poffData) +{ + pThis->offFirstFile = *poffData; + + /* + * We currently does not have any ordering prioritizing implemented, so we + * just store files in the order they were added. + */ + PRTFSISOMAKEROBJ pCur; + RTListForEach(&pThis->ObjectHead, pCur, RTFSISOMAKEROBJ, Entry) + { + if (pCur->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pCurFile = (PRTFSISOMAKERFILE)pCur; + if (pCurFile->offData == UINT64_MAX) + { + pCurFile->offData = *poffData; + *poffData += RT_ALIGN_64(pCurFile->cbData, RTFSISOMAKER_SECTOR_SIZE); + RTListAppend(&pThis->FinalizedFiles, &pCurFile->FinalizedEntry); + Log4(("rtFsIsoMakerFinalizeData: %#x @%#RX64 cbData=%#RX64\n", pCurFile->Core.idxObj, pCurFile->offData, pCurFile->cbData)); + } + + /* + * Create the boot info table. + */ + if (pCurFile->pBootInfoTable) + { + /* + * Checksum the file. + */ + int rc; + RTVFSFILE hVfsFile; + uint64_t offBase; + switch (pCurFile->enmSrcType) + { + case RTFSISOMAKERSRCTYPE_PATH: + rc = RTVfsChainOpenFile(pCurFile->u.pszSrcPath, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, + &hVfsFile, NULL, NULL); + AssertMsgRCReturn(rc, ("%s -> %Rrc\n", pCurFile->u.pszSrcPath, rc), rc); + offBase = 0; + break; + case RTFSISOMAKERSRCTYPE_VFS_FILE: + hVfsFile = pCurFile->u.hVfsFile; + offBase = 0; + rc = VINF_SUCCESS; + break; + case RTFSISOMAKERSRCTYPE_COMMON: + hVfsFile = pThis->paCommonSources[pCurFile->u.Common.idxSrc]; + offBase = pCurFile->u.Common.offData; + rc = VINF_SUCCESS; + break; + default: + AssertMsgFailedReturn(("enmSrcType=%d\n", pCurFile->enmSrcType), VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + uint32_t uChecksum = 0; + uint32_t off = 64; + uint32_t cbLeft = RT_MAX(64, (uint32_t)pCurFile->cbData) - 64; + while (cbLeft > 0) + { + union + { + uint8_t ab[_16K]; + uint32_t au32[_16K / sizeof(uint32_t)]; + } uBuf; + uint32_t cbRead = RT_MIN(sizeof(uBuf), cbLeft); + if (cbRead & 3) + RT_ZERO(uBuf); + rc = RTVfsFileReadAt(hVfsFile, offBase + off, &uBuf, cbRead, NULL); + if (RT_FAILURE(rc)) + break; + + size_t i = RT_ALIGN_Z(cbRead, sizeof(uint32_t)) / sizeof(uint32_t); + while (i-- > 0) + uChecksum += RT_LE2H_U32(uBuf.au32[i]); + + off += cbRead; + cbLeft -= cbRead; + } + + if (pCurFile->enmSrcType == RTFSISOMAKERSRCTYPE_PATH) + RTVfsFileRelease(hVfsFile); + if (RT_FAILURE(rc)) + return rc; + + /* + * Populate the structure. + */ + pCurFile->pBootInfoTable->offPrimaryVolDesc = RT_H2LE_U32(16); + pCurFile->pBootInfoTable->offBootFile = RT_H2LE_U32((uint32_t)(pCurFile->offData / RTFSISOMAKER_SECTOR_SIZE)); + pCurFile->pBootInfoTable->cbBootFile = RT_H2LE_U32((uint32_t)pCurFile->cbData); + pCurFile->pBootInfoTable->uChecksum = RT_H2LE_U32(uChecksum); + RT_ZERO(pCurFile->pBootInfoTable->auReserved); + } + } + } + + return VINF_SUCCESS; +} + + +/** + * Copies the given string as UTF-16 and pad unused space in the destination + * with spaces. + * + * @param pachDst The destination field. C type is char, but real life + * type is UTF-16 / UCS-2. + * @param cchDst The size of the destination field. + * @param pszSrc The source string. NULL is treated like empty string. + */ +static void rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(char *pachDst, size_t cchDst, const char *pszSrc) +{ + size_t cwcSrc = 0; + if (pszSrc) + { + RTUTF16 wszSrc[256]; + PRTUTF16 pwszSrc = wszSrc; + int rc = RTStrToUtf16BigEx(pszSrc, RTSTR_MAX, &pwszSrc, RT_ELEMENTS(wszSrc), &cwcSrc); + AssertRCStmt(rc, cwcSrc = 0); + + if (cwcSrc > cchDst / sizeof(RTUTF16)) + cwcSrc = cchDst / sizeof(RTUTF16); + memcpy(pachDst, wszSrc, cwcSrc * sizeof(RTUTF16)); + } + + /* Space padding. Note! cchDst can be an odd number. */ + size_t cchWritten = cwcSrc * sizeof(RTUTF16); + if (cchWritten < cchDst) + { + while (cchWritten + 2 <= cchDst) + { + pachDst[cchWritten++] = '\0'; + pachDst[cchWritten++] = ' '; + } + if (cchWritten < cchDst) + pachDst[cchWritten] = '\0'; + } +} + + +/** + * Copies the given string and pad unused space in the destination with spaces. + * + * @param pachDst The destination field. + * @param cchDst The size of the destination field. + * @param pszSrc The source string. NULL is treated like empty string. + */ +static void rtFsIsoMakerFinalizeCopyAndSpacePad(char *pachDst, size_t cchDst, const char *pszSrc) +{ + size_t cchSrc; + if (!pszSrc) + cchSrc = 0; + else + { + cchSrc = strlen(pszSrc); + if (cchSrc > cchDst) + cchSrc = cchDst; + memcpy(pachDst, pszSrc, cchSrc); + } + if (cchSrc < cchDst) + memset(&pachDst[cchSrc], ' ', cchDst - cchSrc); +} + + +/** + * Formats a timespec as an ISO-9660 ascii timestamp. + * + * @param pTime The timespec to format. + * @param pIsoTs The ISO-9660 timestamp destination buffer. + */ +static void rtFsIsoMakerTimespecToIso9660Timestamp(PCRTTIMESPEC pTime, PISO9660TIMESTAMP pIsoTs) +{ + RTTIME Exploded; + RTTimeExplode(&Exploded, pTime); + + char szTmp[64]; +#define FORMAT_FIELD(a_achDst, a_uSrc) \ + do { \ + RTStrFormatU32(szTmp, sizeof(szTmp), a_uSrc, 10, sizeof(a_achDst), sizeof(a_achDst), \ + RTSTR_F_ZEROPAD | RTSTR_F_WIDTH | RTSTR_F_PRECISION); \ + memcpy(a_achDst, szTmp, sizeof(a_achDst)); \ + } while (0) + FORMAT_FIELD(pIsoTs->achYear, Exploded.i32Year); + FORMAT_FIELD(pIsoTs->achMonth, Exploded.u8Month); + FORMAT_FIELD(pIsoTs->achDay, Exploded.u8MonthDay); + FORMAT_FIELD(pIsoTs->achHour, Exploded.u8Hour); + FORMAT_FIELD(pIsoTs->achMinute, Exploded.u8Minute); + FORMAT_FIELD(pIsoTs->achSecond, Exploded.u8Second); + FORMAT_FIELD(pIsoTs->achCentisecond, Exploded.u32Nanosecond / RT_NS_10MS); +#undef FORMAT_FIELD + pIsoTs->offUtc = 0; +} + +/** + * Formats zero ISO-9660 ascii timestamp (treated as not specified). + * + * @param pIsoTs The ISO-9660 timestamp destination buffer. + */ +static void rtFsIsoMakerZero9660Timestamp(PISO9660TIMESTAMP pIsoTs) +{ + memset(pIsoTs, '0', RT_UOFFSETOF(ISO9660TIMESTAMP, offUtc)); + pIsoTs->offUtc = 0; +} + + +/** + * Formats a timespec as an ISO-9660 record timestamp. + * + * @param pTime The timespec to format. + * @param pIsoTs The ISO-9660 timestamp destination buffer. + */ +static void rtFsIsoMakerTimespecToIso9660RecTimestamp(PCRTTIMESPEC pTime, PISO9660RECTIMESTAMP pIsoRecTs) +{ + RTTIME Exploded; + RTTimeExplode(&Exploded, pTime); + + pIsoRecTs->bYear = Exploded.i32Year >= 1900 ? Exploded.i32Year - 1900 : 0; + pIsoRecTs->bMonth = Exploded.u8Month; + pIsoRecTs->bDay = Exploded.u8MonthDay; + pIsoRecTs->bHour = Exploded.u8Hour; + pIsoRecTs->bMinute = Exploded.u8Minute; + pIsoRecTs->bSecond = Exploded.u8Second; + pIsoRecTs->offUtc = 0; +} + + +/** + * Allocate and prepare the volume descriptors. + * + * What's not done here gets done later by rtFsIsoMakerFinalizeBootStuffPart2, + * or at teh very end of the finalization by + * rtFsIsoMakerFinalizeVolumeDescriptors. + * + * @returns IPRT status code + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerFinalizePrepVolumeDescriptors(PRTFSISOMAKERINT pThis) +{ + /* + * Allocate and calc pointers. + */ + RTMemFree(pThis->pbVolDescs); + pThis->pbVolDescs = (uint8_t *)RTMemAllocZ(pThis->cVolumeDescriptors * RTFSISOMAKER_SECTOR_SIZE); + AssertReturn(pThis->pbVolDescs, VERR_NO_MEMORY); + + uint32_t offVolDescs = 0; + + pThis->pPrimaryVolDesc = (PISO9660PRIMARYVOLDESC)&pThis->pbVolDescs[offVolDescs]; + offVolDescs += RTFSISOMAKER_SECTOR_SIZE; + + if (!pThis->pBootCatFile) + pThis->pElToritoDesc = NULL; + else + { + pThis->pElToritoDesc = (PISO9660BOOTRECORDELTORITO)&pThis->pbVolDescs[offVolDescs]; + offVolDescs += RTFSISOMAKER_SECTOR_SIZE; + } + + if (!pThis->Joliet.uLevel) + pThis->pJolietVolDesc = NULL; + else + { + pThis->pJolietVolDesc = (PISO9660SUPVOLDESC)&pThis->pbVolDescs[offVolDescs]; + offVolDescs += RTFSISOMAKER_SECTOR_SIZE; + } + + pThis->pTerminatorVolDesc = (PISO9660VOLDESCHDR)&pThis->pbVolDescs[offVolDescs]; + offVolDescs += RTFSISOMAKER_SECTOR_SIZE; + + if (pThis->Udf.uLevel > 0) + { + /** @todo UDF descriptors. */ + } + AssertReturn(offVolDescs == pThis->cVolumeDescriptors * RTFSISOMAKER_SECTOR_SIZE, VERR_ISOMK_IPE_DESC_COUNT); + + /* + * This may be needed later. + */ + char szImageCreationTime[42]; + RTTimeSpecToString(&pThis->ImageCreationTime, szImageCreationTime, sizeof(szImageCreationTime)); + + /* + * Initialize the primary descriptor. + */ + PISO9660PRIMARYVOLDESC pPrimary = pThis->pPrimaryVolDesc; + + pPrimary->Hdr.bDescType = ISO9660VOLDESC_TYPE_PRIMARY; + pPrimary->Hdr.bDescVersion = ISO9660PRIMARYVOLDESC_VERSION; + memcpy(pPrimary->Hdr.achStdId, ISO9660VOLDESC_STD_ID, sizeof(pPrimary->Hdr.achStdId)); + //pPrimary->bPadding8 = 0; + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achSystemId, sizeof(pPrimary->achSystemId), pThis->PrimaryIso.pszSystemId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achVolumeId, sizeof(pPrimary->achVolumeId), + pThis->PrimaryIso.pszVolumeId ? pThis->PrimaryIso.pszVolumeId : szImageCreationTime); + //pPrimary->Unused73 = {0} + //pPrimary->VolumeSpaceSize = later + //pPrimary->abUnused89 = {0} + pPrimary->cVolumesInSet.be = RT_H2BE_U16_C(1); + pPrimary->cVolumesInSet.le = RT_H2LE_U16_C(1); + pPrimary->VolumeSeqNo.be = RT_H2BE_U16_C(1); + pPrimary->VolumeSeqNo.le = RT_H2LE_U16_C(1); + pPrimary->cbLogicalBlock.be = RT_H2BE_U16_C(RTFSISOMAKER_SECTOR_SIZE); + pPrimary->cbLogicalBlock.le = RT_H2LE_U16_C(RTFSISOMAKER_SECTOR_SIZE); + //pPrimary->cbPathTable = later + //pPrimary->offTypeLPathTable = later + //pPrimary->offOptionalTypeLPathTable = {0} + //pPrimary->offTypeMPathTable = later + //pPrimary->offOptionalTypeMPathTable = {0} + //pPrimary->RootDir = later + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achVolumeSetId, sizeof(pPrimary->achVolumeSetId), + pThis->PrimaryIso.pszVolumeSetId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achPublisherId, sizeof(pPrimary->achPublisherId), + pThis->PrimaryIso.pszPublisherId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achDataPreparerId, sizeof(pPrimary->achDataPreparerId), + pThis->PrimaryIso.pszDataPreparerId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achApplicationId, sizeof(pPrimary->achApplicationId), + pThis->PrimaryIso.pszApplicationId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achCopyrightFileId, sizeof(pPrimary->achCopyrightFileId), + pThis->PrimaryIso.pszCopyrightFileId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achAbstractFileId, sizeof(pPrimary->achAbstractFileId), + pThis->PrimaryIso.pszAbstractFileId); + rtFsIsoMakerFinalizeCopyAndSpacePad(pPrimary->achBibliographicFileId, sizeof(pPrimary->achBibliographicFileId), + pThis->PrimaryIso.pszBibliographicFileId); + rtFsIsoMakerTimespecToIso9660Timestamp(&pThis->ImageCreationTime, &pPrimary->BirthTime); + rtFsIsoMakerTimespecToIso9660Timestamp(&pThis->ImageCreationTime, &pPrimary->ModifyTime); + rtFsIsoMakerZero9660Timestamp(&pPrimary->ExpireTime); + rtFsIsoMakerZero9660Timestamp(&pPrimary->EffectiveTime); + pPrimary->bFileStructureVersion = ISO9660_FILE_STRUCTURE_VERSION; + //pPrimary->bReserved883 = 0; + //RT_ZERO(pPrimary->abAppUse); + //RT_ZERO(pPrimary->abReserved1396); + + /* + * Initialize the joliet descriptor if included. + */ + PISO9660SUPVOLDESC pJoliet = pThis->pJolietVolDesc; + if (pJoliet) + { + pJoliet->Hdr.bDescType = ISO9660VOLDESC_TYPE_SUPPLEMENTARY; + pJoliet->Hdr.bDescVersion = ISO9660SUPVOLDESC_VERSION; + memcpy(pJoliet->Hdr.achStdId, ISO9660VOLDESC_STD_ID, sizeof(pJoliet->Hdr.achStdId)); + pJoliet->fVolumeFlags = ISO9660SUPVOLDESC_VOL_F_ESC_ONLY_REG; + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achSystemId, sizeof(pJoliet->achSystemId), pThis->Joliet.pszSystemId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achVolumeId, sizeof(pJoliet->achVolumeId), + pThis->Joliet.pszVolumeId ? pThis->Joliet.pszVolumeId : szImageCreationTime); + //pJoliet->Unused73 = {0} + //pJoliet->VolumeSpaceSize = later + memset(pJoliet->abEscapeSequences, ' ', sizeof(pJoliet->abEscapeSequences)); + pJoliet->abEscapeSequences[0] = ISO9660_JOLIET_ESC_SEQ_0; + pJoliet->abEscapeSequences[1] = ISO9660_JOLIET_ESC_SEQ_1; + pJoliet->abEscapeSequences[2] = pThis->Joliet.uLevel == 1 ? ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1 + : pThis->Joliet.uLevel == 2 ? ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2 + : ISO9660_JOLIET_ESC_SEQ_2_LEVEL_3; + pJoliet->cVolumesInSet.be = RT_H2BE_U16_C(1); + pJoliet->cVolumesInSet.le = RT_H2LE_U16_C(1); + pJoliet->VolumeSeqNo.be = RT_H2BE_U16_C(1); + pJoliet->VolumeSeqNo.le = RT_H2LE_U16_C(1); + pJoliet->cbLogicalBlock.be = RT_H2BE_U16_C(RTFSISOMAKER_SECTOR_SIZE); + pJoliet->cbLogicalBlock.le = RT_H2LE_U16_C(RTFSISOMAKER_SECTOR_SIZE); + //pJoliet->cbPathTable = later + //pJoliet->offTypeLPathTable = later + //pJoliet->offOptionalTypeLPathTable = {0} + //pJoliet->offTypeMPathTable = later + //pJoliet->offOptionalTypeMPathTable = {0} + //pJoliet->RootDir = later + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achVolumeSetId, sizeof(pJoliet->achVolumeSetId), + pThis->Joliet.pszVolumeSetId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achPublisherId, sizeof(pJoliet->achPublisherId), + pThis->Joliet.pszPublisherId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achDataPreparerId, sizeof(pJoliet->achDataPreparerId), + pThis->Joliet.pszDataPreparerId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achApplicationId, sizeof(pJoliet->achApplicationId), + pThis->Joliet.pszApplicationId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achCopyrightFileId, sizeof(pJoliet->achCopyrightFileId), + pThis->Joliet.pszCopyrightFileId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achAbstractFileId, sizeof(pJoliet->achAbstractFileId), + pThis->Joliet.pszAbstractFileId); + rtFsIsoMakerFinalizeCopyAsUtf16BigAndSpacePad(pJoliet->achBibliographicFileId, sizeof(pJoliet->achBibliographicFileId), + pThis->Joliet.pszBibliographicFileId); + rtFsIsoMakerTimespecToIso9660Timestamp(&pThis->ImageCreationTime, &pJoliet->BirthTime); + rtFsIsoMakerTimespecToIso9660Timestamp(&pThis->ImageCreationTime, &pJoliet->ModifyTime); + rtFsIsoMakerZero9660Timestamp(&pJoliet->ExpireTime); + rtFsIsoMakerZero9660Timestamp(&pJoliet->EffectiveTime); + pJoliet->bFileStructureVersion = ISO9660_FILE_STRUCTURE_VERSION; + //pJoliet->bReserved883 = 0; + //RT_ZERO(pJoliet->abAppUse); + //RT_ZERO(pJoliet->abReserved1396); + } + + /* + * The ISO-9660 terminator descriptor. + */ + pThis->pTerminatorVolDesc->bDescType = ISO9660VOLDESC_TYPE_TERMINATOR; + pThis->pTerminatorVolDesc->bDescVersion = 1; + memcpy(pThis->pTerminatorVolDesc->achStdId, ISO9660VOLDESC_STD_ID, sizeof(pThis->pTerminatorVolDesc->achStdId)); + + return VINF_SUCCESS; +} + + +/** + * Finalizes the volume descriptors. + * + * This will set the RTFSISOMAKERFILE::offData members. + * + * @returns IPRT status code. + * @param pThis The ISO maker instance. + */ +static int rtFsIsoMakerFinalizeVolumeDescriptors(PRTFSISOMAKERINT pThis) +{ + AssertReturn(pThis->pbVolDescs && pThis->pPrimaryVolDesc && pThis->pTerminatorVolDesc, VERR_ISOMK_IPE_FINALIZE_1); + + /* + * Primary descriptor. + */ + PISO9660PRIMARYVOLDESC pPrimary = pThis->pPrimaryVolDesc; + + pPrimary->VolumeSpaceSize.be = RT_H2BE_U32(pThis->cbFinalizedImage / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->VolumeSpaceSize.le = RT_H2LE_U32(pThis->cbFinalizedImage / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->cbPathTable.be = RT_H2BE_U32(pThis->PrimaryIsoDirs.cbPathTable); + pPrimary->cbPathTable.le = RT_H2LE_U32(pThis->PrimaryIsoDirs.cbPathTable); + pPrimary->offTypeLPathTable = RT_H2LE_U32(pThis->PrimaryIsoDirs.offPathTableL / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->offTypeMPathTable = RT_H2BE_U32(pThis->PrimaryIsoDirs.offPathTableM / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->RootDir.DirRec.cbDirRec = sizeof(pPrimary->RootDir); + pPrimary->RootDir.DirRec.cExtAttrBlocks = 0; + pPrimary->RootDir.DirRec.offExtent.be = RT_H2BE_U32(pThis->PrimaryIso.pRoot->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->RootDir.DirRec.offExtent.le = RT_H2LE_U32(pThis->PrimaryIso.pRoot->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pPrimary->RootDir.DirRec.cbData.be = RT_H2BE_U32(pThis->PrimaryIso.pRoot->pDir->cbDir); + pPrimary->RootDir.DirRec.cbData.le = RT_H2LE_U32(pThis->PrimaryIso.pRoot->pDir->cbDir); + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pThis->PrimaryIso.pRoot->pObj->BirthTime, &pPrimary->RootDir.DirRec.RecTime); + pPrimary->RootDir.DirRec.fFileFlags = ISO9660_FILE_FLAGS_DIRECTORY; + pPrimary->RootDir.DirRec.bFileUnitSize = 0; + pPrimary->RootDir.DirRec.bInterleaveGapSize = 0; + pPrimary->RootDir.DirRec.VolumeSeqNo.be = RT_H2BE_U16_C(1); + pPrimary->RootDir.DirRec.VolumeSeqNo.le = RT_H2LE_U16_C(1); + pPrimary->RootDir.DirRec.bFileIdLength = 1; + pPrimary->RootDir.DirRec.achFileId[0] = 0x00; + + /* + * Initialize the joliet descriptor if included. + */ + PISO9660SUPVOLDESC pJoliet = pThis->pJolietVolDesc; + if (pJoliet) + { + pJoliet->VolumeSpaceSize = pPrimary->VolumeSpaceSize; + pJoliet->cbPathTable.be = RT_H2BE_U32(pThis->JolietDirs.cbPathTable); + pJoliet->cbPathTable.le = RT_H2LE_U32(pThis->JolietDirs.cbPathTable); + pJoliet->offTypeLPathTable = RT_H2LE_U32(pThis->JolietDirs.offPathTableL / RTFSISOMAKER_SECTOR_SIZE); + pJoliet->offTypeMPathTable = RT_H2BE_U32(pThis->JolietDirs.offPathTableM / RTFSISOMAKER_SECTOR_SIZE); + pJoliet->RootDir.DirRec.cbDirRec = sizeof(pJoliet->RootDir); + pJoliet->RootDir.DirRec.cExtAttrBlocks = 0; + pJoliet->RootDir.DirRec.offExtent.be = RT_H2BE_U32(pThis->Joliet.pRoot->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pJoliet->RootDir.DirRec.offExtent.le = RT_H2LE_U32(pThis->Joliet.pRoot->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pJoliet->RootDir.DirRec.cbData.be = RT_H2BE_U32(pThis->Joliet.pRoot->pDir->cbDir); + pJoliet->RootDir.DirRec.cbData.le = RT_H2LE_U32(pThis->Joliet.pRoot->pDir->cbDir); + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pThis->Joliet.pRoot->pObj->BirthTime, &pJoliet->RootDir.DirRec.RecTime); + pJoliet->RootDir.DirRec.fFileFlags = ISO9660_FILE_FLAGS_DIRECTORY; + pJoliet->RootDir.DirRec.bFileUnitSize = 0; + pJoliet->RootDir.DirRec.bInterleaveGapSize = 0; + pJoliet->RootDir.DirRec.VolumeSeqNo.be = RT_H2BE_U16_C(1); + pJoliet->RootDir.DirRec.VolumeSeqNo.le = RT_H2LE_U16_C(1); + pJoliet->RootDir.DirRec.bFileIdLength = 1; + pJoliet->RootDir.DirRec.achFileId[0] = 0x00; + } + +#if 0 /* this doesn't quite fool it. */ + /* + * isomd5sum fake. + */ + if (1) + { + uint8_t abDigest[RTMD5_HASH_SIZE]; + if (pThis->cbSysArea == 0) + RTMd5(g_abRTZero4K, ISO9660_SECTOR_SIZE, abDigest); + else + { + RTMD5CONTEXT Ctx; + RTMd5Init(&Ctx); + RTMd5Update(&Ctx, pThis->pbSysArea, RT_MIN(pThis->cbSysArea, ISO9660_SECTOR_SIZE)); + if (pThis->cbSysArea < ISO9660_SECTOR_SIZE) + RTMd5Update(&Ctx, g_abRTZero4K, ISO9660_SECTOR_SIZE - pThis->cbSysArea); + RTMd5Final(abDigest, &Ctx); + } + char szFakeHash[RTMD5_DIGEST_LEN + 1]; + RTMd5ToString(abDigest, szFakeHash, sizeof(szFakeHash)); + + size_t cch = RTStrPrintf((char *)&pPrimary->abAppUse[0], sizeof(pPrimary->abAppUse), + "ISO MD5SUM = %s;SKIPSECTORS = %u;RHLISOSTATUS=1;THIS IS JUST A FAKE!", + szFakeHash, pThis->cbFinalizedImage / RTFSISOMAKER_SECTOR_SIZE - 1); + memset(&pPrimary->abAppUse[cch], ' ', sizeof(pPrimary->abAppUse) - cch); + } +#endif + + return VINF_SUCCESS; +} + + +/** + * Finalizes the image. + * + * @returns IPRT status code. + * @param hIsoMaker The ISO maker handle. + */ +RTDECL(int) RTFsIsoMakerFinalize(RTFSISOMAKER hIsoMaker) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(!pThis->fFinalized, VERR_WRONG_ORDER); + + /* + * Remove orphaned objects and allocate volume descriptors. + */ + int rc = rtFsIsoMakerFinalizeRemoveOrphans(pThis); + if (RT_FAILURE(rc)) + return rc; + AssertReturn(pThis->cObjects > 0, VERR_NO_DATA); + AssertReturn(pThis->PrimaryIso.pRoot || pThis->PrimaryIso.uLevel == 0, VERR_NO_DATA); + AssertReturn(pThis->Joliet.pRoot || pThis->Joliet.uLevel == 0, VERR_NO_DATA); + + rc = rtFsIsoMakerFinalizePrepVolumeDescriptors(pThis); + if (RT_FAILURE(rc)) + return rc; + + /* + * If there is any boot related stuff to be included, it ends up right after + * the descriptors. + */ + uint64_t offData = _32K + pThis->cVolumeDescriptors * RTFSISOMAKER_SECTOR_SIZE; + rc = rtFsIsoMakerFinalizeBootStuffPart1(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Directories and path tables comes next. + */ + rc = rtFsIsoMakerFinalizeDirectories(pThis, &offData); + if (RT_SUCCESS(rc)) + { + /* + * Then we store the file data. + */ + rc = rtFsIsoMakerFinalizeData(pThis, &offData); + if (RT_SUCCESS(rc)) + { + pThis->cbFinalizedImage = offData + pThis->cbImagePadding; + + /* + * Do a 2nd pass over the boot stuff to finalize locations. + */ + rc = rtFsIsoMakerFinalizeBootStuffPart2(pThis); + if (RT_SUCCESS(rc)) + { + /* + * Finally, finalize the volume descriptors as they depend on some of the + * block allocations done in the previous steps. + */ + rc = rtFsIsoMakerFinalizeVolumeDescriptors(pThis); + if (RT_SUCCESS(rc)) + { + pThis->fFinalized = true; + return VINF_SUCCESS; + } + } + } + } + } + return rc; +} + + + + + +/* + * + * Image I/O. + * Image I/O. + * Image I/O. + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Close(void *pvThis) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + + RTFsIsoMakerRelease(pThis->pIsoMaker); + pThis->pIsoMaker = NULL; + + if (pThis->hVfsSrcFile != NIL_RTVFSFILE) + { + RTVfsFileRelease(pThis->hVfsSrcFile); + pThis->hVfsSrcFile = NIL_RTVFSFILE; + } + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + PRTFSISOMAKERINT pIsoMaker = pThis->pIsoMaker; + + + pObjInfo->cbObject = pIsoMaker->cbFinalizedImage; + pObjInfo->cbAllocated = pIsoMaker->cbFinalizedImage; + pObjInfo->AccessTime = pIsoMaker->ImageCreationTime; + pObjInfo->ModificationTime = pIsoMaker->ImageCreationTime; + pObjInfo->ChangeTime = pIsoMaker->ImageCreationTime; + pObjInfo->BirthTime = pIsoMaker->ImageCreationTime; + pObjInfo->Attr.fMode = 0444 | RTFS_TYPE_FILE | RTFS_DOS_READONLY; + + switch (enmAddAttr) + { + case RTFSOBJATTRADD_NOTHING: + enmAddAttr = RTFSOBJATTRADD_UNIX; + RT_FALL_THRU(); + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.u.Unix.uid = NIL_RTUID; + pObjInfo->Attr.u.Unix.gid = NIL_RTGID; + pObjInfo->Attr.u.Unix.cHardlinks = 1; + pObjInfo->Attr.u.Unix.INodeIdDevice = 0; + pObjInfo->Attr.u.Unix.INodeId = 0; + pObjInfo->Attr.u.Unix.fFlags = 0; + pObjInfo->Attr.u.Unix.GenerationId = 0; + pObjInfo->Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID; + pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID; + pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_EASIZE: + pObjInfo->Attr.u.EASize.cb = 0; + break; + + default: + AssertFailedReturn(VERR_INVALID_PARAMETER); + } + pObjInfo->Attr.enmAdditional = enmAddAttr; + + return VINF_SUCCESS; +} + + +/** + * Generates the 'SL' records for a symbolic link. + * + * This is used both when generating directories records, spill file data and + * when creating the symbolic link. + * + * @returns Number of bytes produced. Negative IPRT status if buffer overflow. + * @param pszTarget The symbolic link target to encode. + * @param pbBuf The output buffer. + * @param cbBuf The size of the output buffer. + */ +static ssize_t rtFsIsoMakerOutFile_RockRidgeGenSL(const char *pszTarget, uint8_t *pbBuf, size_t cbBuf) +{ + Assert(*pszTarget != '\0'); + + PISO9660RRIPSL pEntry = (PISO9660RRIPSL)pbBuf; + pEntry->Hdr.bSig1 = ISO9660RRIPSL_SIG1; + pEntry->Hdr.bSig2 = ISO9660RRIPSL_SIG2; + pEntry->Hdr.cbEntry = 0; /* set later. */ + pEntry->Hdr.bVersion = ISO9660RRIPSL_VER; + pEntry->fFlags = 0; + size_t offEntry = 0; + size_t off = RT_UOFFSETOF(ISO9660RRIPSL, abComponents); + + /* Does it start with a root slash? */ + if (RTPATH_IS_SLASH(*pszTarget)) + { + pbBuf[off++] = ISO9660RRIP_SL_C_ROOT; + pbBuf[off++] = 0; + pszTarget++; + } + + for (;;) + { + /* Find the end of the component. */ + size_t cchComponent = 0; + char ch; + while ((ch = pszTarget[cchComponent]) != '\0' && !RTPATH_IS_SLASH(ch)) + cchComponent++; + + /* Check for dots and figure out how much space we need. */ + uint8_t fFlags; + size_t cbNeeded; + if (cchComponent == 1 && *pszTarget == '.') + { + fFlags = ISO9660RRIP_SL_C_CURRENT; + cbNeeded = 2; + } + else if (cchComponent == 2 && pszTarget[0] == '.' && pszTarget[1] == '.') + { + fFlags = ISO9660RRIP_SL_C_PARENT; + cbNeeded = 2; + } + else + { + fFlags = 0; + cbNeeded = 2 + cchComponent; + } + + /* Split the SL record if we're out of space. */ + if ( off - offEntry + cbNeeded < UINT8_MAX + && off + cbNeeded <= cbBuf) + { /* likely */ } + else if (cbNeeded + RT_UOFFSETOF(ISO9660RRIPSL, abComponents) < UINT8_MAX) + { + AssertReturn(off + cbNeeded + RT_UOFFSETOF(ISO9660RRIPSL, abComponents) <= cbBuf, VERR_BUFFER_OVERFLOW); + Assert(off - offEntry < UINT8_MAX); + pEntry->Hdr.cbEntry = (uint8_t)(off - offEntry); + pEntry->fFlags |= ISO9660RRIP_SL_F_CONTINUE; + + offEntry = off; + pEntry = (PISO9660RRIPSL)&pbBuf[off]; + pEntry->Hdr.bSig1 = ISO9660RRIPSL_SIG1; + pEntry->Hdr.bSig2 = ISO9660RRIPSL_SIG2; + pEntry->Hdr.cbEntry = 0; /* set later. */ + pEntry->Hdr.bVersion = ISO9660RRIPSL_VER; + pEntry->fFlags = 0; + } + else + { + /* Special case: component doesn't fit in a single SL entry. */ + do + { + if (off - offEntry + 3 < UINT8_MAX) + { + size_t cchLeft = UINT8_MAX - 1 - (off - offEntry) - 2; + size_t cchToCopy = RT_MIN(cchLeft, cchComponent); + AssertReturn(off + 2 + cchToCopy <= cbBuf, VERR_BUFFER_OVERFLOW); + pbBuf[off++] = cchToCopy < cchComponent ? ISO9660RRIP_SL_C_CONTINUE : 0; + pbBuf[off++] = (uint8_t)cchToCopy; + memcpy(&pbBuf[off], pszTarget, cchToCopy); + off += cchToCopy; + pszTarget += cchToCopy; + cchComponent -= cchToCopy; + if (!cchComponent) + break; + } + + Assert(off - offEntry < UINT8_MAX); + pEntry->Hdr.cbEntry = (uint8_t)(off - offEntry); + pEntry->fFlags |= ISO9660RRIP_SL_F_CONTINUE; + + AssertReturn(off + 2 + cchComponent + RT_UOFFSETOF(ISO9660RRIPSL, abComponents) <= cbBuf, VERR_BUFFER_OVERFLOW); + offEntry = off; + pEntry = (PISO9660RRIPSL)&pbBuf[off]; + pEntry->Hdr.bSig1 = ISO9660RRIPSL_SIG1; + pEntry->Hdr.bSig2 = ISO9660RRIPSL_SIG2; + pEntry->Hdr.cbEntry = 0; /* set later. */ + pEntry->Hdr.bVersion = ISO9660RRIPSL_VER; + pEntry->fFlags = 0; + } while (cchComponent > 0); + if (ch == '\0') + break; + pszTarget++; + continue; + } + + /* Produce the record. */ + pbBuf[off++] = fFlags; + pbBuf[off++] = (uint8_t)(cbNeeded - 2); + if (cchComponent > 0) + { + memcpy(&pbBuf[off], pszTarget, cbNeeded - 2); + off += cbNeeded - 2; + } + + if (ch == '\0') + break; + pszTarget += cchComponent + 1; + } + + Assert(off - offEntry < UINT8_MAX); + pEntry->Hdr.cbEntry = (uint8_t)(off - offEntry); + return off; +} + + +/** + * Generates rock ridge data. + * + * This is used both for the directory record and for the spill file ('CE'). + * + * @param pName The name to generate rock ridge info for. + * @param pbSys The output buffer. + * @param cbSys The size of the output buffer. + * @param fInSpill Indicates whether we're in a spill file (true) or + * directory record (false). + */ +static void rtFsIosMakerOutFile_GenerateRockRidge(PRTFSISOMAKERNAME pName, uint8_t *pbSys, size_t cbSys, bool fInSpill) +{ + /* + * Deal with records specific to the root directory '.' entry. + */ + if (pName->pParent != NULL) + { /* likely */ } + else + { + if (!fInSpill) + { + PISO9660SUSPSP pSP = (PISO9660SUSPSP)pbSys; + Assert(cbSys >= sizeof(*pSP)); + pSP->Hdr.bSig1 = ISO9660SUSPSP_SIG1; + pSP->Hdr.bSig2 = ISO9660SUSPSP_SIG2; + pSP->Hdr.cbEntry = ISO9660SUSPSP_LEN; + pSP->Hdr.bVersion = ISO9660SUSPSP_VER; + pSP->bCheck1 = ISO9660SUSPSP_CHECK1; + pSP->bCheck2 = ISO9660SUSPSP_CHECK2; + pSP->cbSkip = 0; + pbSys += sizeof(*pSP); + cbSys -= sizeof(*pSP); + } + if (pName->fRockNeedER) + { + PISO9660SUSPER pER = (PISO9660SUSPER)pbSys; + Assert(cbSys >= ISO9660_RRIP_ER_LEN); + AssertCompile(ISO9660_RRIP_ER_LEN < UINT8_MAX); + pER->Hdr.bSig1 = ISO9660SUSPER_SIG1; + pER->Hdr.bSig2 = ISO9660SUSPER_SIG2; + pER->Hdr.cbEntry = ISO9660_RRIP_ER_LEN; + pER->Hdr.bVersion = ISO9660SUSPER_VER; + pER->cchIdentifier = sizeof(ISO9660_RRIP_ID) - 1; + pER->cchDescription = sizeof(ISO9660_RRIP_DESC) - 1; + pER->cchSource = sizeof(ISO9660_RRIP_SRC) - 1; + pER->bVersion = ISO9660_RRIP_VER; + char *pchDst = &pER->achPayload[0]; /* we do this to shut up annoying clang. */ + memcpy(pchDst, RT_STR_TUPLE(ISO9660_RRIP_ID)); + pchDst += sizeof(ISO9660_RRIP_ID) - 1; + memcpy(pchDst, RT_STR_TUPLE(ISO9660_RRIP_DESC)); + pchDst += sizeof(ISO9660_RRIP_DESC) - 1; + memcpy(pchDst, RT_STR_TUPLE(ISO9660_RRIP_SRC)); + pbSys += ISO9660_RRIP_ER_LEN; + cbSys -= ISO9660_RRIP_ER_LEN; + } + } + + /* + * Deal with common stuff. + */ + if (!fInSpill ? pName->fRockNeedRRInDirRec : pName->fRockNeedRRInSpill) + { + PISO9660RRIPRR pRR = (PISO9660RRIPRR)pbSys; + Assert(cbSys >= sizeof(*pRR)); + pRR->Hdr.bSig1 = ISO9660RRIPRR_SIG1; + pRR->Hdr.bSig2 = ISO9660RRIPRR_SIG2; + pRR->Hdr.cbEntry = ISO9660RRIPRR_LEN; + pRR->Hdr.bVersion = ISO9660RRIPRR_VER; + pRR->fFlags = pName->fRockEntries; + pbSys += sizeof(*pRR); + cbSys -= sizeof(*pRR); + } + + /* + * The following entries all end up in the spill or fully in + * the directory record. + */ + if (fInSpill || pName->cbRockSpill == 0) + { + if (pName->fRockEntries & ISO9660RRIP_RR_F_PX) + { + PISO9660RRIPPX pPX = (PISO9660RRIPPX)pbSys; + Assert(cbSys >= sizeof(*pPX)); + pPX->Hdr.bSig1 = ISO9660RRIPPX_SIG1; + pPX->Hdr.bSig2 = ISO9660RRIPPX_SIG2; + pPX->Hdr.cbEntry = ISO9660RRIPPX_LEN; + pPX->Hdr.bVersion = ISO9660RRIPPX_VER; + pPX->fMode.be = RT_H2BE_U32((uint32_t)(pName->fMode & RTFS_UNIX_MASK)); + pPX->fMode.le = RT_H2LE_U32((uint32_t)(pName->fMode & RTFS_UNIX_MASK)); + pPX->cHardlinks.be = RT_H2BE_U32((uint32_t)pName->cHardlinks); + pPX->cHardlinks.le = RT_H2LE_U32((uint32_t)pName->cHardlinks); + pPX->uid.be = RT_H2BE_U32((uint32_t)pName->uid); + pPX->uid.le = RT_H2LE_U32((uint32_t)pName->uid); + pPX->gid.be = RT_H2BE_U32((uint32_t)pName->gid); + pPX->gid.le = RT_H2LE_U32((uint32_t)pName->gid); +#if 0 /* This is confusing solaris. Looks like it has code assuming inode numbers are block numbers and ends up mistaking files for the root dir. Sigh. */ + pPX->INode.be = RT_H2BE_U32((uint32_t)pName->pObj->idxObj + 1); /* Don't use zero - isoinfo doesn't like it. */ + pPX->INode.le = RT_H2LE_U32((uint32_t)pName->pObj->idxObj + 1); +#else + pPX->INode.be = 0; + pPX->INode.le = 0; +#endif + pbSys += sizeof(*pPX); + cbSys -= sizeof(*pPX); + } + + if (pName->fRockEntries & ISO9660RRIP_RR_F_TF) + { + PISO9660RRIPTF pTF = (PISO9660RRIPTF)pbSys; + pTF->Hdr.bSig1 = ISO9660RRIPTF_SIG1; + pTF->Hdr.bSig2 = ISO9660RRIPTF_SIG2; + pTF->Hdr.cbEntry = Iso9660RripTfCalcLength(ISO9660RRIPTF_F_BIRTH | ISO9660RRIPTF_F_MODIFY | ISO9660RRIPTF_F_ACCESS | ISO9660RRIPTF_F_CHANGE); + Assert(cbSys >= pTF->Hdr.cbEntry); + pTF->Hdr.bVersion = ISO9660RRIPTF_VER; + pTF->fFlags = ISO9660RRIPTF_F_BIRTH | ISO9660RRIPTF_F_MODIFY | ISO9660RRIPTF_F_ACCESS | ISO9660RRIPTF_F_CHANGE; + PISO9660RECTIMESTAMP paTimestamps = (PISO9660RECTIMESTAMP)&pTF->abPayload[0]; + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pName->pObj->BirthTime, &paTimestamps[0]); + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pName->pObj->ModificationTime, &paTimestamps[1]); + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pName->pObj->AccessedTime, &paTimestamps[2]); + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pName->pObj->ChangeTime, &paTimestamps[3]); + cbSys -= pTF->Hdr.cbEntry; + pbSys += pTF->Hdr.cbEntry; + } + + if (pName->fRockEntries & ISO9660RRIP_RR_F_PN) + { + PISO9660RRIPPN pPN = (PISO9660RRIPPN)pbSys; + Assert(cbSys >= sizeof(*pPN)); + pPN->Hdr.bSig1 = ISO9660RRIPPN_SIG1; + pPN->Hdr.bSig2 = ISO9660RRIPPN_SIG2; + pPN->Hdr.cbEntry = ISO9660RRIPPN_LEN; + pPN->Hdr.bVersion = ISO9660RRIPPN_VER; + pPN->Major.be = RT_H2BE_U32((uint32_t)RTDEV_MAJOR(pName->Device)); + pPN->Major.le = RT_H2LE_U32((uint32_t)RTDEV_MAJOR(pName->Device)); + pPN->Minor.be = RT_H2BE_U32((uint32_t)RTDEV_MINOR(pName->Device)); + pPN->Minor.le = RT_H2LE_U32((uint32_t)RTDEV_MINOR(pName->Device)); + cbSys -= sizeof(*pPN); + pbSys += sizeof(*pPN); + } + + if (pName->fRockEntries & ISO9660RRIP_RR_F_NM) + { + size_t cchSrc = pName->cchRockRidgeNm; + const char *pszSrc = pName->pszRockRidgeNm; + for (;;) + { + size_t cchThis = RT_MIN(cchSrc, ISO9660RRIPNM_MAX_NAME_LEN); + PISO9660RRIPNM pNM = (PISO9660RRIPNM)pbSys; + Assert(cbSys >= RT_UOFFSETOF_DYN(ISO9660RRIPNM, achName[cchThis])); + pNM->Hdr.bSig1 = ISO9660RRIPNM_SIG1; + pNM->Hdr.bSig2 = ISO9660RRIPNM_SIG2; + pNM->Hdr.cbEntry = (uint8_t)(RT_UOFFSETOF(ISO9660RRIPNM, achName) + cchThis); + pNM->Hdr.bVersion = ISO9660RRIPNM_VER; + pNM->fFlags = cchThis == cchSrc ? 0 : ISO9660RRIP_NM_F_CONTINUE; + memcpy(&pNM->achName[0], pszSrc, cchThis); + pbSys += RT_UOFFSETOF(ISO9660RRIPNM, achName) + cchThis; + cbSys -= RT_UOFFSETOF(ISO9660RRIPNM, achName) + cchThis; + cchSrc -= cchThis; + if (!cchSrc) + break; + } + } + + if (pName->fRockEntries & ISO9660RRIP_RR_F_SL) + { + AssertReturnVoid(pName->pObj->enmType == RTFSISOMAKEROBJTYPE_SYMLINK); + PCRTFSISOMAKERSYMLINK pSymlink = (PCRTFSISOMAKERSYMLINK)pName->pObj; + + ssize_t cbSlRockRidge = rtFsIsoMakerOutFile_RockRidgeGenSL(pSymlink->szTarget, pbSys, cbSys); + AssertReturnVoid(cbSlRockRidge > 0); + Assert(cbSys >= (size_t)cbSlRockRidge); + pbSys += (size_t)cbSlRockRidge; + cbSys -= (size_t)cbSlRockRidge; + } + } + + /* finally, zero padding. */ + if (cbSys & 1) + { + *pbSys++ = '\0'; + cbSys--; + } + + Assert(!fInSpill ? cbSys == 0 : cbSys < _2G); +} + + + + +/** + * Reads one or more sectors from a rock ridge spill file. + * + * @returns IPRT status code. + * @param pThis The ISO maker output file instance. We use the + * directory pointer hints and child index hints + * @param pIsoMaker The ISO maker. + * @param pFile The rock ridge spill file. + * @param offInFile The offset into the spill file. This is sector aligned. + * @param pbBuf The output buffer. + * @param cbToRead The number of bytes to tread. This is sector aligned. + */ +static int rtFsIsoMakerOutFile_RockRidgeSpillReadSectors(PRTFSISOMAKEROUTPUTFILE pThis, PRTFSISOMAKERINT pIsoMaker, + PRTFSISOMAKERFILE pFile, uint32_t offInFile, uint8_t *pbBuf, + size_t cbToRead) +{ + /* + * We're only working multiple of ISO 9660 sectors. + * + * The spill of one directory record will always fit entirely within a + * sector, we make sure about that during finalization. There may be + * zero padding between spill data sequences, especially on the sector + * boundrary. + */ + Assert((offInFile & ISO9660_SECTOR_OFFSET_MASK) == 0); + Assert((cbToRead & ISO9660_SECTOR_OFFSET_MASK) == 0); + Assert(cbToRead >= ISO9660_SECTOR_SIZE); + + /* + * We generate a sector at a time. + * + * So, we start by locating the first directory/child in the block offInFile + * is pointing to. + */ + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs; + PRTFSISOMAKERNAMEDIR *ppDirHint; + uint32_t *pidxChildHint; + if (pFile->u.pRockSpillNamespace->fNamespace & RTFSISOMAKER_NAMESPACE_ISO_9660) + { + pFinalizedDirs = &pIsoMaker->PrimaryIsoDirs; + ppDirHint = &pThis->pDirHintPrimaryIso; + pidxChildHint = &pThis->iChildPrimaryIso; + } + else + { + pFinalizedDirs = &pIsoMaker->JolietDirs; + ppDirHint = &pThis->pDirHintJoliet; + pidxChildHint = &pThis->iChildJoliet; + } + + /* Special case: '.' record in root dir */ + uint32_t idxChild = *pidxChildHint; + PRTFSISOMAKERNAMEDIR pDir = *ppDirHint; + if ( offInFile == 0 + && (pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry)) != NULL + && pDir->pName->cbRockSpill > 0) + { + AssertReturn(pDir, VERR_ISOMK_IPE_RR_READ); + AssertReturn(pDir->pName->offRockSpill == 0, VERR_ISOMK_IPE_RR_READ); + idxChild = 0; + } + else + { + /* Establish where to start searching from. */ + if ( !pDir + || idxChild >= pDir->cChildren + || pDir->papChildren[idxChild]->cbRockSpill == 0) + { + idxChild = 0; + pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturn(pDir, VERR_ISOMK_IPE_RR_READ); + } + + if (pDir->papChildren[idxChild]->offRockSpill == offInFile) + { /* hit, no need to search */ } + else if (pDir->papChildren[idxChild]->offRockSpill < offInFile) + { + /* search forwards */ + for (;;) + { + idxChild++; + while ( idxChild < pDir->cChildren + && ( pDir->papChildren[idxChild]->offRockSpill < offInFile + || pDir->papChildren[idxChild]->cbRockSpill == 0) ) + idxChild++; + if (idxChild < pDir->cChildren) + break; + pDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturn(pDir, VERR_ISOMK_IPE_RR_READ); + } + Assert(pDir->papChildren[idxChild]->offRockSpill == offInFile); + } + else + { + /* search backwards (no root dir concerns here) */ + for (;;) + { + while ( idxChild > 0 + && ( pDir->papChildren[idxChild - 1]->offRockSpill >= offInFile + || pDir->papChildren[idxChild - 1]->cbRockSpill == 0) ) + idxChild--; + if (pDir->papChildren[idxChild]->offRockSpill == offInFile) + break; + pDir = RTListGetPrev(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturn(pDir, VERR_ISOMK_IPE_RR_READ); + } + Assert(pDir->papChildren[idxChild]->offRockSpill == offInFile); + } + } + + /* + * Produce data. + */ + while (cbToRead > 0) + { + PRTFSISOMAKERNAME pChild; + if ( offInFile > 0 + || pDir->pName->cbRockSpill == 0 + || pDir->pName->pParent != NULL) + { + pChild = pDir->papChildren[idxChild]; + AssertReturn(pChild->offRockSpill == offInFile, VERR_ISOMK_IPE_RR_READ); + AssertReturn(pChild->cbRockSpill > 0, VERR_ISOMK_IPE_RR_READ); + idxChild++; + } + else + { /* root dir special case. */ + pChild = pDir->pName; + Assert(idxChild == 0); + Assert(pChild->pParent == NULL); + } + + AssertReturn(cbToRead >= pChild->cbRockSpill, VERR_ISOMK_IPE_RR_READ); + rtFsIosMakerOutFile_GenerateRockRidge(pDir->pName, pbBuf, cbToRead, true /*fInSpill*/); + cbToRead -= pChild->cbRockSpill; + pbBuf += pChild->cbRockSpill; + offInFile += pChild->cbRockSpill; + + /* Advance to the next name, if any. */ + uint32_t offNext = UINT32_MAX; + do + { + while (idxChild < pDir->cChildren) + { + pChild = pDir->papChildren[idxChild]; + if (pChild->cbRockSpill == 0) + Assert(pChild->offRockSpill == UINT32_MAX); + else + { + offNext = pChild->offRockSpill; + AssertReturn(offNext >= offInFile, VERR_ISOMK_IPE_RR_READ); + AssertReturn(offNext < pFile->cbData, VERR_ISOMK_IPE_RR_READ); + break; + } + idxChild++; + } + if (offNext != UINT32_MAX) + break; + pDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + idxChild = 0; + } while (pDir != NULL); + + if (offNext != UINT32_MAX) + { + uint32_t cbToZero = offNext - offInFile; + if (cbToRead > cbToZero) + RT_BZERO(pbBuf, cbToZero); + else + { + RT_BZERO(pbBuf, cbToRead); + *ppDirHint = pDir; + *pidxChildHint = idxChild; + break; + } + cbToRead -= cbToZero; + pbBuf += cbToZero; + offInFile += cbToZero; + } + else + { + RT_BZERO(pbBuf, cbToRead); + *ppDirHint = NULL; + *pidxChildHint = UINT32_MAX; + break; + } + } + + return VINF_SUCCESS; +} + + +/** + * Deals with reads that aren't an exact multiple of sectors. + * + * @returns IPRT status code. + * @param pThis The ISO maker output file instance. We use the + * directory pointer hints and child index hints + * @param pIsoMaker The ISO maker. + * @param pFile The rock ridge spill file. + * @param offInFile The offset into the spill file. + * @param pbBuf The output buffer. + * @param cbToRead The number of bytes to tread. + */ +static int rtFsIsoMakerOutFile_RockRidgeSpillReadUnaligned(PRTFSISOMAKEROUTPUTFILE pThis, PRTFSISOMAKERINT pIsoMaker, + PRTFSISOMAKERFILE pFile, uint32_t offInFile, uint8_t *pbBuf, + uint32_t cbToRead) +{ + for (;;) + { + /* + * Deal with unnaligned file offsets and sub-sector sized reads. + */ + if ( (offInFile & ISO9660_SECTOR_OFFSET_MASK) + || cbToRead < ISO9660_SECTOR_SIZE) + { + uint8_t abSectorBuf[ISO9660_SECTOR_SIZE]; + int rc = rtFsIsoMakerOutFile_RockRidgeSpillReadSectors(pThis, pIsoMaker, pFile, + offInFile & ~(uint32_t)ISO9660_SECTOR_OFFSET_MASK, + abSectorBuf, sizeof(abSectorBuf)); + if (RT_FAILURE(rc)) + return rc; + uint32_t offSrcBuf = (size_t)offInFile & (size_t)ISO9660_SECTOR_OFFSET_MASK; + uint32_t cbToCopy = RT_MIN(ISO9660_SECTOR_SIZE - offSrcBuf, cbToRead); + memcpy(pbBuf, &abSectorBuf[offSrcBuf], cbToCopy); + if (cbToCopy >= cbToRead) + return VINF_SUCCESS; + cbToRead -= cbToCopy; + offInFile += cbToCopy; + pbBuf += cbToCopy; + } + + /* + * The offset is aligned now, so try read some sectors directly into the buffer. + */ + AssertContinue((offInFile & ISO9660_SECTOR_OFFSET_MASK) == 0); + if (cbToRead >= ISO9660_SECTOR_SIZE) + { + uint32_t cbFullSectors = cbToRead & ~(uint32_t)ISO9660_SECTOR_OFFSET_MASK; + int rc = rtFsIsoMakerOutFile_RockRidgeSpillReadSectors(pThis, pIsoMaker, pFile, offInFile, pbBuf, cbFullSectors); + if (RT_FAILURE(rc)) + return rc; + if (cbFullSectors >= cbToRead) + return VINF_SUCCESS; + cbToRead -= cbFullSectors; + offInFile += cbFullSectors; + pbBuf += cbFullSectors; + } + } +} + + + +/** + * Produces the content of a TRANS.TBL file as a memory file. + * + * @returns IPRT status code. + * @param pThis The ISO maker output file instance. The file is + * returned as pThis->hVfsSrcFile. + * @param pFile The TRANS.TBL file. + */ +static int rtFsIsoMakerOutFile_ProduceTransTbl(PRTFSISOMAKEROUTPUTFILE pThis, PRTFSISOMAKERFILE pFile) +{ + /* + * Create memory file instance. + */ + RTVFSFILE hVfsFile; + int rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, pFile->cbData, &hVfsFile); + AssertRCReturn(rc, rc); + + /* + * Produce the file content. + */ + PRTFSISOMAKERNAME *ppChild = pFile->u.pTransTblDir->pDir->papChildren; + uint32_t cLeft = pFile->u.pTransTblDir->pDir->cChildren; + while (cLeft-- > 0) + { + PRTFSISOMAKERNAME pChild = *ppChild++; + if (pChild->cchTransNm) + { + /** @todo TRANS.TBL codeset, currently using UTF-8 which is probably not it. + * However, nobody uses this stuff any more, so who cares. */ + char szEntry[RTFSISOMAKER_MAX_NAME_BUF * 2 + 128]; + size_t cchEntry = RTStrPrintf(szEntry, sizeof(szEntry), "%c %-*s\t%s\n", pChild->pDir ? 'D' : 'F', + RTFSISOMAKER_TRANS_TBL_LEFT_PAD, pChild->szName, pChild->pszTransNm); + rc = RTVfsFileWrite(hVfsFile, szEntry, cchEntry, NULL); + if (RT_FAILURE(rc)) + { + RTVfsFileRelease(hVfsFile); + return rc; + } + } + } + + /* + * Check that the size matches our estimate. + */ + uint64_t cbResult = 0; + rc = RTVfsFileGetSize(hVfsFile, &cbResult); + if (RT_SUCCESS(rc) && cbResult == pFile->cbData) + { + pThis->hVfsSrcFile = hVfsFile; + return VINF_SUCCESS; + } + + AssertMsgFailed(("rc=%Rrc, cbResult=%#RX64 cbData=%#RX64\n", rc, cbResult, pFile->cbData)); + RTVfsFileRelease(hVfsFile); + return VERR_ISOMK_IPE_PRODUCE_TRANS_TBL; +} + + + +/** + * Reads file data. + * + * @returns IPRT status code + * @param pThis The instance data for the VFS file. We use this to + * keep hints about where we are and we which source + * file we've opened/created. + * @param pIsoMaker The ISO maker instance. + * @param offUnsigned The ISO image byte offset of the requested data. + * @param pbBuf The output buffer. + * @param cbBuf How much to read. + * @param pcbDone Where to return how much was read. + */ +static int rtFsIsoMakerOutFile_ReadFileData(PRTFSISOMAKEROUTPUTFILE pThis, PRTFSISOMAKERINT pIsoMaker, uint64_t offUnsigned, + uint8_t *pbBuf, size_t cbBuf, size_t *pcbDone) +{ + *pcbDone = 0; + + /* + * Figure out which file. We keep a hint in the instance. + */ + uint64_t offInFile; + PRTFSISOMAKERFILE pFile = pThis->pFileHint; + if (!pFile) + { + pFile = RTListGetFirst(&pIsoMaker->FinalizedFiles, RTFSISOMAKERFILE, FinalizedEntry); + AssertReturn(pFile, VERR_ISOMK_IPE_READ_FILE_DATA_1); + } + if ((offInFile = offUnsigned - pFile->offData) < RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE)) + { /* hit */ } + else if (offUnsigned >= pFile->offData) + { + /* Seek forwards. */ + do + { + pFile = RTListGetNext(&pIsoMaker->FinalizedFiles, pFile, RTFSISOMAKERFILE, FinalizedEntry); + AssertReturn(pFile, VERR_ISOMK_IPE_READ_FILE_DATA_2); + } while ((offInFile = offUnsigned - pFile->offData) >= RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE)); + } + else + { + /* Seek backwards. */ + do + { + pFile = RTListGetPrev(&pIsoMaker->FinalizedFiles, pFile, RTFSISOMAKERFILE, FinalizedEntry); + AssertReturn(pFile, VERR_ISOMK_IPE_READ_FILE_DATA_3); + } while ((offInFile = offUnsigned - pFile->offData) >= RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE)); + } + + /* + * Update the hint/current file. + */ + if (pThis->pFileHint != pFile) + { + pThis->pFileHint = pFile; + if (pThis->hVfsSrcFile != NIL_RTVFSFILE) + { + RTVfsFileRelease(pThis->hVfsSrcFile); + pThis->hVfsSrcFile = NIL_RTVFSFILE; + } + } + + /* + * Produce data bits according to the source type. + */ + if (offInFile < pFile->cbData) + { + int rc; + size_t cbToRead = RT_MIN(cbBuf, pFile->cbData - offInFile); + + switch (pFile->enmSrcType) + { + case RTFSISOMAKERSRCTYPE_PATH: + if (pThis->hVfsSrcFile == NIL_RTVFSFILE) + { + rc = RTVfsChainOpenFile(pFile->u.pszSrcPath, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, + &pThis->hVfsSrcFile, NULL, NULL); + AssertMsgRCReturn(rc, ("%s -> %Rrc\n", pFile->u.pszSrcPath, rc), rc); + } + rc = RTVfsFileReadAt(pThis->hVfsSrcFile, offInFile, pbBuf, cbToRead, NULL); + AssertRC(rc); + break; + + case RTFSISOMAKERSRCTYPE_VFS_FILE: + rc = RTVfsFileReadAt(pFile->u.hVfsFile, offInFile, pbBuf, cbToRead, NULL); + AssertRC(rc); + break; + + case RTFSISOMAKERSRCTYPE_COMMON: + rc = RTVfsFileReadAt(pIsoMaker->paCommonSources[pFile->u.Common.idxSrc], + pFile->u.Common.offData + offInFile, pbBuf, cbToRead, NULL); + AssertRC(rc); + break; + + case RTFSISOMAKERSRCTYPE_TRANS_TBL: + if (pThis->hVfsSrcFile == NIL_RTVFSFILE) + { + rc = rtFsIsoMakerOutFile_ProduceTransTbl(pThis, pFile); + AssertRCReturn(rc, rc); + } + rc = RTVfsFileReadAt(pThis->hVfsSrcFile, offInFile, pbBuf, cbToRead, NULL); + AssertRC(rc); + break; + + case RTFSISOMAKERSRCTYPE_RR_SPILL: + Assert(pFile->cbData < UINT32_MAX); + if ( !(offInFile & ISO9660_SECTOR_OFFSET_MASK) + && !(cbToRead & ISO9660_SECTOR_OFFSET_MASK) + && cbToRead > 0) + rc = rtFsIsoMakerOutFile_RockRidgeSpillReadSectors(pThis, pIsoMaker, pFile, (uint32_t)offInFile, + pbBuf, (uint32_t)cbToRead); + else + rc = rtFsIsoMakerOutFile_RockRidgeSpillReadUnaligned(pThis, pIsoMaker, pFile, (uint32_t)offInFile, + pbBuf, (uint32_t)cbToRead); + break; + + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + if (RT_FAILURE(rc)) + return rc; + *pcbDone = cbToRead; + + /* + * Do boot info table patching. + */ + if ( pFile->pBootInfoTable + && offInFile < 64 + && offInFile + cbToRead > 8) + { + size_t offInBuf = offInFile < 8 ? 8 - (size_t)offInFile : 0; + size_t offInTab = offInFile <= 8 ? 0 : (size_t)offInFile - 8; + size_t cbToCopy = RT_MIN(sizeof(*pFile->pBootInfoTable) - offInTab, cbToRead - offInBuf); + memcpy(&pbBuf[offInBuf], (uint8_t *)pFile->pBootInfoTable + offInTab, cbToCopy); + } + + /* + * Check if we're into the zero padding at the end of the file now. + */ + if ( cbToRead < cbBuf + && (pFile->cbData & RTFSISOMAKER_SECTOR_OFFSET_MASK) + && offInFile + cbToRead == pFile->cbData) + { + cbBuf -= cbToRead; + pbBuf += cbToRead; + size_t cbZeros = RT_MIN(cbBuf, RTFSISOMAKER_SECTOR_SIZE - (pFile->cbData & RTFSISOMAKER_SECTOR_OFFSET_MASK)); + memset(pbBuf, 0, cbZeros); + *pcbDone += cbZeros; + } + } + else + { + size_t cbZeros = RT_MIN(cbBuf, RT_ALIGN_64(pFile->cbData, RTFSISOMAKER_SECTOR_SIZE) - offInFile); + memset(pbBuf, 0, cbZeros); + *pcbDone = cbZeros; + } + return VINF_SUCCESS; +} + + +/** + * Generates ISO-9660 path table record into the specified buffer. + * + * @returns Number of bytes copied into the buffer. + * @param pName The directory namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param pbBuf The buffer. This is large enough to hold the path + * record (use RTFSISOMAKER_CALC_PATHREC_SIZE) and a zero + * RTUTF16 terminator if @a fUnicode is true. + */ +static uint32_t rtFsIsoMakerOutFile_GeneratePathRec(PRTFSISOMAKERNAME pName, bool fUnicode, bool fLittleEndian, uint8_t *pbBuf) +{ + PISO9660PATHREC pPathRec = (PISO9660PATHREC)pbBuf; + pPathRec->cbDirId = pName->cbNameInDirRec; + pPathRec->cbExtAttr = 0; + if (fLittleEndian) + { + pPathRec->offExtent = RT_H2LE_U32(pName->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pPathRec->idParentRec = RT_H2LE_U16(pName->pParent ? pName->pParent->pDir->idPathTable : 1); + } + else + { + pPathRec->offExtent = RT_H2BE_U32(pName->pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pPathRec->idParentRec = RT_H2BE_U16(pName->pParent ? pName->pParent->pDir->idPathTable : 1); + } + if (!fUnicode) + { + memcpy(&pPathRec->achDirId[0], pName->szName, pName->cbNameInDirRec); + if (pName->cbNameInDirRec & 1) + pPathRec->achDirId[pName->cbNameInDirRec] = '\0'; + } + else + { + /* Caller made sure there is space for a zero terminator character. */ + PRTUTF16 pwszTmp = (PRTUTF16)&pPathRec->achDirId[0]; + size_t cwcResult = 0; + int rc = RTStrToUtf16BigEx(pName->szName, RTSTR_MAX, &pwszTmp, pName->cbNameInDirRec / sizeof(RTUTF16) + 1, &cwcResult); + AssertRC(rc); + Assert( cwcResult * sizeof(RTUTF16) == pName->cbNameInDirRec + || (!pName->pParent && cwcResult == 0 && pName->cbNameInDirRec == 1) ); + + } + return RTFSISOMAKER_CALC_PATHREC_SIZE(pName->cbNameInDirRec); +} + + +/** + * Deals with situations where the destination buffer doesn't cover the whole + * path table record. + * + * @returns Number of bytes copied into the buffer. + * @param pName The directory namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param offInRec The offset into the path table record. + * @param pbBuf The buffer. + * @param cbBuf The buffer size. + */ +static uint32_t rtFsIsoMakerOutFile_GeneratePathRecPartial(PRTFSISOMAKERNAME pName, bool fUnicode, bool fLittleEndian, + uint32_t offInRec, uint8_t *pbBuf, size_t cbBuf) +{ + uint8_t abTmpRec[256]; + size_t cbToCopy = rtFsIsoMakerOutFile_GeneratePathRec(pName, fUnicode, fLittleEndian, abTmpRec); + cbToCopy = RT_MIN(cbBuf, cbToCopy - offInRec); + memcpy(pbBuf, &abTmpRec[offInRec], cbToCopy); + return (uint32_t)cbToCopy; +} + + +/** + * Generate path table records. + * + * This will generate record up to the end of the table. However, it will not + * supply the zero padding in the last sector, the caller is expected to take + * care of that. + * + * @returns Number of bytes written to the buffer. + * @param ppDirHint Pointer to the directory hint for the namespace. + * @param pFinalizedDirs The finalized directory data for the namespace. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param fLittleEndian Set if we're generating little endian records, clear + * if big endian records. + * @param offInTable Offset into the path table. + * @param pbBuf The output buffer. + * @param cbBuf The buffer size. + */ +static size_t rtFsIsoMakerOutFile_ReadPathTable(PRTFSISOMAKERNAMEDIR *ppDirHint, PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs, + bool fUnicode, bool fLittleEndian, uint32_t offInTable, + uint8_t *pbBuf, size_t cbBuf) +{ + /* + * Figure out which directory to start with. We keep a hint in the instance. + */ + PRTFSISOMAKERNAMEDIR pDir = *ppDirHint; + if (!pDir) + { + pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } + if (offInTable - pDir->offPathTable < RTFSISOMAKER_CALC_PATHREC_SIZE(pDir->pName->cbNameInDirRec)) + { /* hit */ } + /* Seek forwards: */ + else if (offInTable > pDir->offPathTable) + do + { + pDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } while (offInTable - pDir->offPathTable >= RTFSISOMAKER_CALC_PATHREC_SIZE(pDir->pName->cbNameInDirRec)); + /* Back to the start: */ + else if (offInTable == 0) + { + pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } + /* Seek backwards: */ + else + do + { + pDir = RTListGetPrev(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } while (offInTable - pDir->offPathTable >= RTFSISOMAKER_CALC_PATHREC_SIZE(pDir->pName->cbNameInDirRec)); + + /* + * Generate content. + */ + size_t cbDone = 0; + while ( cbBuf > 0 + && pDir) + { + PRTFSISOMAKERNAME pName = pDir->pName; + uint8_t cbRec = RTFSISOMAKER_CALC_PATHREC_SIZE(pName->cbNameInDirRec); + uint32_t cbCopied; + if ( offInTable == pDir->offPathTable + && cbBuf >= cbRec + fUnicode * 2U) + cbCopied = rtFsIsoMakerOutFile_GeneratePathRec(pName, fUnicode, fLittleEndian, pbBuf); + else + cbCopied = rtFsIsoMakerOutFile_GeneratePathRecPartial(pName, fUnicode, fLittleEndian, + offInTable - pDir->offPathTable, pbBuf, cbBuf); + cbDone += cbCopied; + offInTable += cbCopied; + pbBuf += cbCopied; + cbBuf -= cbCopied; + pDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + } + + /* + * Update the hint. + */ + *ppDirHint = pDir; + + return cbDone; +} + + +/** + * Generates ISO-9660 directory record into the specified buffer. + * + * The caller must deal with multi-extent copying and end of sector zero + * padding. + * + * @returns Number of bytes copied into the buffer (pName->cbDirRec). + * @param pName The namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16BE / UCS-2BE, i.e. we're in the joliet namespace. + * @param pbBuf The buffer. This is at least pName->cbDirRec bytes + * big (i.e. at most 256 bytes). + * @param pFinalizedDirs The finalized directory data for the namespace. + */ +static uint32_t rtFsIsoMakerOutFile_GenerateDirRec(PRTFSISOMAKERNAME pName, bool fUnicode, uint8_t *pbBuf, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs) +{ + /* + * Emit a standard ISO-9660 directory record. + */ + PISO9660DIRREC pDirRec = (PISO9660DIRREC)pbBuf; + PCRTFSISOMAKEROBJ pObj = pName->pObj; + PCRTFSISOMAKERNAMEDIR pDir = pName->pDir; + if (pDir) + { + pDirRec->offExtent.be = RT_H2BE_U32(pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pDirRec->offExtent.le = RT_H2LE_U32(pDir->offDir / RTFSISOMAKER_SECTOR_SIZE); + pDirRec->cbData.be = RT_H2BE_U32(pDir->cbDir); + pDirRec->cbData.le = RT_H2LE_U32(pDir->cbDir); + pDirRec->fFileFlags = ISO9660_FILE_FLAGS_DIRECTORY; + } + else if (pObj->enmType == RTFSISOMAKEROBJTYPE_FILE) + { + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pObj; + pDirRec->offExtent.be = RT_H2BE_U32(pFile->offData / RTFSISOMAKER_SECTOR_SIZE); + pDirRec->offExtent.le = RT_H2LE_U32(pFile->offData / RTFSISOMAKER_SECTOR_SIZE); + pDirRec->cbData.be = RT_H2BE_U32(pFile->cbData); + pDirRec->cbData.le = RT_H2LE_U32(pFile->cbData); + pDirRec->fFileFlags = 0; + } + else + { + pDirRec->offExtent.be = 0; + pDirRec->offExtent.le = 0; + pDirRec->cbData.be = 0; + pDirRec->cbData.le = 0; + pDirRec->fFileFlags = 0; + } + rtFsIsoMakerTimespecToIso9660RecTimestamp(&pObj->BirthTime, &pDirRec->RecTime); + + pDirRec->cbDirRec = pName->cbDirRec; + pDirRec->cExtAttrBlocks = 0; + pDirRec->bFileUnitSize = 0; + pDirRec->bInterleaveGapSize = 0; + pDirRec->VolumeSeqNo.be = RT_H2BE_U16_C(1); + pDirRec->VolumeSeqNo.le = RT_H2LE_U16_C(1); + pDirRec->bFileIdLength = pName->cbNameInDirRec; + + if (!fUnicode) + { + memcpy(&pDirRec->achFileId[0], pName->szName, pName->cbNameInDirRec); + if (!(pName->cbNameInDirRec & 1)) + pDirRec->achFileId[pName->cbNameInDirRec] = '\0'; + } + else + { + /* Convert to big endian UTF-16. We're using a separate buffer here + because of zero terminator (none in pDirRec) and misalignment. */ + RTUTF16 wszTmp[128]; + PRTUTF16 pwszTmp = &wszTmp[0]; + size_t cwcResult = 0; + int rc = RTStrToUtf16BigEx(pName->szName, RTSTR_MAX, &pwszTmp, RT_ELEMENTS(wszTmp), &cwcResult); + AssertRC(rc); + Assert( cwcResult * sizeof(RTUTF16) == pName->cbNameInDirRec + || (!pName->pParent && cwcResult == 0 && pName->cbNameInDirRec == 1) ); + memcpy(&pDirRec->achFileId[0], pwszTmp, pName->cbNameInDirRec); + pDirRec->achFileId[pName->cbNameInDirRec] = '\0'; + } + + /* + * Rock ridge fields if enabled. + */ + if (pName->cbRockInDirRec > 0) + { + uint8_t *pbSys = (uint8_t *)&pDirRec->achFileId[pName->cbNameInDirRec + !(pName->cbNameInDirRec & 1)]; + size_t cbSys = &pbBuf[pName->cbDirRec] - pbSys; + Assert(cbSys >= pName->cbRockInDirRec); + if (cbSys > pName->cbRockInDirRec) + RT_BZERO(&pbSys[pName->cbRockInDirRec], cbSys - pName->cbRockInDirRec); + if (pName->cbRockSpill == 0) + rtFsIosMakerOutFile_GenerateRockRidge(pName, pbSys, cbSys, false /*fInSpill*/); + else + { + /* Maybe emit SP and RR entry, before emitting the CE entry. */ + if (pName->pParent == NULL) + { + PISO9660SUSPSP pSP = (PISO9660SUSPSP)pbSys; + pSP->Hdr.bSig1 = ISO9660SUSPSP_SIG1; + pSP->Hdr.bSig2 = ISO9660SUSPSP_SIG2; + pSP->Hdr.cbEntry = ISO9660SUSPSP_LEN; + pSP->Hdr.bVersion = ISO9660SUSPSP_VER; + pSP->bCheck1 = ISO9660SUSPSP_CHECK1; + pSP->bCheck2 = ISO9660SUSPSP_CHECK2; + pSP->cbSkip = 0; + pbSys += sizeof(*pSP); + cbSys -= sizeof(*pSP); + } + if (pName->fRockNeedRRInDirRec) + { + PISO9660RRIPRR pRR = (PISO9660RRIPRR)pbSys; + pRR->Hdr.bSig1 = ISO9660RRIPRR_SIG1; + pRR->Hdr.bSig2 = ISO9660RRIPRR_SIG2; + pRR->Hdr.cbEntry = ISO9660RRIPRR_LEN; + pRR->Hdr.bVersion = ISO9660RRIPRR_VER; + pRR->fFlags = pName->fRockEntries; + pbSys += sizeof(*pRR); + cbSys -= sizeof(*pRR); + } + PISO9660SUSPCE pCE = (PISO9660SUSPCE)pbSys; + pCE->Hdr.bSig1 = ISO9660SUSPCE_SIG1; + pCE->Hdr.bSig2 = ISO9660SUSPCE_SIG2; + pCE->Hdr.cbEntry = ISO9660SUSPCE_LEN; + pCE->Hdr.bVersion = ISO9660SUSPCE_VER; + uint64_t offData = pFinalizedDirs->pRRSpillFile->offData + pName->offRockSpill; + pCE->offBlock.be = RT_H2BE_U32((uint32_t)(offData / ISO9660_SECTOR_SIZE)); + pCE->offBlock.le = RT_H2LE_U32((uint32_t)(offData / ISO9660_SECTOR_SIZE)); + pCE->offData.be = RT_H2BE_U32((uint32_t)(offData & ISO9660_SECTOR_OFFSET_MASK)); + pCE->offData.le = RT_H2LE_U32((uint32_t)(offData & ISO9660_SECTOR_OFFSET_MASK)); + pCE->cbData.be = RT_H2BE_U32((uint32_t)pName->cbRockSpill); + pCE->cbData.le = RT_H2LE_U32((uint32_t)pName->cbRockSpill); + Assert(cbSys >= sizeof(*pCE)); + } + } + + return pName->cbDirRec; +} + + +/** + * Generates ISO-9660 directory records into the specified buffer. + * + * @returns Number of bytes copied into the buffer. + * @param pName The namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16BE / UCS-2BE, i.e. we're in the joliet namespace. + * @param pbBuf The buffer. This is at least pName->cbDirRecTotal + * bytes big. + * @param pFinalizedDirs The finalized directory data for the namespace. + */ +static uint32_t rtFsIsoMakerOutFile_GenerateDirRecDirect(PRTFSISOMAKERNAME pName, bool fUnicode, uint8_t *pbBuf, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs) +{ + /* + * Normally there is just a single record without any zero padding. + */ + uint32_t cbReturn = rtFsIsoMakerOutFile_GenerateDirRec(pName, fUnicode, pbBuf, pFinalizedDirs); + if (RT_LIKELY(pName->cbDirRecTotal == cbReturn)) + return cbReturn; + Assert(cbReturn < pName->cbDirRecTotal); + + /* + * Deal with multiple records. + */ + if (pName->cDirRecs > 1) + { + Assert(pName->pObj->enmType == RTFSISOMAKEROBJTYPE_FILE); + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pName->pObj; + + /* Set max size and duplicate the first directory record cDirRecs - 1 times. */ + uint32_t const cbOne = cbReturn; + PISO9660DIRREC pDirRec = (PISO9660DIRREC)pbBuf; + pDirRec->cbData.be = RT_H2BE_U32_C(RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE); + pDirRec->cbData.le = RT_H2LE_U32_C(RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE); + pDirRec->fFileFlags |= ISO9660_FILE_FLAGS_MULTI_EXTENT; + + PISO9660DIRREC pCurDirRec = pDirRec; + uint32_t offExtent = (uint32_t)(pFile->offData / RTFSISOMAKER_SECTOR_SIZE); + Assert(offExtent == ISO9660_GET_ENDIAN(&pDirRec->offExtent)); + for (uint32_t iDirRec = 1; iDirRec < pName->cDirRecs; iDirRec++) + { + pCurDirRec = (PISO9660DIRREC)memcpy(&pbBuf[cbReturn], pDirRec, cbOne); + + offExtent += RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE / RTFSISOMAKER_SECTOR_SIZE; + pCurDirRec->offExtent.le = RT_H2LE_U32(offExtent); + + cbReturn += cbOne; + } + Assert(cbReturn <= pName->cbDirRecTotal); + + /* Adjust the size in the final record. */ + uint32_t cbDataLast = (uint32_t)(pFile->cbData % RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE); + pCurDirRec->cbData.be = RT_H2BE_U32(cbDataLast); + pCurDirRec->cbData.le = RT_H2LE_U32(cbDataLast); + pCurDirRec->fFileFlags &= ~ISO9660_FILE_FLAGS_MULTI_EXTENT; + } + + /* + * Do end of sector zero padding. + */ + if (cbReturn < pName->cbDirRecTotal) + memset(&pbBuf[cbReturn], 0, (uint32_t)pName->cbDirRecTotal - cbReturn); + + return pName->cbDirRecTotal; +} + + +/** + * Deals with situations where the destination buffer doesn't cover the whole + * directory record. + * + * @returns Number of bytes copied into the buffer. + * @param pName The namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param off The offset into the directory record. + * @param pbBuf The buffer. + * @param cbBuf The buffer size. + * @param pFinalizedDirs The finalized directory data for the namespace. + */ +static uint32_t rtFsIsoMakerOutFile_GenerateDirRecPartial(PRTFSISOMAKERNAME pName, bool fUnicode, + uint32_t off, uint8_t *pbBuf, size_t cbBuf, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs) +{ + Assert(off < pName->cbDirRecTotal); + + /* + * This is reasonably simple when there is only one directory record and + * without any padding. + */ + uint8_t abTmpBuf[256]; + Assert(pName->cbDirRec <= sizeof(abTmpBuf)); + uint32_t const cbOne = rtFsIsoMakerOutFile_GenerateDirRec(pName, fUnicode, abTmpBuf, pFinalizedDirs); + Assert(cbOne == pName->cbDirRec); + if (cbOne == pName->cbDirRecTotal) + { + uint32_t cbToCopy = RT_MIN((uint32_t)cbBuf, cbOne - off); + memcpy(pbBuf, &abTmpBuf[off], cbToCopy); + return cbToCopy; + } + Assert(cbOne < pName->cbDirRecTotal); + + /* + * Single record and zero padding? + */ + uint32_t cbCopied = 0; + if (pName->cDirRecs == 1) + { + /* Anything from the record to copy? */ + if (off < cbOne) + { + cbCopied = RT_MIN((uint32_t)cbBuf, cbOne - off); + memcpy(pbBuf, &abTmpBuf[off], cbCopied); + pbBuf += cbCopied; + cbBuf -= cbCopied; + off += cbCopied; + } + + /* Anything from the zero padding? */ + if (off >= cbOne && cbBuf > 0) + { + uint32_t cbToZero = RT_MIN((uint32_t)cbBuf, (uint32_t)pName->cbDirRecTotal - off); + memset(pbBuf, 0, cbToZero); + cbCopied += cbToZero; + } + } + /* + * Multi-extent stuff. Need to modify the cbData member as we copy. + */ + else + { + Assert(pName->pObj->enmType == RTFSISOMAKEROBJTYPE_FILE); + PRTFSISOMAKERFILE pFile = (PRTFSISOMAKERFILE)pName->pObj; + + /* Max out the size. */ + PISO9660DIRREC pDirRec = (PISO9660DIRREC)abTmpBuf; + pDirRec->cbData.be = RT_H2BE_U32_C(RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE); + pDirRec->cbData.le = RT_H2LE_U32_C(RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE); + pDirRec->fFileFlags |= ISO9660_FILE_FLAGS_MULTI_EXTENT; + + /* Copy directory records. */ + uint32_t offDirRec = pName->offDirRec; + uint32_t offExtent = pFile->offData / RTFSISOMAKER_SECTOR_SIZE; + for (uint32_t i = 0; i < pName->cDirRecs && cbBuf > 0; i++) + { + uint32_t const offInRec = off - offDirRec; + if (offInRec < cbOne) + { + /* Update the record. */ + pDirRec->offExtent.be = RT_H2BE_U32(offExtent); + pDirRec->offExtent.le = RT_H2LE_U32(offExtent); + if (i + 1 == pName->cDirRecs) + { + uint32_t cbDataLast = pFile->cbData % RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE; + pDirRec->cbData.be = RT_H2BE_U32(cbDataLast); + pDirRec->cbData.le = RT_H2LE_U32(cbDataLast); + pDirRec->fFileFlags &= ~ISO9660_FILE_FLAGS_MULTI_EXTENT; + } + + /* Copy chunk. */ + uint32_t cbToCopy = RT_MIN((uint32_t)cbBuf, cbOne - offInRec); + memcpy(pbBuf, &abTmpBuf[offInRec], cbToCopy); + cbCopied += cbToCopy; + pbBuf += cbToCopy; + cbBuf -= cbToCopy; + off += cbToCopy; + } + + offDirRec += cbOne; + offExtent += RTFSISOMAKER_MAX_ISO9660_EXTENT_SIZE / RTFSISOMAKER_SECTOR_SIZE; + } + + /* Anything from the zero padding? */ + if (off >= offDirRec && cbBuf > 0) + { + uint32_t cbToZero = RT_MIN((uint32_t)cbBuf, (uint32_t)pName->cbDirRecTotal - offDirRec); + memset(pbBuf, 0, cbToZero); + cbCopied += cbToZero; + } + } + + return cbCopied; +} + + +/** + * Generate a '.' or '..' directory record. + * + * This is the same as rtFsIsoMakerOutFile_GenerateDirRec, but with the filename + * reduced to 1 byte. + * + * @returns Number of bytes copied into the buffer. + * @param pName The directory namespace node. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param bDirId The directory ID (0x00 or 0x01). + * @param off The offset into the directory record. + * @param pbBuf The buffer. + * @param cbBuf The buffer size. + * @param pFinalizedDirs The finalized directory data for the namespace. + */ +static uint32_t rtFsIsoMakerOutFile_GenerateSpecialDirRec(PRTFSISOMAKERNAME pName, bool fUnicode, uint8_t bDirId, + uint32_t off, uint8_t *pbBuf, size_t cbBuf, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs) +{ + Assert(off < pName->cbDirRec); + Assert(pName->pDir); + + /* Generate a regular directory record. */ + uint8_t abTmpBuf[256]; + Assert(off < pName->cbDirRec); + size_t cbToCopy = rtFsIsoMakerOutFile_GenerateDirRec(pName, fUnicode, abTmpBuf, pFinalizedDirs); + Assert(cbToCopy == pName->cbDirRec); + + /* Replace the filename part. */ + PISO9660DIRREC pDirRec = (PISO9660DIRREC)abTmpBuf; + if (pDirRec->bFileIdLength != 1) + { + uint8_t offSysUse = pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1) + RT_UOFFSETOF(ISO9660DIRREC, achFileId); + uint8_t cbSysUse = pDirRec->cbDirRec - offSysUse; + if (cbSysUse > 0) + memmove(&pDirRec->achFileId[1], &abTmpBuf[offSysUse], cbSysUse); + pDirRec->bFileIdLength = 1; + cbToCopy = RT_UOFFSETOF(ISO9660DIRREC, achFileId) + 1 + cbSysUse; + pDirRec->cbDirRec = (uint8_t)cbToCopy; + } + pDirRec->achFileId[0] = bDirId; + + /* Do the copying. */ + cbToCopy = RT_MIN(cbBuf, cbToCopy - off); + memcpy(pbBuf, &abTmpBuf[off], cbToCopy); + return (uint32_t)cbToCopy; +} + + +/** + * Read directory records. + * + * This locates the directory at @a offUnsigned and generates directory records + * for it. Caller must repeat the call to get directory entries for the next + * directory should there be desire for that. + * + * @returns Number of bytes copied into @a pbBuf. + * @param ppDirHint Pointer to the directory hint for the namespace. + * @param pIsoMaker The ISO maker instance. + * @param pFinalizedDirs The finalized directory data for the namespace. + * @param fUnicode Set if the name should be translated to big endian + * UTF-16 / UCS-2, i.e. we're in the joliet namespace. + * @param offUnsigned The ISO image byte offset of the requested data. + * @param pbBuf The output buffer. + * @param cbBuf How much to read. + */ +static size_t rtFsIsoMakerOutFile_ReadDirRecords(PRTFSISOMAKERNAMEDIR *ppDirHint, PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs, + bool fUnicode, uint64_t offUnsigned, uint8_t *pbBuf, size_t cbBuf) +{ + /* + * Figure out which directory. We keep a hint in the instance. + */ + uint64_t offInDir64; + PRTFSISOMAKERNAMEDIR pDir = *ppDirHint; + if (!pDir) + { + pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } + if ((offInDir64 = offUnsigned - pDir->offDir) < RT_ALIGN_32(pDir->cbDir, RTFSISOMAKER_SECTOR_SIZE)) + { /* hit */ } + /* Seek forwards: */ + else if (offUnsigned > pDir->offDir) + do + { + pDir = RTListGetNext(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } while ((offInDir64 = offUnsigned - pDir->offDir) >= RT_ALIGN_32(pDir->cbDir, RTFSISOMAKER_SECTOR_SIZE)); + /* Back to the start: */ + else if (pFinalizedDirs->offDirs / RTFSISOMAKER_SECTOR_SIZE == offUnsigned / RTFSISOMAKER_SECTOR_SIZE) + { + pDir = RTListGetFirst(&pFinalizedDirs->FinalizedDirs, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + offInDir64 = offUnsigned - pDir->offDir; + } + /* Seek backwards: */ + else + do + { + pDir = RTListGetPrev(&pFinalizedDirs->FinalizedDirs, pDir, RTFSISOMAKERNAMEDIR, FinalizedEntry); + AssertReturnStmt(pDir, *pbBuf = 0xff, 1); + } while ((offInDir64 = offUnsigned - pDir->offDir) >= RT_ALIGN_32(pDir->cbDir, RTFSISOMAKER_SECTOR_SIZE)); + + /* + * Update the hint. + */ + *ppDirHint = pDir; + + /* + * Generate content. + */ + size_t cbDone = 0; + uint32_t offInDir = (uint32_t)offInDir64; + if (offInDir < pDir->cbDir) + { + PRTFSISOMAKERNAME pDirName = pDir->pName; + PRTFSISOMAKERNAME pParentName = pDirName->pParent ? pDirName->pParent : pDirName; + uint32_t cbSpecialRecs = (uint32_t)pDir->cbDirRec00 + pDir->cbDirRec01; + + /* + * Special '.' and/or '..' entries requested. + */ + uint32_t iChild; + if (offInDir < cbSpecialRecs) + { + /* do '.' */ + if (offInDir < pDir->cbDirRec00) + { + uint32_t cbCopied = rtFsIsoMakerOutFile_GenerateSpecialDirRec(pDirName, fUnicode, 0, offInDir, + pbBuf, cbBuf, pFinalizedDirs); + cbDone += cbCopied; + offInDir += cbCopied; + pbBuf += cbCopied; + cbBuf -= cbCopied; + } + + /* do '..' */ + if (cbBuf > 0) + { + uint32_t cbCopied = rtFsIsoMakerOutFile_GenerateSpecialDirRec(pParentName, fUnicode, 1, + offInDir - pDir->cbDirRec00, + pbBuf, cbBuf, pFinalizedDirs); + cbDone += cbCopied; + offInDir += cbCopied; + pbBuf += cbCopied; + cbBuf -= cbCopied; + } + + iChild = 0; + } + /* + * Locate the directory entry we should start with. We can do this + * using binary searching on offInDir. + */ + else + { + /** @todo binary search */ + iChild = 0; + while (iChild < pDir->cChildren) + { + PRTFSISOMAKERNAME pChild = pDir->papChildren[iChild]; + if ((offInDir - pChild->offDirRec) < pChild->cbDirRecTotal) + break; + iChild++; + } + AssertReturnStmt(iChild < pDir->cChildren, *pbBuf = 0xff, 1); + } + + /* + * Normal directory entries. + */ + while ( cbBuf > 0 + && iChild < pDir->cChildren) + { + PRTFSISOMAKERNAME pChild = pDir->papChildren[iChild]; + uint32_t cbCopied; + if ( offInDir == pChild->offDirRec + && cbBuf >= pChild->cbDirRecTotal) + cbCopied = rtFsIsoMakerOutFile_GenerateDirRecDirect(pChild, fUnicode, pbBuf, pFinalizedDirs); + else + cbCopied = rtFsIsoMakerOutFile_GenerateDirRecPartial(pChild, fUnicode, offInDir - pChild->offDirRec, + pbBuf, cbBuf, pFinalizedDirs); + + cbDone += cbCopied; + offInDir += cbCopied; + pbBuf += cbCopied; + cbBuf -= cbCopied; + iChild++; + } + + /* + * Check if we're into the zero padding at the end of the directory now. + */ + if ( cbBuf > 0 + && iChild >= pDir->cChildren) + { + size_t cbZeros = RT_MIN(cbBuf, RTFSISOMAKER_SECTOR_SIZE - (pDir->cbDir & RTFSISOMAKER_SECTOR_OFFSET_MASK)); + memset(pbBuf, 0, cbZeros); + cbDone += cbZeros; + } + } + else + { + cbDone = RT_MIN(cbBuf, RT_ALIGN_32(pDir->cbDir, RTFSISOMAKER_SECTOR_SIZE) - offInDir); + memset(pbBuf, 0, cbDone); + } + + return cbDone; +} + + +/** + * Read directory records or path table records. + * + * Will not necessarily fill the entire buffer. Caller must call again to get + * more. + * + * @returns Number of bytes copied into @a pbBuf. + * @param ppDirHint Pointer to the directory hint for the namespace. + * @param pIsoMaker The ISO maker instance. + * @param pNamespace The namespace. + * @param pFinalizedDirs The finalized directory data for the namespace. + * @param offUnsigned The ISO image byte offset of the requested data. + * @param pbBuf The output buffer. + * @param cbBuf How much to read. + */ +static size_t rtFsIsoMakerOutFile_ReadDirStructures(PRTFSISOMAKERNAMEDIR *ppDirHint, PRTFSISOMAKERNAMESPACE pNamespace, + PRTFSISOMAKERFINALIZEDDIRS pFinalizedDirs, + uint64_t offUnsigned, uint8_t *pbBuf, size_t cbBuf) +{ + if (offUnsigned < pFinalizedDirs->offPathTableL) + return rtFsIsoMakerOutFile_ReadDirRecords(ppDirHint, pFinalizedDirs, + pNamespace->fNamespace == RTFSISOMAKER_NAMESPACE_JOLIET, + offUnsigned, pbBuf, cbBuf); + + uint64_t offInTable; + if ((offInTable = offUnsigned - pFinalizedDirs->offPathTableL) < pFinalizedDirs->cbPathTable) + return rtFsIsoMakerOutFile_ReadPathTable(ppDirHint, pFinalizedDirs, + pNamespace->fNamespace == RTFSISOMAKER_NAMESPACE_JOLIET, + true /*fLittleEndian*/, (uint32_t)offInTable, pbBuf, cbBuf); + + if ((offInTable = offUnsigned - pFinalizedDirs->offPathTableM) < pFinalizedDirs->cbPathTable) + return rtFsIsoMakerOutFile_ReadPathTable(ppDirHint, pFinalizedDirs, + pNamespace->fNamespace == RTFSISOMAKER_NAMESPACE_JOLIET, + false /*fLittleEndian*/, (uint32_t)offInTable, pbBuf, cbBuf); + + /* ASSUME we're in the zero padding at the end of a path table. */ + Assert( offUnsigned - pFinalizedDirs->offPathTableL < RT_ALIGN_32(pFinalizedDirs->cbPathTable, RTFSISOMAKER_SECTOR_SIZE) + || offUnsigned - pFinalizedDirs->offPathTableM < RT_ALIGN_32(pFinalizedDirs->cbPathTable, RTFSISOMAKER_SECTOR_SIZE)); + size_t cbZeros = RT_MIN(cbBuf, RTFSISOMAKER_SECTOR_SIZE - ((size_t)offUnsigned & RTFSISOMAKER_SECTOR_OFFSET_MASK)); + memset(pbBuf, 0, cbZeros); + return cbZeros; +} + + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + PRTFSISOMAKERINT pIsoMaker = pThis->pIsoMaker; + size_t cbBuf = pSgBuf->paSegs[0].cbSeg; + uint8_t *pbBuf = (uint8_t *)pSgBuf->paSegs[0].pvSeg; + + Assert(pSgBuf->cSegs == 1); + RT_NOREF(fBlocking); + + /* + * Process the offset, checking for end-of-file. + */ + uint64_t offUnsigned; + if (off < 0) + offUnsigned = pThis->offCurPos; + else + offUnsigned = (uint64_t)off; + if (offUnsigned >= pIsoMaker->cbFinalizedImage) + { + if (*pcbRead) + { + *pcbRead = 0; + return VINF_EOF; + } + return VERR_EOF; + } + if ( !pcbRead + && pIsoMaker->cbFinalizedImage - offUnsigned < cbBuf) + return VERR_EOF; + + /* + * Produce the bytes. + */ + int rc = VINF_SUCCESS; + size_t cbRead = 0; + while (cbBuf > 0) + { + size_t cbDone; + + /* Betting on there being more file data than metadata, thus doing the + offset switch in decending order. */ + if (offUnsigned >= pIsoMaker->offFirstFile) + { + if (offUnsigned < pIsoMaker->cbFinalizedImage) + { + if (offUnsigned < pIsoMaker->cbFinalizedImage - pIsoMaker->cbImagePadding) + { + rc = rtFsIsoMakerOutFile_ReadFileData(pThis, pIsoMaker, offUnsigned, pbBuf, cbBuf, &cbDone); + if (RT_FAILURE(rc)) + break; + } + else + { + cbDone = pIsoMaker->cbFinalizedImage - offUnsigned; + if (cbDone > cbBuf) + cbDone = cbBuf; + memset(pbBuf, 0, cbDone); + } + } + else + { + rc = pcbRead ? VINF_EOF : VERR_EOF; + break; + } + } + /* + * Joliet directory structures. + */ + else if ( offUnsigned >= pIsoMaker->JolietDirs.offDirs + && pIsoMaker->JolietDirs.offDirs < pIsoMaker->JolietDirs.offPathTableL) + cbDone = rtFsIsoMakerOutFile_ReadDirStructures(&pThis->pDirHintJoliet, &pIsoMaker->Joliet, &pIsoMaker->JolietDirs, + offUnsigned, pbBuf, cbBuf); + /* + * Primary ISO directory structures. + */ + else if (offUnsigned >= pIsoMaker->PrimaryIsoDirs.offDirs) + cbDone = rtFsIsoMakerOutFile_ReadDirStructures(&pThis->pDirHintPrimaryIso, &pIsoMaker->PrimaryIso, + &pIsoMaker->PrimaryIsoDirs, offUnsigned, pbBuf, cbBuf); + /* + * Volume descriptors. + */ + else if (offUnsigned >= _32K) + { + size_t offVolDescs = (size_t)offUnsigned - _32K; + cbDone = RT_MIN(cbBuf, (pIsoMaker->cVolumeDescriptors * RTFSISOMAKER_SECTOR_SIZE) - offVolDescs); + memcpy(pbBuf, &pIsoMaker->pbVolDescs[offVolDescs], cbDone); + } + /* + * Zeros in the system area. + */ + else if (offUnsigned >= pIsoMaker->cbSysArea) + { + cbDone = RT_MIN(cbBuf, _32K - (size_t)offUnsigned); + memset(pbBuf, 0, cbDone); + } + /* + * Actual data in the system area. + */ + else + { + cbDone = RT_MIN(cbBuf, pIsoMaker->cbSysArea - (size_t)offUnsigned); + memcpy(pbBuf, &pIsoMaker->pbSysArea[(size_t)offUnsigned], cbDone); + } + + /* + * Common advance. + */ + cbRead += cbDone; + offUnsigned += cbDone; + pbBuf += cbDone; + cbBuf -= cbDone; + } + + if (pcbRead) + *pcbRead = cbRead; + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Flush(void *pvThis) +{ + RT_NOREF(pvThis); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + *poffActual = pThis->offCurPos; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnSkip} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Skip(void *pvThis, RTFOFF cb) +{ + RTFOFF offIgnored; + return rtFsIsoMakerOutFile_Seek(pvThis, cb, RTFILE_SEEK_CURRENT, &offIgnored); +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + + /* + * Seek relative to which position. + */ + uint64_t offWrt; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offWrt = 0; + break; + + case RTFILE_SEEK_CURRENT: + offWrt = pThis->offCurPos; + break; + + case RTFILE_SEEK_END: + offWrt = pThis->pIsoMaker->cbFinalizedImage; + break; + + default: + return VERR_INVALID_PARAMETER; + } + + /* + * Calc new position, take care to stay within RTFOFF type bounds. + */ + uint64_t offNew; + if (offSeek == 0) + offNew = offWrt; + else if (offSeek > 0) + { + offNew = offWrt + offSeek; + if ( offNew < offWrt + || offNew > RTFOFF_MAX) + offNew = RTFOFF_MAX; + } + else if ((uint64_t)-offSeek < offWrt) + offNew = offWrt + offSeek; + else + offNew = 0; + pThis->offCurPos = offNew; + + *poffActual = offNew; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsIsoMakerOutFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSISOMAKEROUTPUTFILE pThis = (PRTFSISOMAKEROUTPUTFILE)pvThis; + *pcbFile = pThis->pIsoMaker->cbFinalizedImage; + return VINF_SUCCESS; +} + + +/** + * Standard file operations. + */ +DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtFsIsoMakerOutputFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "ISO Maker Output File", + rtFsIsoMakerOutFile_Close, + rtFsIsoMakerOutFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsIsoMakerOutFile_Read, + NULL /*Write*/, + rtFsIsoMakerOutFile_Flush, + NULL /*PollOne*/, + rtFsIsoMakerOutFile_Tell, + rtFsIsoMakerOutFile_Skip, + NULL /*ZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + NULL /*SetMode*/, + NULL /*SetTimes*/, + NULL /*SetOwner*/, + RTVFSOBJSETOPS_VERSION + }, + rtFsIsoMakerOutFile_Seek, + rtFsIsoMakerOutFile_QuerySize, + NULL /*SetSize*/, + NULL /*QueryMaxSize*/, + RTVFSFILEOPS_VERSION +}; + + + +/** + * Creates a VFS file for a finalized ISO maker instanced. + * + * The file can be used to access the image. Both sequential and random access + * are supported, so that this could in theory be hooked up to a CD/DVD-ROM + * drive emulation and used as a virtual ISO image. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param phVfsFile Where to return the handle. + */ +RTDECL(int) RTFsIsoMakerCreateVfsOutputFile(RTFSISOMAKER hIsoMaker, PRTVFSFILE phVfsFile) +{ + PRTFSISOMAKERINT pThis = hIsoMaker; + RTFSISOMAKER_ASSERT_VALID_HANDLE_RET(pThis); + AssertReturn(pThis->fFinalized, VERR_WRONG_ORDER); + AssertPtrReturn(phVfsFile, VERR_INVALID_POINTER); + + uint32_t cRefs = RTFsIsoMakerRetain(pThis); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + PRTFSISOMAKEROUTPUTFILE pFileData; + RTVFSFILE hVfsFile; + int rc = RTVfsNewFile(&g_rtFsIsoMakerOutputFileOps, sizeof(*pFileData), RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_CREATE, + NIL_RTVFS, NIL_RTVFSLOCK, &hVfsFile, (void **)&pFileData); + if (RT_SUCCESS(rc)) + { + pFileData->pIsoMaker = pThis; + pFileData->offCurPos = 0; + pFileData->pFileHint = NULL; + pFileData->hVfsSrcFile = NIL_RTVFSFILE; + pFileData->pDirHintPrimaryIso = NULL; + pFileData->pDirHintJoliet = NULL; + pFileData->iChildPrimaryIso = UINT32_MAX; + pFileData->iChildJoliet = UINT32_MAX; + *phVfsFile = hVfsFile; + return VINF_SUCCESS; + } + + RTFsIsoMakerRelease(pThis); + *phVfsFile = NIL_RTVFSFILE; + return rc; +} + diff --git a/src/VBox/Runtime/common/fs/isomakercmd-man.xml b/src/VBox/Runtime/common/fs/isomakercmd-man.xml new file mode 100644 index 00000000..b119feac --- /dev/null +++ b/src/VBox/Runtime/common/fs/isomakercmd-man.xml @@ -0,0 +1,569 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + manpage for RTIsoMaker/VISO + + Copyright (C) 2006-2017 Oracle Corporation + + This file is part of VirtualBox Open Source Edition (OSE), as + available from http://www.virtualbox.org. This file is free software; + you can redistribute it and/or modify it under the terms of the GNU + General Public License (GPL) as published by the Free Software + Foundation, in version 2 as it comes in the "COPYING" file of the + VirtualBox OSE distribution. VirtualBox OSE is distributed in the + hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + + The contents of this file may alternatively be used under the terms + of the Common Development and Distribution License Version 1.0 + (CDDL) only, as it comes in the "COPYING.CDDL" file of the + VirtualBox OSE distribution, in which case the provisions of the + CDDL are applicable instead of those of the GPL. + + You may elect to license modified versions of this file under the + terms and conditions of either the GPL or the CDDL or both. + --> +<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN" "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd"> +<refentry id="viso" lang="en"> + + <refentryinfo> + <pubdate>$Date: 2018-07-20 19:42:10 +0200 (Fri, 20 Jul 2018) $</pubdate> + <title>VISO file format / RTIsoMaker</title> + </refentryinfo> + + <refmeta> + <refentrytitle>viso</refentrytitle> + <manvolnum>8</manvolnum> + </refmeta> + + <refnamediv> + <!--<refname>VISO</refname>--> + <refname>viso</refname> + <refpurpose>ISO image maker</refpurpose> + <refclass>IPRT</refclass> + </refnamediv> + + <refsynopsisdiv> + <cmdsynopsis id="synopsis-viso"> <!-- The 'id' is mandatory and must start with 'synopsis-'. --> + <command>RTIsoMaker</command> + <arg><replaceable>options</replaceable></arg> + <arg>@<replaceable>commands.rsp</replaceable></arg> + <arg choice="req" rep="repeat"><replaceable>filespec</replaceable></arg> + </cmdsynopsis> + </refsynopsisdiv> + + <refsect1> + <title>Description</title> + <para>Construct a virtual ISO 9660 / Joliet / UDF / HFS hybrid image and either write it to a + file (RTIsoMaker) or serve it as a virtual image (VISO).</para> + + <refsect2 id="viso-viso"> + <title>VISO file format</title> + <para>A VISO file is a virtual ISO image, i.e. constructed in memory from a bunch of files on + the host. A VISO is just the recipe describing how to go about this using a syntax vaguely + similar to mkisofs and genisoimage.</para> + + <para>One requirement is that the VISO file must start with one of the + <option>--iprt-iso-maker-file-marker</option> options. Which of the options you use will + dictate the quoting and escaping rules used when reading the file. The option takes the + image UUID as an argument.</para> + + <para>The VISO files are treated as UTF-8 and must not contain any byte order marker (BOM). + There is currently no way to comment out lines in a VISO file.</para> + + </refsect2> + + <refsect2 id="viso-filespecs"> + <title>File specifications and --name-setup</title> + <para>All non-options that does not start with '@' are taken to indicate a file, directory, + or similar that is should be added to the ISO image. Directories are added recursively and + content is subject to filtering options.</para> + + <para>Since there can be up to six different namespaces on an ISO, it is handy to be able to + control the names used in each and be able to exclude an object from one or more namespaces. + The <option>--name-setup</option> option specifies the file specification format to use + forthwith.</para> + + <para>The default setup is:</para> + <!-- indent this: --> + <para><computeroutput> --name-setup iso+joliet+udf+hfs</computeroutput></para> + + <para>Which means you specify one on-ISO name for all namespaces followed by '=' and the + source file system name. Only specifying the source file system will add the + file/dir/whatever to the root of the ISO image.</para> + + <para>Lets look at the following two examples:</para> + + <!-- indent these --> + <para><computeroutput> /docs/readme.txt=/home/user/Documents/product-x-readme.txt</computeroutput></para> + <para><computeroutput> /home/user/Documents/product-x-readme.txt</computeroutput></para> + + <para>In the first case the file <computeroutput>'/home/user/Documents/product-x-readme.txt'</computeroutput> + is added to the ISO image as <computeroutput>'/docs/readme.txt'</computeroutput> in all + enabled namespaces. In the primary ISO 9660 namespace, the filename will by default be + converted to upper case because it's required by the spec.</para> + + <para>In the second case the file is added to the root under the name + <computeroutput>'product-x-readme.txt'</computeroutput> in all namespaces. Though, in the + primary ISO 9660 namespace the name will be transformed to apply with the current ISO level, + probably uppercased, possibly truncated too. </para> + + <para>Given <option>--name-setup iso,joliet,udf</option> you can specify the name individually + for each of the three namespace, if you like. If you omit any, they will use last name given. + Any names left blank (<computeroutput>==</computeroutput>) will be considered omitted.</para> + + <para>A different name in each namespace:</para> + <para><computeroutput> /ISO.TXT=/Joliet.TxT=/UDF.txt=/tmp/iso/real.txt</computeroutput></para> + <para>Specific name in the ISO 9660 namespace, same in the rest:</para> + <para><computeroutput> /ISO.TXT=/OtherNamespaces.TxT=/tmp/iso/real.txt</computeroutput></para> + <para>Omit the file from the ISO 9660 namespace:</para> + <para><computeroutput> =/OtherNamespaces.TxT=/tmp/iso/real.txt</computeroutput></para> + <para>Omit the file from the joliet namespace:</para> + <para><computeroutput> /ISO.TXT==/UDF.TxT=/tmp/iso/real.txt</computeroutput></para> + <para>Use the same filename as the source everywhere:</para> + <para><computeroutput> /tmp/iso/real.txt</computeroutput></para> + + + <para>Using for instance <option>--name-setup udf</option> you can add a files/dirs/whatever + to select namespace(s) without the more complicated empty name syntax above.</para> + + <para>When adding directories, you can only control the naming and omitting of the directory + itself, not any recursively added files and directories below it.</para> + + </refsect2> + </refsect1> + + <refsect1 id="viso-options"> + <title>Options</title> + + <refsect2 id="viso-options-general"> + <title>General</title> + + <variablelist> + <varlistentry> + <term><option>-o <replaceable>output-file</replaceable></option></term> + <term><option>--output=<replaceable>output-file</replaceable></option></term> + <listitem><para>The output filename. This option is not supported in VISO mode.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--name-setup <replaceable>spec</replaceable></option></term> + <listitem><para>Configures active namespaces and how file specifications are to be + interpreted. The specification is a comma separated list. Each element in the list is + a sub-list separated by space, <computeroutput>'+'</computeroutput> or + <computeroutput>'|'</computeroutput> giving the namespaces that elements controls. + Namespaces are divied into two major and minor ones, you cannot specifying a minor + before the major it belongs to.</para> + <para>Major namespaces and aliases in parentheses:</para> + <itemizedlist spacing="compact"> + <listitem><para>iso (primary, iso9660, iso-9660, primary-iso, iso-primary)</para></listitem> + <listitem><para>joliet</para></listitem> + <listitem><para>udf</para></listitem> + <listitem><para>hfs (hfs-plus)</para></listitem> + </itemizedlist> + <para>Minor namespaces:</para> + <itemizedlist spacing="compact"> + <listitem><para>rock: rock ridge on previous major namespace (iso / joliet)</para></listitem> + <listitem><para>iso-rock: rock ridge extensions on primary ISO 9660 namespace</para></listitem> + <listitem><para>joliet-rock: rock ridge on joliet namespace (just for fun)</para></listitem> + <listitem><para>trans-tbl: translation table file on previous major namespace</para></listitem> + <listitem><para>iso-trans-tbl</para></listitem> + <listitem><para>joliet-trans-tbl</para></listitem> + <listitem><para>udf-trans-tbl</para></listitem> + <listitem><para>hfs-trans-tbl</para></listitem> + </itemizedlist> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--push-iso=<replaceable>iso-file</replaceable></option></term> + <term><option>--push-iso-no-joliet=<replaceable>iso-file</replaceable></option></term> + <term><option>--push-iso-no-rock-<replaceable>iso-file</replaceable></option></term> + <term><option>--push-iso-no-rock-no-joliet=<replaceable>iso-file</replaceable></option></term> + <listitem><para>Open the specified ISO file and use it as source file system until the + corresponding <option>--pop</option> options is encountered. The variations are for + selecting which namespace on the ISO to (not) access. These options are handy for copying + files/directories/stuff from an ISO without having to extract them first or using the + <computeroutput>:iprtvfs:</computeroutput> syntax.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--pop</option></term> + <listitem><para>Pops a <option>--push-iso</option> of the source file system stack.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--import-iso=<replaceable>iso-file</replaceable></option></term> + <listitem><para>Imports everything on the given ISO file, including boot configuration and + system area (first 16 sectors) content. You can use <option>--name-setup</option> to omit + namespaces.</para></listitem> + </varlistentry> + + </variablelist> + </refsect2> + + <refsect2 id="viso-options-namespaces"> + <title>Namespaces</title> + <variablelist> + + <varlistentry> + <term><option>--iso-level=<replaceable>0|1|2|3</replaceable></option></term> <!-- FIXME: imperfect markup --> + <listitem> + <para>Sets the ISO level:</para> + <itemizedlist spacing="compact"> + <listitem><para>0: Disable primary ISO namespace.</para></listitem> + <listitem><para>1: ISO level 1: Filenames 8.3 format and limited to 4GB - 1.</para></listitem> + <listitem><para>2: ISO level 2: 31 char long names and limited to 4GB - 1.</para></listitem> + <listitem><para>3: ISO level 3: 31 char long names and support for >=4GB files. (default)</para></listitem> + <listitem><para>4: Fictive level used by other tools. Not yet implemented.</para></listitem> + </itemizedlist> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--rock-ridge</option></term> + <term><option>--limited-rock-ridge</option></term> + <term><option>--no-rock-ridge</option></term> + <listitem><para>Enables or disables rock ridge support for the primary ISO 9660 namespace. + The <option>--limited-rock-ridge</option> option omits a couple of bits in the root + directory that would make Linux pick rock ridge over joliet.</para> + <para>Default: <option>--limited-rock-ridge</option></para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>-J</option></term> + <term><option>--joliet</option></term> + <term><option>--no-joliet</option></term> + <listitem><para>Enables or disable the joliet namespace. This option must precede any file + specifications.</para> + <para>Default: <option>--joliet</option></para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--joliet-ucs-level=<replaceable>1|2|3</replaceable></option></term> <!-- FIXME: imperfect markup --> + <term><option>--ucs-level=<replaceable>1|2|3</replaceable></option></term> + <listitem><para>Set the Joliet UCS support level. This is currently only flagged in the + image but not enforced on the actual path names.</para> + <para>Default level: 3</para> + </listitem> + </varlistentry> + + </variablelist> + </refsect2> + + <refsect2 id="viso-options-file-attributes"> + <title>File Attributes</title> + <variablelist> + + <varlistentry> + <term><option>--rational-attribs</option></term> + <listitem><para>Enables rational file attribute handling (default):</para> + <itemizedlist spacing="compact"> + <listitem><para>Owner ID is set to zero</para></listitem> + <listitem><para>Group ID is set to zero</para></listitem> + <listitem><para>Mode is set to 0444 for non-executable files.</para></listitem> + <listitem><para>Mode is set to 0555 for executable files.</para></listitem> + <listitem><para>Mode is set to 0555 for directories, preserving stick bits.</para></listitem> + </itemizedlist> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--strict-attribs</option></term> + <listitem><para>Counters <option>--rational-attribs</option> and causes attributes to be + recorded exactly as they appear in the source.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--file-mode=<replaceable>mode</replaceable></option></term> + <term><option>--no-file-mode</option></term> + <listitem><para>Controls the forced file mode mask for rock ridge, UDF and HFS.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--dir-mode=<replaceable>mode</replaceable></option></term> + <term><option>--no-dir-mode</option></term> + <listitem><para>Controls the forced directory mode mask for rock ridge, UDF and HFS.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--new-dir-mode=<replaceable>mode</replaceable></option></term> + <listitem><para>Controls the default mode mask (rock ridge, UDF, HFS) for directories that + are created implicitly. The <option>--dir-mode</option> option overrides this.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--chmod=<replaceable>mode</replaceable>:<replaceable>on-iso-file</replaceable></option></term> + <listitem><para>Explictily sets the rock ridge, UDF and HFS file mode for a file/dir/whatever + that has already been added to the ISO. The mode can be octal, <computeroutput>ra+x</computeroutput>, + <computeroutput>a+r</computeroutput>, or <computeroutput>a+rx</computeroutput>. + (Support for more complicated mode specifications may be implemented at a later point.)</para> + <para>Note that only namespaces in the current --name-setup are affected.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--chown=<replaceable>owner-id</replaceable>:<replaceable>on-iso-file</replaceable></option></term> + <listitem><para>Explictily sets the rock ridge, UDF and HFS file owner ID (numeric) for a + file/dir/whatever that has already been added to the ISO.</para> + <para>Note that only namespaces in the current --name-setup are affected.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term>--chgrp=<replaceable>group-id</replaceable>:<replaceable>on-iso-file</replaceable></term> + <listitem><para>Explictily sets the rock ridge, UDF and HFS file group ID (numeric) for a + file/dir/whatever that has already been added to the ISO.</para> + <para>Note that only namespaces in the current --name-setup are affected.</para> + </listitem> + </varlistentry> + + </variablelist> + </refsect2> + + <refsect2 id="viso-options-booting"> + <title>Booting</title> + <variablelist> + + <varlistentry> + <term><option>--eltorito-new-entry</option></term> + <term><option>--eltorito-alt-boot</option></term> + <listitem><para>Starts a new El Torito boot entry.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--eltorito-add-image=<replaceable>filespec</replaceable></option></term> + <listitem><para>File specification of a file that should be added to the image and used as + the El Torito boot image of the current boot entry.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>-b <replaceable>on-iso-file</replaceable></option></term> + <term><option>--eltorito-boot=<replaceable>on-iso-file</replaceable></option></term> + <listitem><para>Specifies a file on the ISO as the El Torito boot image for the current boot + entry.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--eltorito-floppy-12</option></term> + <term><option>--eltorito-floppy-144</option></term> + <term><option>--eltorito-floppy-288</option></term> + <term><option>--no-emulation-boot</option></term> + <term><option>--hard-disk-boot</option></term> + <listitem><para>Sets the boot image emulation type of the current El Torito boot entry.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--boot-load-seg=<replaceable>seg</replaceable></option></term> + <listitem><para>Specify the image load segment for the current El Torito boot entry.</para> + <para>Default: 0x7c0</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--boot-load-size=<replaceable>sectors</replaceable></option></term> + <listitem><para>Specify the image load size in emulated sectors for the current El Torito + boot entry.</para> + <para>Default: 4 (sectors of 512 bytes)</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--no-boot</option></term> + <listitem><para>Indicates that the current El Torito boot entry isn't bootable. (The BIOS + will allegedly configure the emulation, but not attempt booting.)</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--boot-info-table</option></term> + <listitem><para>Write a isolinux/syslinux boot info table into the boot image for the + current El Torito boot entry.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--eltorito-platform-id=<replaceable>id</replaceable></option></term> + <listitem><para>Set the El Torito platform ID of the current entry, a new entry of the + verification entry depending on when it's used. The ID must be one of: + <computeroutput>x86</computeroutput>, <computeroutput>PPC</computeroutput>, + <computeroutput>Mac</computeroutput>, <computeroutput>efi</computeroutput></para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>-c <replaceable>namespec</replaceable></option></term> + <term><option>--boot-catalog=<replaceable>namespec</replaceable></option></term> + <listitem><para>Enters the El Torito boot catalog into the namespaces as a file. The + <replaceable>namespec</replaceable> uses the same format as a 'filespec', but omits the + final source file system name component.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>-G <replaceable>file</replaceable></option></term> + <term><option>--generic-boot=<replaceable>file</replaceable></option></term> + <listitem><para>Specifies a file that should be loaded at offset 0 in the ISO image. The + file must not be larger than 32KB. When creating a hybrid image, parts of this may be + regenerated by partition tables and such.</para> + </listitem> + </varlistentry> + + </variablelist> + </refsect2> + + <refsect2 id="viso-options-string-properties"> + <title>String properties (applied to active namespaces only)</title> + <variablelist> + + <varlistentry> + <term><option>--abstract=<replaceable>file-id</replaceable></option></term> + <listitem><para>The name of the abstract file in the root dir.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>-A <replaceable>text|_file-id</replaceable></option></term> + <term><option>--application-id=<replaceable>text|_file-id</replaceable></option></term> + <listitem><para>Application ID string or root file name. The latter must be prefixed with + an underscore.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--biblio=<replaceable>file-id</replaceable></option></term> + <listitem><para>The name of the bibliographic file in the root dir.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--copyright=<replaceable>file-id</replaceable></option></term> + <listitem><para>The name of the copyright file in the root dir.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>-P <replaceable>text|_file-id</replaceable></option></term> + <term><option>--publisher=<replaceable>text|_file-id</replaceable></option></term> + <listitem><para>Publisher ID string or root file name. The latter must be prefixed with an + underscore.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>-p <replaceable>text|_file-id</replaceable></option></term> + <term><option>--preparer=<replaceable>text|_file-id</replaceable></option></term> + <listitem><para>Data preparer ID string or root file name. The latter must be prefixed + with an underscore.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--sysid=<replaceable>text</replaceable></option></term> + <listitem><para>System ID string.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--volid=<replaceable>text</replaceable></option></term> + <term><option>--volume-id=<replaceable>text</replaceable></option></term> + <listitem><para>Volume ID string (label). (It is possible to set different labels for + primary ISO 9660, joliet, UDF and HFS by changing the active namespaces using the + <option>--name-setup</option> option between <option>--volume-id</option> occurences.)</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--volset=<replaceable>text</replaceable></option></term> + <listitem><para>Volume set ID string.</para></listitem> + </varlistentry> + + </variablelist> + </refsect2> + + <refsect2 id="viso-options-compatibility"> + <title>Compatibility:</title> + <variablelist> + + <varlistentry> + <term><option>--graft-points</option></term> + <listitem><para>Alias for --name-setup iso+joliet+udf+hfs.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>-l</option></term> + <term><option>--long-names</option></term> + <listitem><para>Allow 31 charater filenames. Just ensure ISO level >= 2 here.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>-R</option></term> + <term><option>--rock</option></term> + <listitem><para>Same as <option>--rock-ridge</option> and <option>--strict-attribs</option>.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>-r</option></term> + <term><option>--rational-rock</option></term> + <listitem><para>Same as <option>--rock-ridge</option> and <option>--rational-attribs</option>.</para></listitem> + </varlistentry> + + </variablelist> + </refsect2> + + + <refsect2 id="viso-options-viso-specific"> + <title>VISO Specific:</title> + <variablelist> + + <varlistentry> + <term><option>--iprt-iso-maker-file-marker=<replaceable>UUID</replaceable></option></term> + <term><option>--iprt-iso-maker-file-marker-bourne=<replaceable>UUID</replaceable></option></term> + <term><option>--iprt-iso-maker-file-marker-bourne-sh=<replaceable>UUID</replaceable></option></term> + <listitem><para>Used as first option in a VISO file to specify the file UUID and that it is + formatted using bourne-shell argument quoting & escaping style.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--iprt-iso-maker-file-marker-ms=<replaceable>UUID</replaceable></option></term> + <term><option>--iprt-iso-maker-file-marker-ms-sh=<replaceable>UUID</replaceable></option></term> + <listitem><para>Used as first option in a VISO file to specify the file UUID and that it is + formatted using microsoft CRT argument quoting & escaping style.</para> + </listitem> + </varlistentry> + + </variablelist> + </refsect2> + + + <refsect2 id="viso-options-testing"> + <title>Testing (not applicable to VISO):</title> + <variablelist> + + <varlistentry> + <term><option>--output-buffer-size=<replaceable>bytes</replaceable></option></term> + <listitem><para>Selects a specific output buffer size for testing virtual image reads.</para></listitem> + </varlistentry> + + <varlistentry> + <term><option>--random-output-buffer-size</option></term> + <listitem><para>Enables randomized buffer size for each virtual image read, using the + current output buffer size (<option>--output-buffer-size</option>) as maximum.</para> + </listitem> + </varlistentry> + + <varlistentry> + <term><option>--random-order-verification=<replaceable>size</replaceable></option></term> + <listitem><para>Enables verification pass of the image that compares blocks of the given + size in random order from the virtual and output images.</para> + </listitem> + </varlistentry> + + </variablelist> + </refsect2> + + </refsect1> +</refentry> + diff --git a/src/VBox/Runtime/common/fs/isomakercmd.cpp b/src/VBox/Runtime/common/fs/isomakercmd.cpp new file mode 100644 index 00000000..adebd11b --- /dev/null +++ b/src/VBox/Runtime/common/fs/isomakercmd.cpp @@ -0,0 +1,3594 @@ +/* $Id: isomakercmd.cpp $ */ +/** @file + * IPRT - ISO Image Maker Command. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include "internal/iprt.h" +#include <iprt/fsisomaker.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/buildconfig.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/fsvfs.h> +#include <iprt/err.h> +#include <iprt/getopt.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/message.h> +#include <iprt/path.h> +#include <iprt/rand.h> +#include <iprt/stream.h> +#include <iprt/string.h> +#include <iprt/vfs.h> +#include <iprt/formats/iso9660.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Maximum number of name specifiers we allow. */ +#define RTFSISOMAKERCMD_MAX_NAMES 8 + +/** Maximum directory recursions when adding a directory tree. */ +#define RTFSISOMAKERCMD_MAX_DIR_RECURSIONS 32 + +/** @name Name specifiers + * @{ */ +#define RTFSISOMAKERCMDNAME_PRIMARY_ISO RTFSISOMAKER_NAMESPACE_ISO_9660 +#define RTFSISOMAKERCMDNAME_JOLIET RTFSISOMAKER_NAMESPACE_JOLIET +#define RTFSISOMAKERCMDNAME_UDF RTFSISOMAKER_NAMESPACE_UDF +#define RTFSISOMAKERCMDNAME_HFS RTFSISOMAKER_NAMESPACE_HFS + +#define RTFSISOMAKERCMDNAME_PRIMARY_ISO_ROCK_RIDGE RT_BIT_32(16) +#define RTFSISOMAKERCMDNAME_JOLIET_ROCK_RIDGE RT_BIT_32(17) + +#define RTFSISOMAKERCMDNAME_JOLIET_TRANS_TBL RT_BIT_32(20) +#define RTFSISOMAKERCMDNAME_PRIMARY_ISO_TRANS_TBL RT_BIT_32(21) +#define RTFSISOMAKERCMDNAME_UDF_TRANS_TBL RT_BIT_32(22) +#define RTFSISOMAKERCMDNAME_HFS_TRANS_TBL RT_BIT_32(23) + +#define RTFSISOMAKERCMDNAME_MAJOR_MASK \ + (RTFSISOMAKERCMDNAME_PRIMARY_ISO | RTFSISOMAKERCMDNAME_JOLIET | RTFSISOMAKERCMDNAME_UDF | RTFSISOMAKERCMDNAME_HFS) + +#define RTFSISOMAKERCMDNAME_MINOR_MASK \ + ( RTFSISOMAKERCMDNAME_PRIMARY_ISO_ROCK_RIDGE | RTFSISOMAKERCMDNAME_PRIMARY_ISO_TRANS_TBL \ + | RTFSISOMAKERCMDNAME_JOLIET_ROCK_RIDGE | RTFSISOMAKERCMDNAME_JOLIET_TRANS_TBL \ + | RTFSISOMAKERCMDNAME_UDF_TRANS_TBL \ + | RTFSISOMAKERCMDNAME_HFS_TRANS_TBL) +AssertCompile((RTFSISOMAKERCMDNAME_MAJOR_MASK & RTFSISOMAKERCMDNAME_MINOR_MASK) == 0); +/** @} */ + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +typedef enum RTFSISOMAKERCMDOPT +{ + RTFSISOMAKERCMD_OPT_FIRST = 1000, + + RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, + RTFSISOMAKERCMD_OPT_OUTPUT_BUFFER_SIZE, + RTFSISOMAKERCMD_OPT_RANDOM_OUTPUT_BUFFER_SIZE, + RTFSISOMAKERCMD_OPT_RANDOM_ORDER_VERIFICATION, + RTFSISOMAKERCMD_OPT_NAME_SETUP, + + RTFSISOMAKERCMD_OPT_ROCK_RIDGE, + RTFSISOMAKERCMD_OPT_LIMITED_ROCK_RIDGE, + RTFSISOMAKERCMD_OPT_NO_ROCK_RIDGE, + RTFSISOMAKERCMD_OPT_NO_JOLIET, + + RTFSISOMAKERCMD_OPT_IMPORT_ISO, + RTFSISOMAKERCMD_OPT_PUSH_ISO, + RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_JOLIET, + RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK, + RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK_NO_JOLIET, + RTFSISOMAKERCMD_OPT_POP, + + RTFSISOMAKERCMD_OPT_ELTORITO_NEW_ENTRY, + RTFSISOMAKERCMD_OPT_ELTORITO_ADD_IMAGE, + RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_12, + RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_144, + RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_288, + + RTFSISOMAKERCMD_OPT_RATIONAL_ATTRIBS, + RTFSISOMAKERCMD_OPT_STRICT_ATTRIBS, + RTFSISOMAKERCMD_OPT_NO_FILE_MODE, + RTFSISOMAKERCMD_OPT_NO_DIR_MODE, + RTFSISOMAKERCMD_OPT_CHMOD, + RTFSISOMAKERCMD_OPT_CHOWN, + RTFSISOMAKERCMD_OPT_CHGRP, + + /* + * Compatibility options: + */ + RTFSISOMAKERCMD_OPT_ABSTRACT_FILE_ID, + RTFSISOMAKERCMD_OPT_ALLOW_LEADING_DOTS, + RTFSISOMAKERCMD_OPT_ALLOW_LIMITED_SIZE, + RTFSISOMAKERCMD_OPT_ALLOW_LOWERCASE, + RTFSISOMAKERCMD_OPT_ALLOW_MULTI_DOT, + RTFSISOMAKERCMD_OPT_ALPHA_BOOT, + RTFSISOMAKERCMD_OPT_APPLE, + RTFSISOMAKERCMD_OPT_BIBLIOGRAPHIC_FILE_ID, + RTFSISOMAKERCMD_OPT_CHECK_OLD_NAMES, + RTFSISOMAKERCMD_OPT_CHECK_SESSION, + RTFSISOMAKERCMD_OPT_COPYRIGHT_FILE_ID, + RTFSISOMAKERCMD_OPT_DETECT_HARDLINKS, + RTFSISOMAKERCMD_OPT_DIR_MODE, + RTFSISOMAKERCMD_OPT_DVD_VIDEO, + RTFSISOMAKERCMD_OPT_ELTORITO_PLATFORM_ID, + RTFSISOMAKERCMD_OPT_ELTORITO_HARD_DISK_BOOT, + RTFSISOMAKERCMD_OPT_ELTORITO_INFO_TABLE, + RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SEG, + RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SIZE, + RTFSISOMAKERCMD_OPT_ELTORITO_NO_BOOT, + RTFSISOMAKERCMD_OPT_ELTORITO_NO_EMULATION_BOOT, + RTFSISOMAKERCMD_OPT_EXCLUDE_LIST, + RTFSISOMAKERCMD_OPT_FILE_MODE, + RTFSISOMAKERCMD_OPT_FORCE_RR, + RTFSISOMAKERCMD_OPT_GID, + RTFSISOMAKERCMD_OPT_GRAFT_POINTS, + RTFSISOMAKERCMD_OPT_GUI, + RTFSISOMAKERCMD_OPT_HFS_AUTO, + RTFSISOMAKERCMD_OPT_HFS_BLESS, + RTFSISOMAKERCMD_OPT_HFS_BOOT_FILE, + RTFSISOMAKERCMD_OPT_HFS_CAP, + RTFSISOMAKERCMD_OPT_HFS_CHRP_BOOT, + RTFSISOMAKERCMD_OPT_HFS_CLUSTER_SIZE, + RTFSISOMAKERCMD_OPT_HFS_CREATOR, + RTFSISOMAKERCMD_OPT_HFS_DAVE, + RTFSISOMAKERCMD_OPT_HFS_DOUBLE, + RTFSISOMAKERCMD_OPT_HFS_ENABLE, + RTFSISOMAKERCMD_OPT_HFS_ETHERSHARE, + RTFSISOMAKERCMD_OPT_HFS_EXCHANGE, + RTFSISOMAKERCMD_OPT_HFS_HIDE, + RTFSISOMAKERCMD_OPT_HFS_HIDE_LIST, + RTFSISOMAKERCMD_OPT_HFS_ICON_POSITION, + RTFSISOMAKERCMD_OPT_HFS_INPUT_CHARSET, + RTFSISOMAKERCMD_OPT_HFS_MAC_NAME, + RTFSISOMAKERCMD_OPT_HFS_MACBIN, + RTFSISOMAKERCMD_OPT_HFS_MAGIC, + RTFSISOMAKERCMD_OPT_HFS_MAP, + RTFSISOMAKERCMD_OPT_HFS_NETATALK, + RTFSISOMAKERCMD_OPT_HFS_NO_DESKTOP, + RTFSISOMAKERCMD_OPT_HFS_OSX_DOUBLE, + RTFSISOMAKERCMD_OPT_HFS_OSX_HFS, + RTFSISOMAKERCMD_OPT_HFS_OUTPUT_CHARSET, + RTFSISOMAKERCMD_OPT_HFS_PARMS, + RTFSISOMAKERCMD_OPT_HFS_PART, + RTFSISOMAKERCMD_OPT_HFS_PREP_BOOT, + RTFSISOMAKERCMD_OPT_HFS_PROBE, + RTFSISOMAKERCMD_OPT_HFS_ROOT_INFO, + RTFSISOMAKERCMD_OPT_HFS_SFM, + RTFSISOMAKERCMD_OPT_HFS_SGI, + RTFSISOMAKERCMD_OPT_HFS_SINGLE, + RTFSISOMAKERCMD_OPT_HFS_TYPE, + RTFSISOMAKERCMD_OPT_HFS_UNLOCK, + RTFSISOMAKERCMD_OPT_HFS_USHARE, + RTFSISOMAKERCMD_OPT_HFS_VOL_ID, + RTFSISOMAKERCMD_OPT_HFS_XINET, + RTFSISOMAKERCMD_OPT_HIDDEN, + RTFSISOMAKERCMD_OPT_HIDDEN_LIST, + RTFSISOMAKERCMD_OPT_HIDE, + RTFSISOMAKERCMD_OPT_HIDE_JOLIET, + RTFSISOMAKERCMD_OPT_HIDE_JOLIET_LIST, + RTFSISOMAKERCMD_OPT_HIDE_JOLIET_TRANS_TBL, + RTFSISOMAKERCMD_OPT_HIDE_LIST, + RTFSISOMAKERCMD_OPT_HIDE_RR_MOVED, + RTFSISOMAKERCMD_OPT_HPPA_BOOTLOADER, + RTFSISOMAKERCMD_OPT_HPPA_CMDLINE, + RTFSISOMAKERCMD_OPT_HPPA_KERNEL_32, + RTFSISOMAKERCMD_OPT_HPPA_KERNEL_64, + RTFSISOMAKERCMD_OPT_HPPA_RAMDISK, + RTFSISOMAKERCMD_OPT_INPUT_CHARSET, + RTFSISOMAKERCMD_OPT_ISO_LEVEL, + RTFSISOMAKERCMD_OPT_JIGDO_COMPRESS, + RTFSISOMAKERCMD_OPT_JIGDO_EXCLUDE, + RTFSISOMAKERCMD_OPT_JIGDO_FORCE_MD5, + RTFSISOMAKERCMD_OPT_JIGDO_JIGDO, + RTFSISOMAKERCMD_OPT_JIGDO_MAP, + RTFSISOMAKERCMD_OPT_JIGDO_MD5_LIST, + RTFSISOMAKERCMD_OPT_JIGDO_MIN_FILE_SIZE, + RTFSISOMAKERCMD_OPT_JIGDO_TEMPLATE, + RTFSISOMAKERCMD_OPT_JOLIET_CHARSET, + RTFSISOMAKERCMD_OPT_JOLIET_LEVEL, + RTFSISOMAKERCMD_OPT_JOLIET_LONG, + RTFSISOMAKERCMD_OPT_LOG_FILE, + RTFSISOMAKERCMD_OPT_MAX_ISO9660_FILENAMES, + RTFSISOMAKERCMD_OPT_MIPS_BOOT, + RTFSISOMAKERCMD_OPT_MIPSEL_BOOT, + RTFSISOMAKERCMD_OPT_NEW_DIR_MODE, + RTFSISOMAKERCMD_OPT_NO_BACKUP_FILES, + RTFSISOMAKERCMD_OPT_NO_DETECT_HARDLINKS, + RTFSISOMAKERCMD_OPT_NO_ISO_TRANSLATE, + RTFSISOMAKERCMD_OPT_NO_PAD, + RTFSISOMAKERCMD_OPT_NO_RR, + RTFSISOMAKERCMD_OPT_NO_SPLIT_SYMLINK_COMPONENTS, + RTFSISOMAKERCMD_OPT_NO_SPLIT_SYMLINK_FIELDS, + RTFSISOMAKERCMD_OPT_OLD_ROOT, + RTFSISOMAKERCMD_OPT_OUTPUT_CHARSET, + RTFSISOMAKERCMD_OPT_PAD, + RTFSISOMAKERCMD_OPT_PATH_LIST, + RTFSISOMAKERCMD_OPT_PRINT_SIZE, + RTFSISOMAKERCMD_OPT_QUIET, + RTFSISOMAKERCMD_OPT_RELAXED_FILENAMES, + RTFSISOMAKERCMD_OPT_ROOT, + RTFSISOMAKERCMD_OPT_SORT, + RTFSISOMAKERCMD_OPT_SPARC_BOOT, + RTFSISOMAKERCMD_OPT_SPARC_LABEL, + RTFSISOMAKERCMD_OPT_SPLIT_OUTPUT, + RTFSISOMAKERCMD_OPT_STREAM_FILE_NAME, + RTFSISOMAKERCMD_OPT_STREAM_MEDIA_SIZE, + RTFSISOMAKERCMD_OPT_SUNX86_BOOT, + RTFSISOMAKERCMD_OPT_SUNX86_LABEL, + RTFSISOMAKERCMD_OPT_SYSTEM_ID, + RTFSISOMAKERCMD_OPT_TRANS_TBL_NAME, + RTFSISOMAKERCMD_OPT_UDF, + RTFSISOMAKERCMD_OPT_UID, + RTFSISOMAKERCMD_OPT_USE_FILE_VERSION, + RTFSISOMAKERCMD_OPT_VOLUME_ID, + RTFSISOMAKERCMD_OPT_VOLUME_SET_ID, + RTFSISOMAKERCMD_OPT_VOLUME_SET_SEQ_NO, + RTFSISOMAKERCMD_OPT_VOLUME_SET_SIZE, + RTFSISOMAKERCMD_OPT_END +} RTFSISOMAKERCMDOPT; + + +/** + * El Torito boot entry. + */ +typedef struct RTFSISOMKCMDELTORITOENTRY +{ + /** The type of this entry. */ + enum + { + kEntryType_Invalid = 0, + kEntryType_Validation, /**< Same as kEntryType_SectionHeader, just hardcoded #0. */ + kEntryType_SectionHeader, + kEntryType_Default, /**< Same as kEntryType_Section, just hardcoded #1. */ + kEntryType_Section + } enmType; + /** Type specific data. */ + union + { + struct + { + /** The platform ID (ISO9660_ELTORITO_PLATFORM_ID_XXX). */ + uint8_t idPlatform; + /** Some string for the header. */ + const char *pszString; + } Validation, + SectionHeader; + struct + { + /** The name of the boot image wihtin the ISO (-b option). */ + const char *pszImageNameInIso; + /** The object ID of the image in the ISO. This is set to UINT32_MAX when + * pszImageNameInIso is used (i.e. -b option) and we've delayed everything + * boot related till after all files have been added to the image. */ + uint32_t idxImageObj; + /** Whether to insert boot info table into the image. */ + bool fInsertBootInfoTable; + /** Bootble or not. Possible to make BIOS set up emulation w/o booting it. */ + bool fBootable; + /** The media type (ISO9660_ELTORITO_BOOT_MEDIA_TYPE_XXX). */ + uint8_t bBootMediaType; + /** File system / partition type. */ + uint8_t bSystemType; + /** Load address divided by 0x10. */ + uint16_t uLoadSeg; + /** Number of sectors (512) to load. */ + uint16_t cSectorsToLoad; + } Section, + Default; + } u; +} RTFSISOMKCMDELTORITOENTRY; +/** Pointer to an el torito boot entry. */ +typedef RTFSISOMKCMDELTORITOENTRY *PRTFSISOMKCMDELTORITOENTRY; + +/** + * ISO maker command options & state. + */ +typedef struct RTFSISOMAKERCMDOPTS +{ + /** The handle to the ISO maker. */ + RTFSISOMAKER hIsoMaker; + /** Set if we're creating a virtual image maker, i.e. producing something + * that is going to be read from only and not written to disk. */ + bool fVirtualImageMaker; + /** Extended error info. This is a stderr alternative for the + * fVirtualImageMaker case (stdout goes to LogRel). */ + PRTERRINFO pErrInfo; + + /** The output file. + * This is NULL when fVirtualImageMaker is set. */ + const char *pszOutFile; + /** Special buffer size to use for testing the ISO maker code reading. */ + uint32_t cbOutputReadBuffer; + /** Use random output read buffer size. cbOutputReadBuffer works as maximum + * when this is enabled. */ + bool fRandomOutputReadBufferSize; + /** Do output verification, but do it in random order if non-zero. The + * values gives the block size to use. */ + uint32_t cbRandomOrderVerifciationBlock; + + /** Index of the top source stack entry, -1 if empty. */ + int32_t iSrcStack; + struct + { + /** The root VFS dir or the CWD for relative paths. */ + RTVFSDIR hSrcDir; + /** The current source VFS, NIL_RTVFS if the regular file system is used. */ + RTVFS hSrcVfs; + /** The specifier for hSrcVfs (error messages). */ + const char *pszSrcVfs; + /** The option for hSrcVfs. + * This is NULL for a CWD passed via the API that shouldn't be popped. */ + const char *pszSrcVfsOption; + } aSrcStack[5]; + + /** @name Processing of inputs + * @{ */ + /** The namespaces (RTFSISOMAKER_NAMESPACE_XXX) we're currently adding + * input to. */ + uint32_t fDstNamespaces; + /** The number of name specifiers we're currently operating with. */ + uint32_t cNameSpecifiers; + /** Name specifier configurations. + * For instance given "name0=name1=name2=name3=source-file" we will add + * source-file to the image with name0 as the name in the namespace and + * sub-name specified by aNameSpecifiers[0], name1 in aNameSpecifiers[1], + * and so on. This allows exact control over which names a file will + * have in each namespace (primary-iso, joliet, udf, hfs) and sub-namespace + * (rock-ridge, trans.tbl). + */ + uint32_t afNameSpecifiers[RTFSISOMAKERCMD_MAX_NAMES]; + /** The forced directory mode. */ + RTFMODE fDirMode; + /** Set if fDirMode should be applied. */ + bool fDirModeActive; + /** Set if fFileMode should be applied. */ + bool fFileModeActive; + /** The force file mode. */ + RTFMODE fFileMode; + /** @} */ + + /** @name Booting related options and state. + * @{ */ + /** Number of boot catalog entries (aBootCatEntries). */ + uint32_t cBootCatEntries; + /** Boot catalog entries. */ + RTFSISOMKCMDELTORITOENTRY aBootCatEntries[64]; + /** @} */ + + /** @name Filtering + * @{ */ + /** The trans.tbl filename when enabled. We must not import these files. */ + const char *pszTransTbl; + /** @} */ + + /** Number of items (files, directories, images, whatever) we've added. */ + uint32_t cItemsAdded; +} RTFSISOMAKERCMDOPTS; +typedef RTFSISOMAKERCMDOPTS *PRTFSISOMAKERCMDOPTS; +typedef RTFSISOMAKERCMDOPTS const *PCRTFSISOMAKERCMDOPTS; + + +/** + * One parsed name. + */ +typedef struct RTFSISOMKCMDPARSEDNAME +{ + /** Copy of the corresponding RTFSISOMAKERCMDOPTS::afNameSpecifiers + * value. */ + uint32_t fNameSpecifiers; + /** The length of the specified path. */ + uint32_t cchPath; + /** Specified path. */ + char szPath[RTPATH_MAX]; +} RTFSISOMKCMDPARSEDNAME; +/** Pointer to a parsed name. */ +typedef RTFSISOMKCMDPARSEDNAME *PRTFSISOMKCMDPARSEDNAME; +/** Pointer to a const parsed name. */ +typedef RTFSISOMKCMDPARSEDNAME const *PCRTFSISOMKCMDPARSEDNAME; + + +/** + * Parsed names. + */ +typedef struct RTFSISOMKCMDPARSEDNAMES +{ + /** Number of names. */ + uint32_t cNames; + /** Number of names with the source. */ + uint32_t cNamesWithSrc; + /** Special source types. + * Used for conveying commands to do on names intead of adding a source. + * Only used when adding generic stuff w/o any options involved. */ + enum + { + kSrcType_None, + kSrcType_Normal, + kSrcType_NormalSrcStack, + kSrcType_Remove, + kSrcType_MustRemove + } enmSrcType; + /** The parsed names. */ + RTFSISOMKCMDPARSEDNAME aNames[RTFSISOMAKERCMD_MAX_NAMES + 1]; +} RTFSISOMKCMDPARSEDNAMES; +/** Pointer to parsed names. */ +typedef RTFSISOMKCMDPARSEDNAMES *PRTFSISOMKCMDPARSEDNAMES; +/** Pointer to const parsed names. */ +typedef RTFSISOMKCMDPARSEDNAMES *PCRTFSISOMKCMDPARSEDNAMES; + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/* + * Parse the command line. This is similar to genisoimage and mkisofs, + * thus the single dash long name aliases. + */ +static const RTGETOPTDEF g_aRtFsIsoMakerOptions[] = +{ + /* + * Unique IPRT ISO maker options. + */ + { "--name-setup", RTFSISOMAKERCMD_OPT_NAME_SETUP, RTGETOPT_REQ_STRING }, + { "--import-iso", RTFSISOMAKERCMD_OPT_IMPORT_ISO, RTGETOPT_REQ_STRING }, + { "--push-iso", RTFSISOMAKERCMD_OPT_PUSH_ISO, RTGETOPT_REQ_STRING }, + { "--push-iso-no-joliet", RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_JOLIET, RTGETOPT_REQ_STRING }, + { "--push-iso-no-rock", RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK, RTGETOPT_REQ_STRING }, + { "--push-iso-no-rock-no-joliet", RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK_NO_JOLIET, RTGETOPT_REQ_STRING }, + { "--pop", RTFSISOMAKERCMD_OPT_POP, RTGETOPT_REQ_NOTHING }, + + { "--rock-ridge", RTFSISOMAKERCMD_OPT_ROCK_RIDGE, RTGETOPT_REQ_NOTHING }, + { "--limited-rock-ridge", RTFSISOMAKERCMD_OPT_LIMITED_ROCK_RIDGE, RTGETOPT_REQ_NOTHING }, + { "--no-rock-ridge", RTFSISOMAKERCMD_OPT_NO_ROCK_RIDGE, RTGETOPT_REQ_NOTHING }, + { "--no-joliet", RTFSISOMAKERCMD_OPT_NO_JOLIET, RTGETOPT_REQ_NOTHING }, + { "--joliet-ucs-level", RTFSISOMAKERCMD_OPT_JOLIET_LEVEL, RTGETOPT_REQ_UINT8 }, + + { "--rational-attribs", RTFSISOMAKERCMD_OPT_RATIONAL_ATTRIBS, RTGETOPT_REQ_NOTHING }, + { "--strict-attribs", RTFSISOMAKERCMD_OPT_STRICT_ATTRIBS, RTGETOPT_REQ_NOTHING }, + { "--no-file-mode", RTFSISOMAKERCMD_OPT_NO_FILE_MODE, RTGETOPT_REQ_NOTHING }, + { "--no-dir-mode", RTFSISOMAKERCMD_OPT_NO_DIR_MODE, RTGETOPT_REQ_NOTHING }, + { "--chmod", RTFSISOMAKERCMD_OPT_CHMOD, RTGETOPT_REQ_STRING }, + { "--chown", RTFSISOMAKERCMD_OPT_CHOWN, RTGETOPT_REQ_STRING }, + { "--chgrp", RTFSISOMAKERCMD_OPT_CHGRP, RTGETOPT_REQ_STRING }, + + { "--eltorito-new-entry", RTFSISOMAKERCMD_OPT_ELTORITO_NEW_ENTRY, RTGETOPT_REQ_NOTHING }, + { "--eltorito-add-image", RTFSISOMAKERCMD_OPT_ELTORITO_ADD_IMAGE, RTGETOPT_REQ_STRING }, + { "--eltorito-floppy-12", RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_12, RTGETOPT_REQ_NOTHING }, + { "--eltorito-floppy-144", RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_144, RTGETOPT_REQ_NOTHING }, + { "--eltorito-floppy-288", RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_288, RTGETOPT_REQ_NOTHING }, + + { "--iprt-iso-maker-file-marker", RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, RTGETOPT_REQ_STRING }, + { "--iprt-iso-maker-file-marker-ms", RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, RTGETOPT_REQ_STRING }, + { "--iprt-iso-maker-file-marker-ms-crt", RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, RTGETOPT_REQ_STRING }, + { "--iprt-iso-maker-file-marker-bourne", RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, RTGETOPT_REQ_STRING }, + { "--iprt-iso-maker-file-marker-bourne-sh", RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER, RTGETOPT_REQ_STRING }, + + { "--output-buffer-size", RTFSISOMAKERCMD_OPT_OUTPUT_BUFFER_SIZE, RTGETOPT_REQ_UINT32 }, + { "--random-output-buffer-size", RTFSISOMAKERCMD_OPT_RANDOM_OUTPUT_BUFFER_SIZE, RTGETOPT_REQ_NOTHING }, + { "--random-order-verification", RTFSISOMAKERCMD_OPT_RANDOM_ORDER_VERIFICATION, RTGETOPT_REQ_UINT32 }, + +#define DD(a_szLong, a_chShort, a_fFlags) { a_szLong, a_chShort, a_fFlags }, { "-" a_szLong, a_chShort, a_fFlags } + + /* + * genisoimage/mkisofs compatibility options we've implemented: + */ + /* booting: */ + { "--generic-boot", 'G', RTGETOPT_REQ_STRING }, + DD("-eltorito-boot", 'b', RTGETOPT_REQ_STRING ), + DD("-eltorito-alt-boot", RTFSISOMAKERCMD_OPT_ELTORITO_NEW_ENTRY, RTGETOPT_REQ_NOTHING ), + DD("-eltorito-platform-id", RTFSISOMAKERCMD_OPT_ELTORITO_PLATFORM_ID, RTGETOPT_REQ_STRING ), + DD("-hard-disk-boot", RTFSISOMAKERCMD_OPT_ELTORITO_HARD_DISK_BOOT, RTGETOPT_REQ_NOTHING ), + DD("-no-emulation-boot", RTFSISOMAKERCMD_OPT_ELTORITO_NO_EMULATION_BOOT, RTGETOPT_REQ_NOTHING ), + DD("-no-boot", RTFSISOMAKERCMD_OPT_ELTORITO_NO_BOOT, RTGETOPT_REQ_NOTHING ), + DD("-boot-load-seg", RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SEG, RTGETOPT_REQ_UINT16 ), + DD("-boot-load-size", RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SIZE, RTGETOPT_REQ_UINT16 ), + DD("-boot-info-table", RTFSISOMAKERCMD_OPT_ELTORITO_INFO_TABLE, RTGETOPT_REQ_NOTHING ), + { "--boot-catalog", 'c', RTGETOPT_REQ_STRING }, + + /* String props: */ + DD("-abstract", RTFSISOMAKERCMD_OPT_ABSTRACT_FILE_ID, RTGETOPT_REQ_STRING ), + { "--application-id", 'A', RTGETOPT_REQ_STRING }, + DD("-biblio", RTFSISOMAKERCMD_OPT_BIBLIOGRAPHIC_FILE_ID, RTGETOPT_REQ_STRING ), + DD("-copyright", RTFSISOMAKERCMD_OPT_COPYRIGHT_FILE_ID, RTGETOPT_REQ_STRING ), + DD("-publisher", 'P', RTGETOPT_REQ_STRING ), + { "--preparer", 'p', RTGETOPT_REQ_STRING }, + DD("-sysid", RTFSISOMAKERCMD_OPT_SYSTEM_ID, RTGETOPT_REQ_STRING ), + { "--volume-id", RTFSISOMAKERCMD_OPT_VOLUME_ID, RTGETOPT_REQ_STRING }, /* should've been '-V' */ + DD("-volid", RTFSISOMAKERCMD_OPT_VOLUME_ID, RTGETOPT_REQ_STRING ), + DD("-volset", RTFSISOMAKERCMD_OPT_VOLUME_SET_ID, RTGETOPT_REQ_STRING ), + + /* Other: */ + DD("-file-mode", RTFSISOMAKERCMD_OPT_FILE_MODE, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT ), + DD("-dir-mode", RTFSISOMAKERCMD_OPT_DIR_MODE, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT ), + DD("-new-dir-mode", RTFSISOMAKERCMD_OPT_NEW_DIR_MODE, RTGETOPT_REQ_UINT32 | RTGETOPT_FLAG_OCT ), + DD("-graft-points", RTFSISOMAKERCMD_OPT_GRAFT_POINTS, RTGETOPT_REQ_NOTHING ), + DD("--iso-level", RTFSISOMAKERCMD_OPT_ISO_LEVEL, RTGETOPT_REQ_UINT8 ), + { "--long-names", 'l', RTGETOPT_REQ_NOTHING }, + { "--output", 'o', RTGETOPT_REQ_STRING }, + { "--joliet", 'J', RTGETOPT_REQ_NOTHING }, + DD("-ucs-level", RTFSISOMAKERCMD_OPT_JOLIET_LEVEL, RTGETOPT_REQ_UINT8 ), + DD("-rock", 'R', RTGETOPT_REQ_NOTHING ), + DD("-rational-rock", 'r', RTGETOPT_REQ_NOTHING ), + DD("-pad", RTFSISOMAKERCMD_OPT_PAD, RTGETOPT_REQ_NOTHING ), + DD("-no-pad", RTFSISOMAKERCMD_OPT_NO_PAD, RTGETOPT_REQ_NOTHING ), + + /* + * genisoimage/mkisofs compatibility: + */ + DD("-allow-limited-size", RTFSISOMAKERCMD_OPT_ALLOW_LIMITED_SIZE, RTGETOPT_REQ_NOTHING ), + DD("-allow-leading-dots", RTFSISOMAKERCMD_OPT_ALLOW_LEADING_DOTS, RTGETOPT_REQ_NOTHING ), + DD("-ldots", RTFSISOMAKERCMD_OPT_ALLOW_LEADING_DOTS, RTGETOPT_REQ_NOTHING ), + DD("-allow-lowercase", RTFSISOMAKERCMD_OPT_ALLOW_LOWERCASE, RTGETOPT_REQ_NOTHING ), + DD("-allow-multidot", RTFSISOMAKERCMD_OPT_ALLOW_MULTI_DOT, RTGETOPT_REQ_NOTHING ), + DD("-cache-inodes", RTFSISOMAKERCMD_OPT_DETECT_HARDLINKS, RTGETOPT_REQ_NOTHING ), + DD("-no-cache-inodes", RTFSISOMAKERCMD_OPT_NO_DETECT_HARDLINKS, RTGETOPT_REQ_NOTHING ), + DD("-alpha-boot", RTFSISOMAKERCMD_OPT_ALPHA_BOOT, RTGETOPT_REQ_STRING ), + DD("-hppa-bootloader", RTFSISOMAKERCMD_OPT_HPPA_BOOTLOADER, RTGETOPT_REQ_STRING ), + DD("-hppa-cmdline", RTFSISOMAKERCMD_OPT_HPPA_CMDLINE, RTGETOPT_REQ_STRING ), + DD("-hppa-kernel-32", RTFSISOMAKERCMD_OPT_HPPA_KERNEL_32, RTGETOPT_REQ_STRING ), + DD("-hppa-kernel-64", RTFSISOMAKERCMD_OPT_HPPA_KERNEL_64, RTGETOPT_REQ_STRING ), + DD("-hppa-ramdisk", RTFSISOMAKERCMD_OPT_HPPA_RAMDISK, RTGETOPT_REQ_STRING ), + DD("-mips-boot", RTFSISOMAKERCMD_OPT_MIPS_BOOT, RTGETOPT_REQ_STRING ), + DD("-mipsel-boot", RTFSISOMAKERCMD_OPT_MIPSEL_BOOT, RTGETOPT_REQ_STRING ), + DD("-sparc-boot", 'B', RTGETOPT_REQ_STRING ), + { "--cd-extra", 'C', RTGETOPT_REQ_STRING }, + DD("-check-oldnames", RTFSISOMAKERCMD_OPT_CHECK_OLD_NAMES, RTGETOPT_REQ_NOTHING ), + DD("-check-session", RTFSISOMAKERCMD_OPT_CHECK_SESSION, RTGETOPT_REQ_STRING ), + { "--dont-append-dot", 'd', RTGETOPT_REQ_NOTHING }, + { "--deep-directories", 'D', RTGETOPT_REQ_NOTHING }, + DD("-dvd-video", RTFSISOMAKERCMD_OPT_DVD_VIDEO, RTGETOPT_REQ_NOTHING ), + DD("-follow-symlinks", 'f', RTGETOPT_REQ_NOTHING ), + DD("-gid", RTFSISOMAKERCMD_OPT_GID, RTGETOPT_REQ_UINT32 ), + DD("-gui", RTFSISOMAKERCMD_OPT_GUI, RTGETOPT_REQ_NOTHING ), + DD("-hide", RTFSISOMAKERCMD_OPT_HIDE, RTGETOPT_REQ_STRING ), + DD("-hide-list", RTFSISOMAKERCMD_OPT_HIDE_LIST, RTGETOPT_REQ_STRING ), + DD("-hidden", RTFSISOMAKERCMD_OPT_HIDDEN, RTGETOPT_REQ_STRING ), + DD("-hidden-list", RTFSISOMAKERCMD_OPT_HIDDEN_LIST, RTGETOPT_REQ_STRING ), + DD("-hide-joliet", RTFSISOMAKERCMD_OPT_HIDE_JOLIET, RTGETOPT_REQ_STRING ), + DD("-hide-joliet-list", RTFSISOMAKERCMD_OPT_HIDE_JOLIET_LIST, RTGETOPT_REQ_STRING ), + DD("-hide-joliet-trans-tbl", RTFSISOMAKERCMD_OPT_HIDE_JOLIET_TRANS_TBL, RTGETOPT_REQ_NOTHING ), + DD("-hide-rr-moved", RTFSISOMAKERCMD_OPT_HIDE_RR_MOVED, RTGETOPT_REQ_NOTHING ), + DD("-input-charset", RTFSISOMAKERCMD_OPT_INPUT_CHARSET, RTGETOPT_REQ_STRING ), + DD("-output-charset", RTFSISOMAKERCMD_OPT_OUTPUT_CHARSET, RTGETOPT_REQ_STRING ), + DD("-joliet-long", RTFSISOMAKERCMD_OPT_JOLIET_LONG, RTGETOPT_REQ_NOTHING ), + DD("-jcharset", RTFSISOMAKERCMD_OPT_JOLIET_CHARSET, RTGETOPT_REQ_STRING ), + { "--leading-dot", 'L', RTGETOPT_REQ_NOTHING }, + DD("-jigdo-jigdo", RTFSISOMAKERCMD_OPT_JIGDO_JIGDO, RTGETOPT_REQ_STRING ), + DD("-jigdo-template", RTFSISOMAKERCMD_OPT_JIGDO_TEMPLATE, RTGETOPT_REQ_STRING ), + DD("-jigdo-min-file-size", RTFSISOMAKERCMD_OPT_JIGDO_MIN_FILE_SIZE, RTGETOPT_REQ_UINT64 ), + DD("-jigdo-force-md5", RTFSISOMAKERCMD_OPT_JIGDO_FORCE_MD5, RTGETOPT_REQ_STRING ), + DD("-jigdo-exclude", RTFSISOMAKERCMD_OPT_JIGDO_EXCLUDE, RTGETOPT_REQ_STRING ), + DD("-jigdo-map", RTFSISOMAKERCMD_OPT_JIGDO_MAP, RTGETOPT_REQ_STRING ), + DD("-md5-list", RTFSISOMAKERCMD_OPT_JIGDO_MD5_LIST, RTGETOPT_REQ_STRING ), + DD("-jigdo-template-compress", RTFSISOMAKERCMD_OPT_JIGDO_COMPRESS, RTGETOPT_REQ_STRING ), + DD("-log-file", RTFSISOMAKERCMD_OPT_LOG_FILE, RTGETOPT_REQ_STRING ), + { "--exclude", 'm', RTGETOPT_REQ_STRING }, + { "--exclude", 'x', RTGETOPT_REQ_STRING }, + DD("-exclude-list", RTFSISOMAKERCMD_OPT_EXCLUDE_LIST, RTGETOPT_REQ_STRING ), + DD("-max-iso9660-filenames", RTFSISOMAKERCMD_OPT_MAX_ISO9660_FILENAMES, RTGETOPT_REQ_NOTHING ), + { "--merge", 'M', RTGETOPT_REQ_STRING }, + DD("-dev", 'M', RTGETOPT_REQ_STRING ), + { "--omit-version-numbers", 'N', RTGETOPT_REQ_NOTHING }, + DD("-nobak", RTFSISOMAKERCMD_OPT_NO_BACKUP_FILES, RTGETOPT_REQ_NOTHING ), + DD("-no-bak", RTFSISOMAKERCMD_OPT_NO_BACKUP_FILES, RTGETOPT_REQ_NOTHING ), + DD("-force-rr", RTFSISOMAKERCMD_OPT_FORCE_RR, RTGETOPT_REQ_NOTHING ), + DD("-no-rr", RTFSISOMAKERCMD_OPT_NO_RR, RTGETOPT_REQ_NOTHING ), + DD("-no-split-symlink-components", RTFSISOMAKERCMD_OPT_NO_SPLIT_SYMLINK_COMPONENTS, RTGETOPT_REQ_NOTHING ), + DD("-no-split-symlink-fields", RTFSISOMAKERCMD_OPT_NO_SPLIT_SYMLINK_FIELDS, RTGETOPT_REQ_NOTHING ), + DD("-path-list", RTFSISOMAKERCMD_OPT_PATH_LIST, RTGETOPT_REQ_STRING ), + DD("-print-size", RTFSISOMAKERCMD_OPT_PRINT_SIZE, RTGETOPT_REQ_NOTHING ), + DD("-quiet", RTFSISOMAKERCMD_OPT_QUIET, RTGETOPT_REQ_NOTHING ), + DD("-relaxed-filenames", RTFSISOMAKERCMD_OPT_RELAXED_FILENAMES, RTGETOPT_REQ_NOTHING ), + DD("-root", RTFSISOMAKERCMD_OPT_ROOT, RTGETOPT_REQ_STRING ), + DD("-old-root", RTFSISOMAKERCMD_OPT_OLD_ROOT, RTGETOPT_REQ_STRING ), + DD("-sort", RTFSISOMAKERCMD_OPT_SORT, RTGETOPT_REQ_STRING ), + DD("-sparc-boot", RTFSISOMAKERCMD_OPT_SPARC_BOOT, RTGETOPT_REQ_STRING ), + DD("-sparc-label", RTFSISOMAKERCMD_OPT_SPARC_LABEL, RTGETOPT_REQ_STRING ), + DD("-split-output", RTFSISOMAKERCMD_OPT_SPLIT_OUTPUT, RTGETOPT_REQ_NOTHING ), + DD("-stream-media-size", RTFSISOMAKERCMD_OPT_STREAM_MEDIA_SIZE, RTGETOPT_REQ_UINT64 ), + DD("-stream-file-name", RTFSISOMAKERCMD_OPT_STREAM_FILE_NAME, RTGETOPT_REQ_STRING ), + DD("-sunx86-boot", RTFSISOMAKERCMD_OPT_SUNX86_BOOT, RTGETOPT_REQ_STRING ), + DD("-sunx86-label", RTFSISOMAKERCMD_OPT_SUNX86_LABEL, RTGETOPT_REQ_STRING ), + { "--trans-tbl", 'T', RTGETOPT_REQ_NOTHING }, + DD("-table-name", RTFSISOMAKERCMD_OPT_TRANS_TBL_NAME, RTGETOPT_REQ_STRING ), + DD("-udf", RTFSISOMAKERCMD_OPT_UDF, RTGETOPT_REQ_NOTHING ), + DD("-uid", RTFSISOMAKERCMD_OPT_UID, RTGETOPT_REQ_UINT32 ), + DD("-use-fileversion", RTFSISOMAKERCMD_OPT_USE_FILE_VERSION, RTGETOPT_REQ_NOTHING ), + { "--untranslated-filenames", 'U', RTGETOPT_REQ_NOTHING }, + DD("-no-iso-translate", RTFSISOMAKERCMD_OPT_NO_ISO_TRANSLATE, RTGETOPT_REQ_NOTHING ), + DD("-volset-size", RTFSISOMAKERCMD_OPT_VOLUME_SET_SIZE, RTGETOPT_REQ_UINT32 ), + DD("-volset-seqno", RTFSISOMAKERCMD_OPT_VOLUME_SET_SEQ_NO, RTGETOPT_REQ_UINT32 ), + { "--transpared-compression", 'z', RTGETOPT_REQ_NOTHING }, + + /* HFS and ISO-9660 apple extensions. */ + DD("-hfs", RTFSISOMAKERCMD_OPT_HFS_ENABLE, RTGETOPT_REQ_NOTHING ), + DD("-apple", RTFSISOMAKERCMD_OPT_APPLE, RTGETOPT_REQ_NOTHING ), + DD("-map", RTFSISOMAKERCMD_OPT_HFS_MAP, RTGETOPT_REQ_STRING ), + DD("-magic", RTFSISOMAKERCMD_OPT_HFS_MAGIC, RTGETOPT_REQ_STRING ), + DD("-hfs-creator", RTFSISOMAKERCMD_OPT_HFS_CREATOR, RTGETOPT_REQ_STRING ), + DD("-hfs-type", RTFSISOMAKERCMD_OPT_HFS_TYPE, RTGETOPT_REQ_STRING ), + DD("-probe", RTFSISOMAKERCMD_OPT_HFS_PROBE, RTGETOPT_REQ_NOTHING ), + DD("-no-desktop", RTFSISOMAKERCMD_OPT_HFS_NO_DESKTOP, RTGETOPT_REQ_NOTHING ), + DD("-mac-name", RTFSISOMAKERCMD_OPT_HFS_MAC_NAME, RTGETOPT_REQ_NOTHING ), + DD("-boot-hfs-file", RTFSISOMAKERCMD_OPT_HFS_BOOT_FILE, RTGETOPT_REQ_STRING ), + DD("-part", RTFSISOMAKERCMD_OPT_HFS_PART, RTGETOPT_REQ_NOTHING ), + DD("-auto", RTFSISOMAKERCMD_OPT_HFS_AUTO, RTGETOPT_REQ_STRING ), + DD("-cluster-size", RTFSISOMAKERCMD_OPT_HFS_CLUSTER_SIZE, RTGETOPT_REQ_UINT32 ), + DD("-hide-hfs", RTFSISOMAKERCMD_OPT_HFS_HIDE, RTGETOPT_REQ_STRING ), + DD("-hide-hfs-list", RTFSISOMAKERCMD_OPT_HFS_HIDE_LIST, RTGETOPT_REQ_STRING ), + DD("-hfs-volid", RTFSISOMAKERCMD_OPT_HFS_VOL_ID, RTGETOPT_REQ_STRING ), + DD("-icon-position", RTFSISOMAKERCMD_OPT_HFS_ICON_POSITION, RTGETOPT_REQ_NOTHING ), + DD("-root-info", RTFSISOMAKERCMD_OPT_HFS_ROOT_INFO, RTGETOPT_REQ_STRING ), + DD("-prep-boot", RTFSISOMAKERCMD_OPT_HFS_PREP_BOOT, RTGETOPT_REQ_STRING ), + DD("-chrp-boot", RTFSISOMAKERCMD_OPT_HFS_CHRP_BOOT, RTGETOPT_REQ_NOTHING ), + DD("-input-hfs-charset", RTFSISOMAKERCMD_OPT_HFS_INPUT_CHARSET, RTGETOPT_REQ_STRING ), + DD("-output-hfs-charset", RTFSISOMAKERCMD_OPT_HFS_OUTPUT_CHARSET, RTGETOPT_REQ_STRING ), + DD("-hfs-unlock", RTFSISOMAKERCMD_OPT_HFS_UNLOCK, RTGETOPT_REQ_NOTHING ), + DD("-hfs-bless", RTFSISOMAKERCMD_OPT_HFS_BLESS, RTGETOPT_REQ_STRING ), + DD("-hfs-parms", RTFSISOMAKERCMD_OPT_HFS_PARMS, RTGETOPT_REQ_STRING ), + { "--cap", RTFSISOMAKERCMD_OPT_HFS_CAP, RTGETOPT_REQ_NOTHING }, + { "--netatalk", RTFSISOMAKERCMD_OPT_HFS_NETATALK, RTGETOPT_REQ_NOTHING }, + { "--double", RTFSISOMAKERCMD_OPT_HFS_DOUBLE, RTGETOPT_REQ_NOTHING }, + { "--ethershare", RTFSISOMAKERCMD_OPT_HFS_ETHERSHARE, RTGETOPT_REQ_NOTHING }, + { "--ushare", RTFSISOMAKERCMD_OPT_HFS_USHARE, RTGETOPT_REQ_NOTHING }, + { "--exchange", RTFSISOMAKERCMD_OPT_HFS_EXCHANGE, RTGETOPT_REQ_NOTHING }, + { "--sgi", RTFSISOMAKERCMD_OPT_HFS_SGI, RTGETOPT_REQ_NOTHING }, + { "--xinet", RTFSISOMAKERCMD_OPT_HFS_XINET, RTGETOPT_REQ_NOTHING }, + { "--macbin", RTFSISOMAKERCMD_OPT_HFS_MACBIN, RTGETOPT_REQ_NOTHING }, + { "--single", RTFSISOMAKERCMD_OPT_HFS_SINGLE, RTGETOPT_REQ_NOTHING }, + { "--dave", RTFSISOMAKERCMD_OPT_HFS_DAVE, RTGETOPT_REQ_NOTHING }, + { "--sfm", RTFSISOMAKERCMD_OPT_HFS_SFM, RTGETOPT_REQ_NOTHING }, + { "--osx-double", RTFSISOMAKERCMD_OPT_HFS_OSX_DOUBLE, RTGETOPT_REQ_NOTHING }, + { "--osx-hfs", RTFSISOMAKERCMD_OPT_HFS_OSX_HFS, RTGETOPT_REQ_NOTHING }, +#undef DD +}; + +#ifndef RT_OS_OS2 /* fixme */ +# include "isomakercmd-man.h" +#endif + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtFsIsoMakerCmdParse(PRTFSISOMAKERCMDOPTS pOpts, unsigned cArgs, char **papszArgs, unsigned cDepth); + + +/** + * Wrapper around RTErrInfoSetV / RTMsgErrorV. + * + * @returns @a rc + * @param pOpts The ISO maker command instance. + * @param rc The return code. + * @param pszFormat The message format. + * @param ... The message format arguments. + */ +static int rtFsIsoMakerCmdErrorRc(PRTFSISOMAKERCMDOPTS pOpts, int rc, const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + if (pOpts->pErrInfo) + RTErrInfoSetV(pOpts->pErrInfo, rc, pszFormat, va); + else + RTMsgErrorV(pszFormat, va); + va_end(va); + return rc; +} + + +/** + * Wrapper around RTErrInfoSetV / RTMsgErrorV for doing the job of + * RTVfsChainMsgError. + * + * @returns @a rc + * @param pOpts The ISO maker command instance. + * @param pszFunction The API called. + * @param pszSpec The VFS chain specification or file path passed to the. + * @param rc The return code. + * @param offError The error offset value returned (0 if not captured). + * @param pErrInfo Additional error information. Optional. + */ +static int rtFsIsoMakerCmdChainError(PRTFSISOMAKERCMDOPTS pOpts, const char *pszFunction, const char *pszSpec, int rc, + uint32_t offError, PRTERRINFO pErrInfo) +{ + if (RTErrInfoIsSet(pErrInfo)) + { + if (offError > 0) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, + "%s failed with rc=%Rrc: %s\n" + " '%s'\n" + " %*s^", + pszFunction, rc, pErrInfo->pszMsg, pszSpec, offError, ""); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s failed to open '%s': %Rrc: %s", + pszFunction, pszSpec, rc, pErrInfo->pszMsg); + } + else + { + if (offError > 0) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, + "%s failed with rc=%Rrc:\n" + " '%s'\n" + " %*s^", + pszFunction, rc, pszSpec, offError, ""); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s failed to open '%s': %Rrc", pszFunction, pszSpec, rc); + } + return rc; +} + + +/** + * Wrapper around RTErrInfoSetV / RTMsgErrorV for displaying syntax errors. + * + * @returns VERR_INVALID_PARAMETER + * @param pOpts The ISO maker command instance. + * @param pszFormat The message format. + * @param ... The message format arguments. + */ +static int rtFsIsoMakerCmdSyntaxError(PRTFSISOMAKERCMDOPTS pOpts, const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + if (pOpts->pErrInfo) + RTErrInfoSetV(pOpts->pErrInfo, VERR_INVALID_PARAMETER, pszFormat, va); + else + RTMsgErrorV(pszFormat, va); + va_end(va); + return VERR_INVALID_PARAMETER; +} + + +/** + * Wrapper around RTPrintfV / RTLogRelPrintfV. + * + * @param pOpts The ISO maker command instance. + * @param pszFormat The message format. + * @param ... The message format arguments. + */ +static void rtFsIsoMakerPrintf(PRTFSISOMAKERCMDOPTS pOpts, const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + if (pOpts->pErrInfo) + RTLogRelPrintfV(pszFormat, va); + else + RTPrintfV(pszFormat, va); + va_end(va); +} + +/** + * Deletes the state and returns @a rc. + * + * @returns @a rc. + * @param pOpts The ISO maker command instance to delete. + * @param rc The status code to return. + */ +static int rtFsIsoMakerCmdDeleteState(PRTFSISOMAKERCMDOPTS pOpts, int rc) +{ + if (pOpts->hIsoMaker != NIL_RTFSISOMAKER) + { + RTFsIsoMakerRelease(pOpts->hIsoMaker); + pOpts->hIsoMaker = NIL_RTFSISOMAKER; + } + + while (pOpts->iSrcStack >= 0) + { + RTVfsDirRelease(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir); + RTVfsRelease(pOpts->aSrcStack[pOpts->iSrcStack].hSrcVfs); + pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir = NIL_RTVFSDIR; + pOpts->aSrcStack[pOpts->iSrcStack].hSrcVfs = NIL_RTVFS; + pOpts->iSrcStack--; + } + + return rc; +} + + +/** + * Print the usage. + * + * @param pOpts Options for print metho. + * @param pszProgName The program name. + */ +static void rtFsIsoMakerCmdUsage(PRTFSISOMAKERCMDOPTS pOpts, const char *pszProgName) +{ +#ifndef RT_OS_OS2 /* fixme */ + if (!pOpts->pErrInfo) + RTMsgRefEntryHelp(g_pStdOut, &g_viso); + else +#endif + rtFsIsoMakerPrintf(pOpts, "Usage: %s [options] [@commands.rsp] <filespec...>\n", + RTPathFilename(pszProgName)); +} + + +/** + * Verifies the image content by reading blocks in random order. + * + * This is for exercise the virtual ISO code better and test that we get the + * same data when reading something twice. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsSrcFile The source file (virtual ISO). + * @param hVfsDstFile The destination file (image file on disk). + * @param cbImage The size of the ISO. + */ +static int rtFsIsoMakerCmdVerifyImageInRandomOrder(PRTFSISOMAKERCMDOPTS pOpts, RTVFSFILE hVfsSrcFile, + RTVFSFILE hVfsDstFile, uint64_t cbImage) +{ + /* + * Figure the buffer (block) size and allocate a bitmap for noting down blocks we've covered. + */ + int rc; + size_t cbBuf = RT_MAX(pOpts->cbRandomOrderVerifciationBlock, 1); + uint64_t cBlocks64 = (cbImage + cbBuf - 1) / cbBuf; + if (cBlocks64 > _512M) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_OUT_OF_RANGE, + "verification block count too high: cBlocks=%#RX64 (cbBuf=%#zx), max 512M", cBlocks64, cbBuf); + uint32_t cBlocks = (uint32_t)cBlocks64; + uint32_t cbBitmap = (cBlocks + 63) / 8; + if (cbBitmap > _64M) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_OUT_OF_RANGE, + "verification bitmap too big: cbBitmap=%#RX32 (cbBuf=%#zx), max 64MB", cbBitmap, cbBuf); + void *pvSrcBuf = RTMemTmpAlloc(cbBuf); + void *pvDstBuf = RTMemTmpAlloc(cbBuf); + void *pvBitmap = RTMemTmpAllocZ(cbBitmap); + if (pvSrcBuf && pvDstBuf && pvBitmap) + { + /* Must set the unused bits in the top qword. */ + for (uint32_t i = RT_ALIGN_32(cBlocks, 64) - 1; i >= cBlocks; i--) + ASMBitSet(pvBitmap, i); + + /* + * Do the verification. + */ + rtFsIsoMakerPrintf(pOpts, "Verifying image in random order using %zu (%#zx) byte blocks: %#RX32 in blocks\n", + cbBuf, cbBuf, cBlocks); + + rc = VINF_SUCCESS; + uint64_t cLeft = cBlocks; + while (cLeft-- > 0) + { + /* + * Figure out which block to check next. + */ + uint32_t iBlock = RTRandU32Ex(0, cBlocks - 1); + if (!ASMBitTestAndSet(pvBitmap, iBlock)) + Assert(iBlock < cBlocks); + else + { + /* try 32 other random numbers. */ + bool fBitSet; + unsigned cTries = 0; + do + { + iBlock = RTRandU32Ex(0, cBlocks - 1); + fBitSet = ASMBitTestAndSet(pvBitmap, iBlock); + } while (fBitSet && ++cTries < 32); + if (fBitSet) + { + /* Look for the next clear bit after it (with wrap around). */ + int iHit = ASMBitNextClear(pvBitmap, cBlocks, iBlock); + Assert(iHit < (int32_t)cBlocks); + if (iHit < 0) + { + iHit = ASMBitFirstClear(pvBitmap, iBlock); + Assert(iHit < (int32_t)cBlocks); + } + if (iHit >= 0) + { + fBitSet = ASMBitTestAndSet(pvBitmap, iHit); + if (!fBitSet) + iBlock = iHit; + else + { + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_INTERNAL_ERROR_3, + "Bitmap weirdness: iHit=%#x iBlock=%#x cLeft=%#x cBlocks=%#x", + iHit, iBlock, cLeft, cBlocks); + if (!pOpts->pErrInfo) + RTMsgInfo("Bitmap: %#RX32 bytes\n%.*Rhxd", cbBitmap, cbBitmap, pvBitmap); + break; + } + } + else + { + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_INTERNAL_ERROR_2, + "Bitmap weirdness: iBlock=%#x cLeft=%#x cBlocks=%#x", + iBlock, cLeft, cBlocks); + if (!pOpts->pErrInfo) + RTMsgInfo("Bitmap: %#RX32 bytes\n%.*Rhxd", cbBitmap, cbBitmap, pvBitmap); + break; + } + } + } + Assert(ASMBitTest(pvBitmap, iBlock)); + + /* + * Figure out how much and where to read (last block fun). + */ + uint64_t offBlock = iBlock * (uint64_t)cbBuf; + size_t cbToRead = cbBuf; + if (iBlock + 1 < cBlocks) + { /* likely */ } + else if (cbToRead > cbImage - offBlock) + cbToRead = (size_t)(cbImage - offBlock); + Assert(offBlock + cbToRead <= cbImage); + + /* + * Read the blocks. + */ + //RTPrintf("Reading block #%#x at %#RX64\n", iBlock, offBlock); + rc = RTVfsFileReadAt(hVfsDstFile, offBlock, pvDstBuf, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + memset(pvSrcBuf, 0xdd, cbBuf); + rc = RTVfsFileReadAt(hVfsSrcFile, offBlock, pvSrcBuf, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + if (memcmp(pvDstBuf, pvSrcBuf, cbToRead) == 0) + continue; + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_MISMATCH, + "Block #%#x differs! offBlock=%#RX64 cbToRead=%#zu\n" + "Virtual ISO (source):\n%.*Rhxd\nWritten ISO (destination):\n%.*Rhxd", + iBlock, offBlock, cbToRead, cbToRead, pvSrcBuf, cbToRead, pvDstBuf); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, + "Error reading %#zx bytes source (virtual ISO) block #%#x at %#RX64: %Rrc", + cbToRead, iBlock, offBlock, rc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, + "Error reading %#zx bytes destination (written ISO) block #%#x at %#RX64: %Rrc", + cbToRead, iBlock, offBlock, rc); + break; + } + + if (RT_SUCCESS(rc)) + rtFsIsoMakerPrintf(pOpts, "Written image verified fine!\n"); + } + else if (!pvSrcBuf || !pvDstBuf) + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "RTMemTmpAlloc(%#zx) failed", cbBuf); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "RTMemTmpAlloc(%#zx) failed", cbBuf); + RTMemTmpFree(pvBitmap); + RTMemTmpFree(pvDstBuf); + RTMemTmpFree(pvSrcBuf); + return rc; +} + + +/** + * Writes the image to file, no checking, no special buffering. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsSrcFile The source file from the ISO maker. + * @param hVfsDstFile The destination file (image file on disk). + * @param cbImage The size of the ISO. + * @param ppvBuf Pointer to the buffer pointer. The buffer will + * be reallocated, but we want the luxary of the + * caller freeing it. + */ +static int rtFsIsoMakerCmdWriteImageRandomBufferSize(PRTFSISOMAKERCMDOPTS pOpts, RTVFSFILE hVfsSrcFile, RTVFSFILE hVfsDstFile, + uint64_t cbImage, void **ppvBuf) +{ + /* + * Copy the virtual image bits to the destination file. + */ + void *pvBuf = *ppvBuf; + uint32_t cbMaxBuf = pOpts->cbOutputReadBuffer > 0 ? pOpts->cbOutputReadBuffer : _64K; + uint64_t offImage = 0; + while (offImage < cbImage) + { + /* Figure out how much to copy this time. */ + size_t cbToCopy = RTRandU32Ex(1, cbMaxBuf - 1); + if (offImage + cbToCopy < cbImage) + { /* likely */ } + else + cbToCopy = (size_t)(cbImage - offImage); + RTMemFree(pvBuf); + *ppvBuf = pvBuf = RTMemTmpAlloc(cbToCopy); + if (pvBuf) + { + /* Do the copying. */ + int rc = RTVfsFileReadAt(hVfsSrcFile, offImage, pvBuf, cbToCopy, NULL); + if (RT_SUCCESS(rc)) + { + rc = RTVfsFileWriteAt(hVfsDstFile, offImage, pvBuf, cbToCopy, NULL); + if (RT_SUCCESS(rc)) + offImage += cbToCopy; + else + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error %Rrc writing %#zx bytes at offset %#RX64 to '%s'", + rc, cbToCopy, offImage, pOpts->pszOutFile); + } + else + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error %Rrc read %#zx bytes at offset %#RX64", rc, cbToCopy, offImage); + } + else + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "RTMemTmpAlloc(%#zx) failed", cbToCopy); + } + return VINF_SUCCESS; +} + + +/** + * Writes the image to file, no checking, no special buffering. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsSrcFile The source file from the ISO maker. + * @param hVfsDstFile The destination file (image file on disk). + * @param cbImage The size of the ISO. + * @param pvBuf Pointer to read buffer. + * @param cbBuf The buffer size. + */ +static int rtFsIsoMakerCmdWriteImageSimple(PRTFSISOMAKERCMDOPTS pOpts, RTVFSFILE hVfsSrcFile, RTVFSFILE hVfsDstFile, + uint64_t cbImage, void *pvBuf, size_t cbBuf) +{ + /* + * Copy the virtual image bits to the destination file. + */ + uint64_t offImage = 0; + while (offImage < cbImage) + { + /* Figure out how much to copy this time. */ + size_t cbToCopy = cbBuf; + if (offImage + cbToCopy < cbImage) + { /* likely */ } + else + cbToCopy = (size_t)(cbImage - offImage); + + /* Do the copying. */ + int rc = RTVfsFileReadAt(hVfsSrcFile, offImage, pvBuf, cbToCopy, NULL); + if (RT_SUCCESS(rc)) + { + rc = RTVfsFileWriteAt(hVfsDstFile, offImage, pvBuf, cbToCopy, NULL); + if (RT_SUCCESS(rc)) + offImage += cbToCopy; + else + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error %Rrc writing %#zx bytes at offset %#RX64 to '%s'", + rc, cbToCopy, offImage, pOpts->pszOutFile); + } + else + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error %Rrc read %#zx bytes at offset %#RX64", rc, cbToCopy, offImage); + } + return VINF_SUCCESS; +} + + +/** + * Writes the image to file. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsSrcFile The source file from the ISO maker. + */ +static int rtFsIsoMakerCmdWriteImage(PRTFSISOMAKERCMDOPTS pOpts, RTVFSFILE hVfsSrcFile) +{ + /* + * Get the image size and setup the copy buffer. + */ + uint64_t cbImage; + int rc = RTVfsFileGetSize(hVfsSrcFile, &cbImage); + if (RT_SUCCESS(rc)) + { + rtFsIsoMakerPrintf(pOpts, "Image size: %'RU64 (%#RX64) bytes\n", cbImage, cbImage); + + uint32_t cbBuf = pOpts->cbOutputReadBuffer == 0 ? _1M : pOpts->cbOutputReadBuffer; + void *pvBuf = RTMemTmpAlloc(cbBuf); + if (pvBuf) + { + /* + * Open the output file. + */ + RTVFSFILE hVfsDstFile; + uint32_t offError; + RTERRINFOSTATIC ErrInfo; + rc = RTVfsChainOpenFile(pOpts->pszOutFile, + RTFILE_O_READWRITE | RTFILE_O_CREATE_REPLACE | RTFILE_O_DENY_WRITE + | (0664 << RTFILE_O_CREATE_MODE_SHIFT), + &hVfsDstFile, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_SUCCESS(rc)) + { + /* + * Apply the desired writing method. + */ + if (!pOpts->fRandomOutputReadBufferSize) + rc = rtFsIsoMakerCmdWriteImageRandomBufferSize(pOpts, hVfsSrcFile, hVfsDstFile, cbImage, &pvBuf); + else + rc = rtFsIsoMakerCmdWriteImageSimple(pOpts, hVfsSrcFile, hVfsDstFile, cbImage, pvBuf, cbBuf); + RTMemTmpFree(pvBuf); + + if (RT_SUCCESS(rc) && pOpts->cbRandomOrderVerifciationBlock > 0) + rc = rtFsIsoMakerCmdVerifyImageInRandomOrder(pOpts, hVfsSrcFile, hVfsDstFile, cbImage); + + /* + * Flush the output file before releasing it. + */ + if (RT_SUCCESS(rc)) + { + rc = RTVfsFileFlush(hVfsDstFile); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTVfsFileFlush failed on '%s': %Rrc", pOpts->pszOutFile, rc); + } + + RTVfsFileRelease(hVfsDstFile); + } + else + { + RTMemTmpFree(pvBuf); + rc = rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenFile", pOpts->pszOutFile, rc, offError, &ErrInfo.Core); + } + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "RTMemTmpAlloc(%zu) failed", cbBuf); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTVfsFileGetSize failed: %Rrc", rc); + return rc; +} + + +/** + * Formats @a fNameSpecifiers into a '+' separated list of names. + * + * @returns pszDst + * @param fNameSpecifiers The name specifiers. + * @param pszDst The destination bufer. + * @param cbDst The size of the destination buffer. + */ +static char *rtFsIsoMakerCmdNameSpecifiersToString(uint32_t fNameSpecifiers, char *pszDst, size_t cbDst) +{ + static struct { const char *pszName; uint32_t cchName; uint32_t fSpec; } const s_aSpecs[] = + { + { RT_STR_TUPLE("primary"), RTFSISOMAKERCMDNAME_PRIMARY_ISO }, + { RT_STR_TUPLE("primary-rock"), RTFSISOMAKERCMDNAME_PRIMARY_ISO_ROCK_RIDGE }, + { RT_STR_TUPLE("primary-trans-tbl"), RTFSISOMAKERCMDNAME_PRIMARY_ISO_TRANS_TBL }, + { RT_STR_TUPLE("joliet"), RTFSISOMAKERCMDNAME_JOLIET }, + { RT_STR_TUPLE("joliet-rock"), RTFSISOMAKERCMDNAME_JOLIET_ROCK_RIDGE }, + { RT_STR_TUPLE("joliet-trans-tbl"), RTFSISOMAKERCMDNAME_JOLIET_TRANS_TBL }, + { RT_STR_TUPLE("udf"), RTFSISOMAKERCMDNAME_UDF }, + { RT_STR_TUPLE("udf-trans-tbl"), RTFSISOMAKERCMDNAME_UDF_TRANS_TBL }, + { RT_STR_TUPLE("hfs"), RTFSISOMAKERCMDNAME_HFS }, + { RT_STR_TUPLE("hfs-trans-tbl"), RTFSISOMAKERCMDNAME_HFS_TRANS_TBL }, + }; + + Assert(cbDst > 0); + char *pszRet = pszDst; + for (uint32_t i = 0; i < RT_ELEMENTS(s_aSpecs); i++) + if (s_aSpecs[i].fSpec & fNameSpecifiers) + { + if (pszDst != pszRet && cbDst > 1) + { + *pszDst++ = '+'; + cbDst--; + } + if (cbDst > s_aSpecs[i].cchName) + { + memcpy(pszDst, s_aSpecs[i].pszName, s_aSpecs[i].cchName); + cbDst -= s_aSpecs[i].cchName; + pszDst += s_aSpecs[i].cchName; + } + else if (cbDst > 1) + { + memcpy(pszDst, s_aSpecs[i].pszName, cbDst - 1); + pszDst += cbDst - 1; + cbDst = 1; + } + + fNameSpecifiers &= ~s_aSpecs[i].fSpec; + if (!fNameSpecifiers) + break; + } + *pszDst = '\0'; + return pszRet; +} + + +/** + * Parses the --name-setup option. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszSpec The name setup specification. + */ +static int rtFsIsoMakerCmdOptNameSetup(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSpec) +{ + /* + * Comma separated list of one or more specifiers. + */ + uint32_t fNamespaces = 0; + uint32_t fPrevMajor = 0; + uint32_t iNameSpecifier = 0; + uint32_t offSpec = 0; + do + { + /* + * Parse up to the next colon or end of string. + */ + uint32_t fNameSpecifier = 0; + char ch; + while ( (ch = pszSpec[offSpec]) != '\0' + && ch != ',') + { + if (RT_C_IS_SPACE(ch) || ch == '+' || ch == '|') /* space, '+' and '|' are allowed as name separators. */ + offSpec++; + else + { + /* Find the end of the name. */ + uint32_t offEndSpec = offSpec + 1; + while ( (ch = pszSpec[offEndSpec]) != '\0' + && ch != ',' + && ch != '+' + && ch != '|' + && !RT_C_IS_SPACE(ch)) + offEndSpec++; + +#define IS_EQUAL(a_sz) (cchName == sizeof(a_sz) - 1U && strncmp(pchName, a_sz, sizeof(a_sz) - 1U) == 0) + const char * const pchName = &pszSpec[offSpec]; + uint32_t const cchName = offEndSpec - offSpec; + /* major namespaces */ + if ( IS_EQUAL("iso") + || IS_EQUAL("primary") + || IS_EQUAL("iso9660") + || IS_EQUAL("iso-9660") + || IS_EQUAL("primary-iso") + || IS_EQUAL("iso-primary") ) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_PRIMARY_ISO; + fNamespaces |= fPrevMajor = RTFSISOMAKER_NAMESPACE_ISO_9660; + } + else if (IS_EQUAL("joliet")) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_JOLIET; + fNamespaces |= fPrevMajor = RTFSISOMAKER_NAMESPACE_JOLIET; + } + else if (IS_EQUAL("udf")) + { +#if 0 + fNameSpecifier |= RTFSISOMAKERCMDNAME_UDF; + fNamespaces |= fPrevMajor = RTFSISOMAKER_NAMESPACE_UDF; +#else + return rtFsIsoMakerCmdSyntaxError(pOpts, "UDF support is currently not implemented"); +#endif + } + else if (IS_EQUAL("hfs") || IS_EQUAL("hfsplus")) + { +#if 0 + fNameSpecifier |= RTFSISOMAKERCMDNAME_HFS; + fNamespaces |= fPrevMajor = RTFSISOMAKER_NAMESPACE_HFS; +#else + return rtFsIsoMakerCmdSyntaxError(pOpts, "Hybrid HFS+ support is currently not implemented"); +#endif + } + /* rock ridge */ + else if ( IS_EQUAL("rr") + || IS_EQUAL("rock") + || IS_EQUAL("rock-ridge")) + { + if (fPrevMajor == RTFSISOMAKERCMDNAME_PRIMARY_ISO) + fNameSpecifier |= RTFSISOMAKERCMDNAME_PRIMARY_ISO_ROCK_RIDGE; + else if (fPrevMajor == RTFSISOMAKERCMDNAME_JOLIET) + fNameSpecifier |= RTFSISOMAKERCMDNAME_JOLIET_ROCK_RIDGE; + else + return rtFsIsoMakerCmdSyntaxError(pOpts, "unqualified rock-ridge name specifier"); + } + else if ( IS_EQUAL("iso-rr") || IS_EQUAL("iso-rock") || IS_EQUAL("iso-rock-ridge") + || IS_EQUAL("primary-rr") || IS_EQUAL("primary-rock") || IS_EQUAL("primary-rock-ridge") + || IS_EQUAL("iso9660-rr") || IS_EQUAL("iso9660-rock") || IS_EQUAL("iso9660-rock-ridge") + || IS_EQUAL("iso-9660-rr") || IS_EQUAL("iso-9660-rock") || IS_EQUAL("iso-9660-rock-ridge") + || IS_EQUAL("primaryiso-rr") || IS_EQUAL("primaryiso-rock") || IS_EQUAL("primaryiso-rock-ridge") + || IS_EQUAL("primary-iso-rr") || IS_EQUAL("primary-iso-rock") || IS_EQUAL("primary-iso-rock-ridge") ) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_PRIMARY_ISO_ROCK_RIDGE; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_PRIMARY_ISO)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "iso-9660-rock-ridge must come after the iso-9660 name specifier"); + } + else if (IS_EQUAL("joliet-rr") || IS_EQUAL("joliet-rock") || IS_EQUAL("joliet-rock-ridge")) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_JOLIET_ROCK_RIDGE; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_JOLIET)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "joliet-rock-ridge must come after the joliet name specifier"); + } + /* trans.tbl */ + else if (IS_EQUAL("trans") || IS_EQUAL("trans-tbl")) + { + if (fPrevMajor == RTFSISOMAKERCMDNAME_PRIMARY_ISO) + fNameSpecifier |= RTFSISOMAKERCMDNAME_PRIMARY_ISO_TRANS_TBL; + else if (fPrevMajor == RTFSISOMAKERCMDNAME_JOLIET) + fNameSpecifier |= RTFSISOMAKERCMDNAME_JOLIET_TRANS_TBL; + else + return rtFsIsoMakerCmdSyntaxError(pOpts, "unqualified trans-tbl name specifier"); + } + else if ( IS_EQUAL("iso-trans") || IS_EQUAL("iso-trans-tbl") + || IS_EQUAL("primary-trans") || IS_EQUAL("primary-trans-tbl") + || IS_EQUAL("iso9660-trans") || IS_EQUAL("iso9660-trans-tbl") + || IS_EQUAL("iso-9660-trans") || IS_EQUAL("iso-9660-trans-tbl") + || IS_EQUAL("primaryiso-trans") || IS_EQUAL("primaryiso-trans-tbl") + || IS_EQUAL("primary-iso-trans") || IS_EQUAL("primary-iso-trans-tbl") ) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_PRIMARY_ISO_TRANS_TBL; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_PRIMARY_ISO)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "iso-9660-trans-tbl must come after the iso-9660 name specifier"); + } + else if (IS_EQUAL("joliet-trans") || IS_EQUAL("joliet-trans-tbl")) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_JOLIET_TRANS_TBL; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_JOLIET)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "joliet-trans-tbl must come after the joliet name specifier"); + } + else if (IS_EQUAL("udf-trans") || IS_EQUAL("udf-trans-tbl")) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_UDF_TRANS_TBL; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_UDF)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "udf-trans-tbl must come after the udf name specifier"); + } + else if (IS_EQUAL("hfs-trans") || IS_EQUAL("hfs-trans-tbl")) + { + fNameSpecifier |= RTFSISOMAKERCMDNAME_HFS_TRANS_TBL; + if (!(fNamespaces & RTFSISOMAKERCMDNAME_HFS)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "hfs-trans-tbl must come after the hfs name specifier"); + } + else + return rtFsIsoMakerCmdSyntaxError(pOpts, "unknown name specifier '%.*s'", cchName, pchName); +#undef IS_EQUAL + offSpec = offEndSpec; + } + } /* while same specifier */ + + /* + * Check that it wasn't empty. + */ + if (fNameSpecifier == 0) + return rtFsIsoMakerCmdSyntaxError(pOpts, "name specifier #%u (0-based) is empty ", iNameSpecifier); + + /* + * Complain if a major namespace name is duplicated. The rock-ridge and + * trans.tbl names are simple to replace, the others affect the two former + * names and are therefore not allowed twice in the list. + */ + uint32_t i = iNameSpecifier; + while (i-- > 0) + { + uint32_t fRepeated = (fNameSpecifier & RTFSISOMAKERCMDNAME_MAJOR_MASK) + & (pOpts->afNameSpecifiers[i] & RTFSISOMAKERCMDNAME_MAJOR_MASK); + if (fRepeated) + { + char szTmp[128]; + return rtFsIsoMakerCmdSyntaxError(pOpts, "repeating name specifier%s: %s", RT_IS_POWER_OF_TWO(fRepeated) ? "" : "s", + rtFsIsoMakerCmdNameSpecifiersToString(fRepeated, szTmp, sizeof(szTmp))); + } + } + + /* + * Add it. + */ + if (iNameSpecifier >= RT_ELEMENTS(pOpts->afNameSpecifiers)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "too many name specifiers (max %d)", RT_ELEMENTS(pOpts->afNameSpecifiers)); + pOpts->afNameSpecifiers[iNameSpecifier] = fNameSpecifier; + iNameSpecifier++; + + /* + * Next, if any. + */ + if (pszSpec[offSpec] == ',') + offSpec++; + } while (pszSpec[offSpec] != '\0'); + + pOpts->cNameSpecifiers = iNameSpecifier; + pOpts->fDstNamespaces = fNamespaces; + + return VINF_SUCCESS; +} + + +/** + * Checks if we should use the source stack or the regular file system for + * opening a source. + * + * @returns true / false. + * @param pOpts The ISO maker command instance. + * @param pszSrc The source path under consideration. + */ +static bool rtFsIsoMakerCmdUseSrcStack(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSrc) +{ + /* Not if there isn't any stack. */ + if (pOpts->iSrcStack < 0) + return false; + + /* Not if we've got a :iprtvfs: incantation. */ + if (RTVfsChainIsSpec(pszSrc)) + return false; + + /* If the top entry is a CWD rather than a VFS, we only do it for root-less paths. */ + if (pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption == NULL) + { + if (RTPathStartsWithRoot(pszSrc)) + return false; + } + return true; +} + + +/** + * Processes a non-option argument. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszSpec The specification of what to add. + * @param fWithSrc Whether the specification includes a source path + * or not. + * @param pParsed Where to return the parsed name specification. + */ +static int rtFsIsoMakerCmdParseNameSpec(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSpec, bool fWithSrc, + PRTFSISOMKCMDPARSEDNAMES pParsed) +{ + const char * const pszSpecIn = pszSpec; + uint32_t const cMaxNames = pOpts->cNameSpecifiers + fWithSrc; + + /* + * Split it up by '='. + */ + pParsed->cNames = 0; + pParsed->cNamesWithSrc = 0; + pParsed->enmSrcType = fWithSrc ? RTFSISOMKCMDPARSEDNAMES::kSrcType_Normal : RTFSISOMKCMDPARSEDNAMES::kSrcType_None; + for (;;) + { + const char *pszEqual = strchr(pszSpec, '='); + size_t cchName = pszEqual ? pszEqual - pszSpec : strlen(pszSpec); + bool fNeedSlash = (pszEqual || !fWithSrc) && !RTPATH_IS_SLASH(*pszSpec) && cchName > 0; + if (cchName + fNeedSlash >= sizeof(pParsed->aNames[pParsed->cNamesWithSrc].szPath)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "name #%u (0-based) is too long: %s", pParsed->cNamesWithSrc, pszSpecIn); + if (pParsed->cNamesWithSrc >= cMaxNames) + return rtFsIsoMakerCmdSyntaxError(pOpts, "too many names specified (max %u%s): %s", + pOpts->cNameSpecifiers, fWithSrc ? " + source" : "", pszSpecIn); + if (!fNeedSlash) + memcpy(pParsed->aNames[pParsed->cNamesWithSrc].szPath, pszSpec, cchName); + else + { + memcpy(&pParsed->aNames[pParsed->cNamesWithSrc].szPath[1], pszSpec, cchName); + pParsed->aNames[pParsed->cNamesWithSrc].szPath[0] = RTPATH_SLASH; + cchName++; + } + pParsed->aNames[pParsed->cNamesWithSrc].szPath[cchName] = '\0'; + pParsed->aNames[pParsed->cNamesWithSrc].cchPath = (uint32_t)cchName; + pParsed->cNamesWithSrc++; + + if (!pszEqual) + { + if (fWithSrc) + { + if (!cchName) + return rtFsIsoMakerCmdSyntaxError(pOpts, "empty source file name: %s", pszSpecIn); + if (cchName == 8 && strcmp(pszSpec, ":remove:") == 0) + pParsed->enmSrcType = RTFSISOMKCMDPARSEDNAMES::kSrcType_Remove; + else if (cchName == 13 && strcmp(pszSpec, ":must-remove:") == 0) + pParsed->enmSrcType = RTFSISOMKCMDPARSEDNAMES::kSrcType_MustRemove; + else if (rtFsIsoMakerCmdUseSrcStack(pOpts, pszSpec)) + pParsed->enmSrcType = RTFSISOMKCMDPARSEDNAMES::kSrcType_NormalSrcStack; + } + break; + } + pszSpec = pszEqual + 1; + } + + /* + * If there are too few names specified, move the source and repeat the + * last non-source name. If only source, convert source into a name spec. + */ + if (pParsed->cNamesWithSrc < cMaxNames) + { + uint32_t iSrc; + if (!fWithSrc) + iSrc = pParsed->cNamesWithSrc - 1; + else + { + pParsed->aNames[pOpts->cNameSpecifiers] = pParsed->aNames[pParsed->cNamesWithSrc - 1]; + iSrc = pParsed->cNamesWithSrc >= 2 ? pParsed->cNamesWithSrc - 2 : 0; + } + + /* If the source is a input file name specifier, reduce it to something that starts with a slash. */ + if (pParsed->cNamesWithSrc == 1 && fWithSrc) + { + const char *pszSrc = pParsed->aNames[iSrc].szPath; + char *pszFinalPath = NULL; + if (RTVfsChainIsSpec(pParsed->aNames[iSrc].szPath)) + { + uint32_t offError; + int rc = RTVfsChainQueryFinalPath(pParsed->aNames[iSrc].szPath, &pszFinalPath, &offError); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainQueryFinalPath", + pParsed->aNames[iSrc].szPath, rc, offError, NULL); + pszSrc = pszFinalPath; + } + + /* Find the start of the last component, ignoring trailing slashes. */ + size_t cchSrc = strlen(pszSrc); + size_t offLast = cchSrc; + while (offLast > 0 && RTPATH_IS_SLASH(pszSrc[offLast - 1])) + offLast--; + while (offLast > 0 && !RTPATH_IS_SLASH(pszSrc[offLast - 1])) + offLast--; + + /* Move it up front with a leading slash. */ + if (offLast > 0 || !RTPATH_IS_SLASH(*pszSrc)) + { + pParsed->aNames[iSrc].cchPath = 1 + (uint32_t)(cchSrc - offLast); + if (pParsed->aNames[iSrc].cchPath >= sizeof(pParsed->aNames[iSrc].szPath)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "name too long: %s", pszSpecIn); + + memmove(&pParsed->aNames[iSrc].szPath[1], &pszSrc[offLast], pParsed->aNames[iSrc].cchPath); + } + else + pParsed->aNames[iSrc].cchPath = 1; + pParsed->aNames[iSrc].szPath[0] = RTPATH_SLASH; + + if (pszFinalPath) + RTStrFree(pszFinalPath); + } + + for (uint32_t iDst = iSrc + 1; iDst < pOpts->cNameSpecifiers; iDst++) + pParsed->aNames[iDst] = pParsed->aNames[iSrc]; + + pParsed->cNamesWithSrc = cMaxNames; + } + pParsed->cNames = pOpts->cNameSpecifiers; + + /* + * Copy the specifier flags and check that the paths all starts with slashes. + */ + for (uint32_t i = 0; i < pOpts->cNameSpecifiers; i++) + { + pParsed->aNames[i].fNameSpecifiers = pOpts->afNameSpecifiers[i]; + Assert( pParsed->aNames[i].cchPath == 0 + || RTPATH_IS_SLASH(pParsed->aNames[i].szPath[0])); + } + + return VINF_SUCCESS; +} + + +/** + * Enteres an object into the namespace by full paths. + * + * This is used by rtFsIsoMakerCmdOptEltoritoSetBootCatalogPath and + * rtFsIsoMakerCmdAddFile. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param idxObj The configuration index of the object to be named. + * @param pParsed The parsed names. + * @param pszSrcOrName Source file or name. + */ +static int rtFsIsoMakerCmdSetObjPaths(PRTFSISOMAKERCMDOPTS pOpts, uint32_t idxObj, PCRTFSISOMKCMDPARSEDNAMES pParsed, + const char *pszSrcOrName) +{ + int rc = VINF_SUCCESS; + for (uint32_t i = 0; i < pParsed->cNames; i++) + if (pParsed->aNames[i].cchPath > 0) + { + if (pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK) + { + rc = RTFsIsoMakerObjSetPath(pOpts->hIsoMaker, idxObj, + pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK, + pParsed->aNames[i].szPath); + if (RT_FAILURE(rc)) + { + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error setting name '%s' on '%s': %Rrc", + pParsed->aNames[i].szPath, pszSrcOrName, rc); + break; + } + } + if (pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MINOR_MASK) + { + /** @todo add APIs for this. */ + } + } + return rc; +} + + +/** + * Adds a file. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszSrc The path to the source file. + * @param pParsed The parsed names. + * @param pidxObj Where to return the configuration index for the + * added file. Optional. + */ +static int rtFsIsoMakerCmdAddFile(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSrc, PCRTFSISOMKCMDPARSEDNAMES pParsed, + uint32_t *pidxObj) +{ + int rc; + uint32_t idxObj = UINT32_MAX; + if (pParsed->enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_NormalSrcStack) + { + RTVFSFILE hVfsFileSrc; + rc = RTVfsDirOpenFile(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir, pszSrc, + RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFileSrc); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error opening '%s' (%s '%s'): %Rrc", + pszSrc, pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption ? "inside" : "relative to", + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfs, rc); + + rc = RTFsIsoMakerAddUnnamedFileWithVfsFile(pOpts->hIsoMaker, hVfsFileSrc, &idxObj); + RTVfsFileRelease(hVfsFileSrc); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error adding '%s' (VFS): %Rrc", pszSrc, rc); + } + else + { + rc = RTFsIsoMakerAddUnnamedFileWithSrcPath(pOpts->hIsoMaker, pszSrc, &idxObj); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error adding '%s': %Rrc", pszSrc, rc); + } + + + pOpts->cItemsAdded++; + if (pidxObj) + *pidxObj = idxObj; + + return rtFsIsoMakerCmdSetObjPaths(pOpts, idxObj, pParsed, pszSrc); +} + + +/** + * Applies filtering rules. + * + * @returns true if filtered out, false if included. + * @param pOpts The ISO maker command instance. + * @param pszSrc The source source. + * @param pszName The name part (maybe different buffer from pszSrc). + * @param fIsDir Set if directory, clear if not. + */ +static bool rtFsIsoMakerCmdIsFilteredOut(PRTFSISOMAKERCMDOPTS pOpts, const char *pszDir, const char *pszName, bool fIsDir) +{ + /* Ignore trans.tbl files. */ + if ( !fIsDir + && RTStrICmp(pszName, pOpts->pszTransTbl) == 0) + return true; + + RT_NOREF(pOpts, pszDir, pszName, fIsDir); + return false; +} + + +/** + * Worker for rtFsIsoMakerCmdAddVfsDir that does the recursion. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsDir The directory to process. + * @param idxDirObj The configuration index of the directory. + * @param pszSrc Pointer to the source path buffer. RTPATH_MAX + * in size. Okay to modify beyond @a cchSrc. + * @param cchSrc Length of the path corresponding to @a hVfsDir. + * @param fNamespaces Which ISO maker namespaces to add the names to. + * @param cDepth Number of recursions. Used to deal with loopy + * directories. + */ +static int rtFsIsoMakerCmdAddVfsDirRecursive(PRTFSISOMAKERCMDOPTS pOpts, RTVFSDIR hVfsDir, uint32_t idxDirObj, + char *pszSrc, size_t cchSrc, uint32_t fNamespaces, uint8_t cDepth) +{ + /* + * Check that we're not in too deep. + */ + if (cDepth >= RTFSISOMAKERCMD_MAX_DIR_RECURSIONS) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_ISOMK_IMPORT_TOO_DEEP_DIR_TREE, + "Recursive (VFS) dir add too deep (depth=%u): %.*s", cDepth, cchSrc, pszSrc); + /* + * Enumerate the directory. + */ + int rc; + size_t cbDirEntryAlloced = sizeof(RTDIRENTRYEX); + PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced); + if (pDirEntry) + { + for (;;) + { + /* + * Read the next entry. + */ + size_t cbDirEntry = cbDirEntryAlloced; + rc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX); + if (RT_FAILURE(rc)) + { + if (rc == VERR_NO_MORE_FILES) + rc = VINF_SUCCESS; + else if (rc == VERR_BUFFER_OVERFLOW) + { + RTMemTmpFree(pDirEntry); + cbDirEntryAlloced = RT_ALIGN_Z(RT_MIN(cbDirEntry, cbDirEntryAlloced) + 64, 64); + pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced); + if (pDirEntry) + continue; + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "Out of memory (direntry buffer)"); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTVfsDirReadEx failed on %.*s: %Rrc", cchSrc, pszSrc, rc); + break; + } + + /* Ignore '.' and '..' entries. */ + if (RTDirEntryExIsStdDotLink(pDirEntry)) + continue; + + /* + * Process the entry. + */ + + /* Update the name. */ + if (cchSrc + 1 + pDirEntry->cbName < RTPATH_MAX) + { + pszSrc[cchSrc] = '/'; /* VFS only groks unix slashes */ + memcpy(&pszSrc[cchSrc + 1], pDirEntry->szName, pDirEntry->cbName); + pszSrc[cchSrc + 1 + pDirEntry->cbName] = '\0'; + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_FILENAME_TOO_LONG, "Filename is too long (depth %u): '%.*s/%s'", + cDepth, cchSrc, pszSrc, pDirEntry->szName); + + /* Okay? Check name filtering. */ + if ( RT_SUCCESS(rc) + && !rtFsIsoMakerCmdIsFilteredOut(pOpts, pszSrc, pDirEntry->szName, RTFS_IS_DIRECTORY(pDirEntry->Info.Attr.fMode))) + { + /* Do type specific adding. */ + uint32_t idxObj = UINT32_MAX; + if (RTFS_IS_FILE(pDirEntry->Info.Attr.fMode)) + { + /* + * Files are added with VFS file sources. + * The ASSUMPTION is that we're working with a virtual file system + * here and won't be wasting native file descriptors. + */ + RTVFSFILE hVfsFileSrc; + rc = RTVfsDirOpenFile(hVfsDir, pDirEntry->szName, + RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFileSrc); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerAddUnnamedFileWithVfsFile(pOpts->hIsoMaker, hVfsFileSrc, &idxObj); + RTVfsFileRelease(hVfsFileSrc); + if (RT_SUCCESS(rc)) + { + pOpts->cItemsAdded++; + rc = RTFsIsoMakerObjSetNameAndParent(pOpts->hIsoMaker, idxObj, idxDirObj, fNamespaces, + pDirEntry->szName); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error setting parent & name on file '%s' to '%s': %Rrc", + pszSrc, pDirEntry->szName, rc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error adding file '%s' (VFS recursive): %Rrc", pszSrc, rc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error opening file '%s' (VFS recursive): %Rrc", pszSrc, rc); + } + else if (RTFS_IS_DIRECTORY(pDirEntry->Info.Attr.fMode)) + { + /* + * Open and add the sub-directory. + */ + RTVFSDIR hVfsSubDirSrc; + rc = RTVfsDirOpenDir(hVfsDir, pDirEntry->szName, 0 /*fFlags*/, &hVfsSubDirSrc); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerAddUnnamedDir(pOpts->hIsoMaker, &pDirEntry->Info, &idxObj); + if (RT_SUCCESS(rc)) + { + pOpts->cItemsAdded++; + rc = RTFsIsoMakerObjSetNameAndParent(pOpts->hIsoMaker, idxObj, idxDirObj, fNamespaces, + pDirEntry->szName); + if (RT_SUCCESS(rc)) + /* Recurse into the sub-directory. */ + rc = rtFsIsoMakerCmdAddVfsDirRecursive(pOpts, hVfsSubDirSrc, idxObj, pszSrc, + cchSrc + 1 + pDirEntry->cbName, fNamespaces, cDepth + 1); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, + "Error setting parent & name on directory '%s' to '%s': %Rrc", + pszSrc, pDirEntry->szName, rc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error adding directory '%s' (VFS recursive): %Rrc", pszSrc, rc); + RTVfsDirRelease(hVfsSubDirSrc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error opening directory '%s' (VFS recursive): %Rrc", pszSrc, rc); + } + else if (RTFS_IS_SYMLINK(pDirEntry->Info.Attr.fMode)) + { + /* + * TODO: ISO FS symlink support. + */ + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_IMPLEMENTED, + "Adding symlink '%s' failed: not yet implemented", pszSrc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_IMPLEMENTED, + "Adding special file '%s' failed: not implemented", pszSrc); + } + if (RT_FAILURE(rc)) + break; + } + + RTMemTmpFree(pDirEntry); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "Out of memory! (direntry buffer)"); + return rc; +} + + +/** + * Common directory adding worker. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param hVfsSrcDir The directory being added. + * @param pszSrc The source directory name. + * @param pParsed The parsed names. + * @param pidxObj Where to return the configuration index for the + * added file. Optional. + */ +static int rtFsIsoMakerCmdAddVfsDirCommon(PRTFSISOMAKERCMDOPTS pOpts, RTVFSDIR hVfsDirSrc, char *pszSrc, + PCRTFSISOMKCMDPARSEDNAMES pParsed, PCRTFSOBJINFO pObjInfo) +{ + /* + * Add the directory if it doesn't exist. + */ + uint32_t idxObj = UINT32_MAX; + for (uint32_t i = 0; i < pParsed->cNames; i++) + if (pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK) + { + idxObj = RTFsIsoMakerGetObjIdxForPath(pOpts->hIsoMaker, + pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK, + pParsed->aNames[i].szPath); + if (idxObj != UINT32_MAX) + { + /** @todo make sure the directory is present in the other namespace. */ + break; + } + } + int rc = VINF_SUCCESS; + if (idxObj == UINT32_MAX) + { + rc = RTFsIsoMakerAddUnnamedDir(pOpts->hIsoMaker, pObjInfo, &idxObj); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerCmdSetObjPaths(pOpts, idxObj, pParsed, pParsed->aNames[pParsed->cNames - 1].szPath); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerAddUnnamedDir failed: %Rrc", rc); + } + if (RT_SUCCESS(rc)) + { + /* + * Add the directory content. + */ + uint32_t fNamespaces = 0; + for (uint32_t i = 0; i < pParsed->cNames; i++) + fNamespaces |= pParsed->aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK; + rc = rtFsIsoMakerCmdAddVfsDirRecursive(pOpts, hVfsDirSrc, idxObj, pszSrc, + pParsed->aNames[pParsed->cNamesWithSrc - 1].cchPath, fNamespaces, 0 /*cDepth*/); + } + + return rc; +} + + +/** + * Adds a directory, from the source VFS. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pParsed The parsed names. + * @param pidxObj Where to return the configuration index for the + * added file. Optional. + */ +static int rtFsIsoMakerCmdAddVfsDir(PRTFSISOMAKERCMDOPTS pOpts, PCRTFSISOMKCMDPARSEDNAMES pParsed, PCRTFSOBJINFO pObjInfo) +{ + Assert(pParsed->cNames < pParsed->cNamesWithSrc); + char *pszSrc = pParsed->aNames[pParsed->cNamesWithSrc - 1].szPath; + RTPathChangeToUnixSlashes(pszSrc, true /*fForce*/); /* VFS currently only understand unix slashes. */ + RTVFSDIR hVfsDirSrc; + int rc = RTVfsDirOpenDir(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir, pszSrc, 0 /*fFlags*/, &hVfsDirSrc); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoMakerCmdAddVfsDirCommon(pOpts, hVfsDirSrc, pszSrc, pParsed, pObjInfo); + RTVfsDirRelease(hVfsDirSrc); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error opening directory '%s' (%s '%s'): %Rrc", pszSrc, + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption ? "inside" : "relative to", + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfs, rc); + return rc; +} + + +/** + * Adds a directory, from a VFS chain or real file system. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszSrc The path to the source directory. + * @param pParsed The parsed names. + */ +static int rtFsIsoMakerCmdAddDir(PRTFSISOMAKERCMDOPTS pOpts, PCRTFSISOMKCMDPARSEDNAMES pParsed, PCRTFSOBJINFO pObjInfo) +{ + Assert(pParsed->cNames < pParsed->cNamesWithSrc); + char *pszSrc = pParsed->aNames[pParsed->cNamesWithSrc - 1].szPath; + RTERRINFOSTATIC ErrInfo; + uint32_t offError; + RTVFSDIR hVfsDirSrc; + int rc = RTVfsChainOpenDir(pszSrc, 0 /*fOpen*/, &hVfsDirSrc, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoMakerCmdAddVfsDirCommon(pOpts, hVfsDirSrc, pszSrc, pParsed, pObjInfo); + RTVfsDirRelease(hVfsDirSrc); + } + else + rc = rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenDir", pszSrc, rc, offError, &ErrInfo.Core); + return rc; +} + + +/** + * Adds a file after first making sure it's a file. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszSrc The path to the source file. + * @param pParsed The parsed names. + * @param pidxObj Where to return the configuration index for the + * added file. Optional. + */ +static int rtFsIsoMakerCmdStatAndAddFile(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSrc, PCRTFSISOMKCMDPARSEDNAMES pParsed, + uint32_t *pidxObj) +{ + int rc; + RTFSOBJINFO ObjInfo; + if (pParsed->enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_NormalSrcStack) + { + rc = RTVfsDirQueryPathInfo(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir, pszSrc, + &ObjInfo, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTVfsQueryPathInfo failed on %s (%s %s): %Rrc", pszSrc, + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption ? "inside" : "relative to", + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfs, rc); + } + else + { + uint32_t offError; + RTERRINFOSTATIC ErrInfo; + rc = RTVfsChainQueryInfo(pszSrc, &ObjInfo, RTFSOBJATTRADD_UNIX, + RTPATH_F_FOLLOW_LINK, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainQueryInfo", pszSrc, rc, offError, &ErrInfo.Core); + } + + if (RTFS_IS_FILE(ObjInfo.Attr.fMode)) + return rtFsIsoMakerCmdAddFile(pOpts, pszSrc, pParsed, pidxObj); + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_A_FILE, "Not a file: %s", pszSrc); +} + + +/** + * Processes a non-option argument. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszSpec The specification of what to add. + */ +static int rtFsIsoMakerCmdAddSomething(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSpec) +{ + /* + * Parse the name spec. + */ + RTFSISOMKCMDPARSEDNAMES Parsed; + int rc = rtFsIsoMakerCmdParseNameSpec(pOpts, pszSpec, true /*fWithSrc*/, &Parsed); + if (RT_FAILURE(rc)) + return rc; + + /* + * Deal with special source filenames used to remove/change stuff. + */ + if ( Parsed.enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_Remove + || Parsed.enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_MustRemove) + { + const char *pszFirstNm = NULL; + uint32_t cRemoved = 0; + for (uint32_t i = 0; i < pOpts->cNameSpecifiers; i++) + if ( Parsed.aNames[i].cchPath > 0 + && (Parsed.aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK)) + { + /* Make sure we remove all objects by this name. */ + pszFirstNm = Parsed.aNames[i].szPath; + for (;;) + { + uint32_t idxObj = RTFsIsoMakerGetObjIdxForPath(pOpts->hIsoMaker, + Parsed.aNames[i].fNameSpecifiers & RTFSISOMAKERCMDNAME_MAJOR_MASK, + Parsed.aNames[i].szPath); + if (idxObj == UINT32_MAX) + break; + rc = RTFsIsoMakerObjRemove(pOpts->hIsoMaker, idxObj); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to remove '%s': %Rrc", pszSpec, rc); + cRemoved++; + } + } + if ( Parsed.enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_MustRemove + && cRemoved == 0) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_FOUND, "Failed to locate '%s' for removal", pszSpec); + } + /* + * Add regular source. + */ + else + { + const char *pszSrc = Parsed.aNames[Parsed.cNamesWithSrc - 1].szPath; + RTFSOBJINFO ObjInfo; + if (Parsed.enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_NormalSrcStack) + { + rc = RTVfsDirQueryPathInfo(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir, pszSrc, + &ObjInfo, RTFSOBJATTRADD_UNIX, RTPATH_F_FOLLOW_LINK); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTVfsQueryPathInfo failed on %s (%s %s): %Rrc", pszSrc, + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption ? "inside" : "relative to", + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfs, rc); + } + else + { + uint32_t offError; + RTERRINFOSTATIC ErrInfo; + rc = RTVfsChainQueryInfo(pszSrc, &ObjInfo, RTFSOBJATTRADD_UNIX, + RTPATH_F_FOLLOW_LINK, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainQueryInfo", pszSrc, rc, offError, &ErrInfo.Core); + } + + /* By type: */ + + if (RTFS_IS_FILE(ObjInfo.Attr.fMode)) + return rtFsIsoMakerCmdAddFile(pOpts, pszSrc, &Parsed, NULL /*pidxObj*/); + + if (RTFS_IS_DIRECTORY(ObjInfo.Attr.fMode)) + { + if (Parsed.enmSrcType == RTFSISOMKCMDPARSEDNAMES::kSrcType_NormalSrcStack) + return rtFsIsoMakerCmdAddVfsDir(pOpts, &Parsed, &ObjInfo); + return rtFsIsoMakerCmdAddDir(pOpts, &Parsed, &ObjInfo); + } + + if (RTFS_IS_SYMLINK(ObjInfo.Attr.fMode)) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_IMPLEMENTED, "Adding symlink '%s' failed: not yet implemented", pszSpec); + + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_IMPLEMENTED, "Adding special file '%s' failed: not implemented", pszSpec); + } + + return VINF_SUCCESS; +} + + +/** + * Opens an ISO and use it for subsequent file system accesses. + * + * This is handy for duplicating a part of an ISO in the new image. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszIsoSpec The ISO path specifier. + * @param pszOption The option we're being called on. + * @param fFlags RTFSISO9660_F_XXX + */ +static int rtFsIsoMakerCmdOptPushIso(PRTFSISOMAKERCMDOPTS pOpts, const char *pszIsoSpec, const char *pszOption, uint32_t fFlags) +{ + int32_t iSrcStack = pOpts->iSrcStack + 1; + if ((uint32_t)iSrcStack >= RT_ELEMENTS(pOpts->aSrcStack)) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_IMPLEMENTED, + "Too many pushes %s %s (previous: %s %s, %s %s, %s %s, ...)", + pszOption, pszIsoSpec, + pOpts->aSrcStack[iSrcStack - 1].pszSrcVfsOption, pOpts->aSrcStack[iSrcStack - 1].pszSrcVfs, + pOpts->aSrcStack[iSrcStack - 2].pszSrcVfsOption, pOpts->aSrcStack[iSrcStack - 2].pszSrcVfs, + pOpts->aSrcStack[iSrcStack - 3].pszSrcVfsOption, pOpts->aSrcStack[iSrcStack - 3].pszSrcVfs); + + /* + * Try open the file. + */ + int rc; + RTVFSFILE hVfsFileIso = NIL_RTVFSFILE; + RTERRINFOSTATIC ErrInfo; + if (rtFsIsoMakerCmdUseSrcStack(pOpts, pszIsoSpec)) + { + rc = RTVfsDirOpenFile(pOpts->aSrcStack[iSrcStack - 1].hSrcDir, pszIsoSpec, + RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFileIso); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error opening '%s' relative to '%s'", + pszIsoSpec, pOpts->aSrcStack[iSrcStack - 1].pszSrcVfs); + } + else + { + uint32_t offError; + rc = RTVfsChainOpenFile(pszIsoSpec, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, + &hVfsFileIso, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenFile", pszIsoSpec, rc, offError, &ErrInfo.Core); + } + if (RT_SUCCESS(rc)) + { + RTVFS hSrcVfs; + rc = RTFsIso9660VolOpen(hVfsFileIso, fFlags, &hSrcVfs, RTErrInfoInitStatic(&ErrInfo)); + RTVfsFileRelease(hVfsFileIso); + if (RT_SUCCESS(rc)) + { + RTVFSDIR hVfsSrcRootDir; + rc = RTVfsOpenRoot(hSrcVfs, &hVfsSrcRootDir); + if (RT_SUCCESS(rc)) + { + pOpts->aSrcStack[iSrcStack].hSrcDir = hVfsSrcRootDir; + pOpts->aSrcStack[iSrcStack].hSrcVfs = hSrcVfs; + pOpts->aSrcStack[iSrcStack].pszSrcVfs = pszIsoSpec; + pOpts->aSrcStack[iSrcStack].pszSrcVfsOption = pszOption; + pOpts->iSrcStack = iSrcStack; + return VINF_SUCCESS; + } + RTVfsRelease(hSrcVfs); + } + else if (RTErrInfoIsSet(&ErrInfo.Core)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to open '%s' as ISO FS: %Rrc - %s", + pszIsoSpec, rc, ErrInfo.Core.pszMsg); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to open '%s' as ISO FS: %Rrc", pszIsoSpec, rc); + } + return rc; +} + + +/** + * Counter part to --push-iso and friends. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + */ +static int rtFsIsoMakerCmdOptPop(PRTFSISOMAKERCMDOPTS pOpts) +{ + int32_t const iSrcStack = pOpts->iSrcStack; + if ( iSrcStack >= 0 + && pOpts->aSrcStack[iSrcStack].pszSrcVfsOption) + { + RTVfsDirRelease(pOpts->aSrcStack[iSrcStack].hSrcDir); + RTVfsRelease(pOpts->aSrcStack[iSrcStack].hSrcVfs); + pOpts->aSrcStack[iSrcStack].hSrcDir = NIL_RTVFSDIR; + pOpts->aSrcStack[iSrcStack].hSrcVfs = NIL_RTVFS; + pOpts->aSrcStack[iSrcStack].pszSrcVfs = NULL; + pOpts->aSrcStack[iSrcStack].pszSrcVfsOption = NULL; + pOpts->iSrcStack = iSrcStack - 1; + return VINF_SUCCESS; + } + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_NOT_FOUND, "--pop without --push-xxx"); +} + + +/** + * Deals with the --import-iso {iso-file-spec} options. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszIsoSpec The ISO path specifier. + */ +static int rtFsIsoMakerCmdOptImportIso(PRTFSISOMAKERCMDOPTS pOpts, const char *pszIsoSpec) +{ + /* + * Open the input file. + */ + RTERRINFOSTATIC ErrInfo; + RTVFSFILE hIsoFile; + int rc; + if (rtFsIsoMakerCmdUseSrcStack(pOpts, pszIsoSpec)) + { + rc = RTVfsDirOpenFile(pOpts->aSrcStack[pOpts->iSrcStack].hSrcDir, pszIsoSpec, + RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hIsoFile); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to open '%s' %s %s for importing: %Rrc", pszIsoSpec, + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfsOption ? "inside" : "relative to", + pOpts->aSrcStack[pOpts->iSrcStack].pszSrcVfs, rc); + } + else + { + uint32_t offError; + rc = RTVfsChainOpenFile(pszIsoSpec, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, + &hIsoFile, &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenFile", pszIsoSpec, rc, offError, &ErrInfo.Core); + } + + RTFSISOMAKERIMPORTRESULTS Results; + rc = RTFsIsoMakerImport(pOpts->hIsoMaker, hIsoFile, 0 /*fFlags*/, &Results, RTErrInfoInitStatic(&ErrInfo)); + + RTVfsFileRelease(hIsoFile); + + pOpts->cItemsAdded += Results.cAddedFiles; + pOpts->cItemsAdded += Results.cAddedSymlinks; + pOpts->cItemsAdded += Results.cAddedDirs; + pOpts->cItemsAdded += Results.cBootCatEntries != UINT32_MAX ? Results.cBootCatEntries : 0; + pOpts->cItemsAdded += Results.cbSysArea != 0 ? 1 : 0; + + rtFsIsoMakerPrintf(pOpts, "ISO imported statistics for '%s'\n", pszIsoSpec); + rtFsIsoMakerPrintf(pOpts, " cAddedNames: %'14RU32\n", Results.cAddedNames); + rtFsIsoMakerPrintf(pOpts, " cAddedDirs: %'14RU32\n", Results.cAddedDirs); + rtFsIsoMakerPrintf(pOpts, " cbAddedDataBlocks: %'14RU64 bytes\n", Results.cbAddedDataBlocks); + rtFsIsoMakerPrintf(pOpts, " cAddedFiles: %'14RU32\n", Results.cAddedFiles); + rtFsIsoMakerPrintf(pOpts, " cAddedSymlinks: %'14RU32\n", Results.cAddedSymlinks); + if (Results.cBootCatEntries == UINT32_MAX) + rtFsIsoMakerPrintf(pOpts, " cBootCatEntries: none\n"); + else + rtFsIsoMakerPrintf(pOpts, " cBootCatEntries: %'14RU32\n", Results.cBootCatEntries); + rtFsIsoMakerPrintf(pOpts, " cbSysArea: %'14RU32\n", Results.cbSysArea); + rtFsIsoMakerPrintf(pOpts, " cErrors: %'14RU32\n", Results.cErrors); + + if (RT_SUCCESS(rc)) + return rc; + if (RTErrInfoIsSet(&ErrInfo.Core)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerImport failed: %Rrc - %s", rc, ErrInfo.Core.pszMsg); + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerImport failed: %Rrc", rc); +} + + +/** + * Deals with: --iso-level, -l + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param uLevel The new ISO level. + */ +static int rtFsIsoMakerCmdOptSetIsoLevel(PRTFSISOMAKERCMDOPTS pOpts, uint8_t uLevel) +{ + int rc = RTFsIsoMakerSetIso9660Level(pOpts->hIsoMaker, uLevel); + if (RT_SUCCESS(rc)) + return rc; + if (rc == VERR_WRONG_ORDER) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Cannot change ISO level to %d after having added files!", uLevel); + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set ISO level to %d: %Rrc", uLevel, rc); +} + + +/** + * Deals with: --rock-ridge, --limited-rock-ridge, --no-rock-ridge + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param uLevel The new rock ridge level. + */ +static int rtFsIsoMakerCmdOptSetPrimaryRockLevel(PRTFSISOMAKERCMDOPTS pOpts, uint8_t uLevel) +{ + int rc = RTFsIsoMakerSetRockRidgeLevel(pOpts->hIsoMaker, uLevel); + if (RT_SUCCESS(rc)) + return rc; + if (rc == VERR_WRONG_ORDER) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Cannot change rock ridge level to %d after having added files!", uLevel); + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set rock ridge level to %d: %Rrc", uLevel, rc); +} + + +/** + * Deals with: --joliet, --no-joliet, --joliet-ucs-level, --ucs-level + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param uLevel The new rock ridge level. + */ +static int rtFsIsoMakerCmdOptSetJolietUcs2Level(PRTFSISOMAKERCMDOPTS pOpts, uint8_t uLevel) +{ + int rc = RTFsIsoMakerSetJolietUcs2Level(pOpts->hIsoMaker, uLevel); + if (RT_SUCCESS(rc)) + return rc; + if (rc == VERR_WRONG_ORDER) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Cannot change joliet UCS level to %d after having added files!", uLevel); + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set joliet UCS level to %d: %Rrc", uLevel, rc); +} + + +/** + * Deals with: --rational-attribs, --strict-attribs, -R, -r + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param uLevel The new rock ridge level. + */ +static int rtFsIsoMakerCmdOptSetAttribInheritStyle(PRTFSISOMAKERCMDOPTS pOpts, bool fStrict) +{ + int rc = RTFsIsoMakerSetAttribInheritStyle(pOpts->hIsoMaker, fStrict); + if (RT_SUCCESS(rc)) + return rc; + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to change attributes handling style to %s: %Rrc", + fStrict ? "strict" : "rational", rc); +} + + +/** + * Deals with: -G|--generic-boot {file} + * + * This concers content the first 16 sectors of the image. We start loading the + * file at byte 0 in the image and stops at 32KB. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszGenericBootImage The generic boot image source. + */ +static int rtFsIsoMakerCmdOptGenericBoot(PRTFSISOMAKERCMDOPTS pOpts, const char *pszGenericBootImage) +{ + RTERRINFOSTATIC ErrInfo; + uint32_t offError; + RTVFSFILE hVfsFile; + int rc = RTVfsChainOpenFile(pszGenericBootImage, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFile, + &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenFile", pszGenericBootImage, rc, offError, &ErrInfo.Core); + + uint8_t abBuf[_32K]; + size_t cbRead; + rc = RTVfsFileReadAt(hVfsFile, 0, abBuf, sizeof(abBuf), &cbRead); + RTVfsFileRelease(hVfsFile); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Error reading 32KB from generic boot image '%s': %Rrc", pszGenericBootImage, rc); + + rc = RTFsIsoMakerSetSysAreaContent(pOpts->hIsoMaker, abBuf, cbRead, 0); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerSetSysAreaContent failed with a %zu bytes input: %Rrc", cbRead, rc); + + return VINF_SUCCESS; +} + + +/** + * Helper that makes sure we've got a validation boot entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + */ +static void rtFsIsoMakerCmdOptEltoritoEnsureValidationEntry(PRTFSISOMAKERCMDOPTS pOpts) +{ + if (pOpts->cBootCatEntries == 0) + { + pOpts->aBootCatEntries[0].enmType = RTFSISOMKCMDELTORITOENTRY::kEntryType_Validation; + pOpts->aBootCatEntries[0].u.Validation.idPlatform = ISO9660_ELTORITO_PLATFORM_ID_X86; + pOpts->aBootCatEntries[0].u.Validation.pszString = NULL; + pOpts->cBootCatEntries = 1; + } +} + + +/** + * Helper that makes sure we've got a current boot entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param fForceNew Whether to force a new entry. + * @param pidxBootCat Where to return the boot catalog index. + */ +static int rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(PRTFSISOMAKERCMDOPTS pOpts, bool fForceNew, uint32_t *pidxBootCat) +{ + rtFsIsoMakerCmdOptEltoritoEnsureValidationEntry(pOpts); + + uint32_t i = pOpts->cBootCatEntries; + if (i == 2 && fForceNew) + { + pOpts->aBootCatEntries[i].enmType = RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader; + pOpts->aBootCatEntries[i].u.SectionHeader.idPlatform = pOpts->aBootCatEntries[0].u.Validation.idPlatform; + pOpts->aBootCatEntries[i].u.SectionHeader.pszString = NULL; + pOpts->cBootCatEntries = ++i; + } + + if ( i == 1 + || fForceNew + || pOpts->aBootCatEntries[i - 1].enmType == RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader) + { + if (i >= RT_ELEMENTS(pOpts->aBootCatEntries)) + { + *pidxBootCat = UINT32_MAX; + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_BUFFER_OVERFLOW, "Too many boot catalog entries"); + } + + pOpts->aBootCatEntries[i].enmType = i == 1 ? RTFSISOMKCMDELTORITOENTRY::kEntryType_Default + : RTFSISOMKCMDELTORITOENTRY::kEntryType_Section; + pOpts->aBootCatEntries[i].u.Section.pszImageNameInIso = NULL; + pOpts->aBootCatEntries[i].u.Section.idxImageObj = UINT32_MAX; + pOpts->aBootCatEntries[i].u.Section.fInsertBootInfoTable = false; + pOpts->aBootCatEntries[i].u.Section.fBootable = true; + pOpts->aBootCatEntries[i].u.Section.bBootMediaType = ISO9660_ELTORITO_BOOT_MEDIA_TYPE_MASK; + pOpts->aBootCatEntries[i].u.Section.bSystemType = 1 /*FAT12*/; + pOpts->aBootCatEntries[i].u.Section.uLoadSeg = 0x7c0; + pOpts->aBootCatEntries[i].u.Section.cSectorsToLoad = 4; + pOpts->cBootCatEntries = ++i; + } + + *pidxBootCat = i - 1; + return VINF_SUCCESS; +} + + +/** + * Deals with: --boot-catalog <path-spec> + * + * This enters the boot catalog into the namespaces of the image. The path-spec + * is similar to what rtFsIsoMakerCmdAddSomething processes, only there isn't a + * source file part. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszGenericBootImage The generic boot image source. + */ +static int rtFsIsoMakerCmdOptEltoritoSetBootCatalogPath(PRTFSISOMAKERCMDOPTS pOpts, const char *pszBootCat) +{ + /* Make sure we'll fail later if no other boot options are present. */ + rtFsIsoMakerCmdOptEltoritoEnsureValidationEntry(pOpts); + + /* Parse the name spec. */ + RTFSISOMKCMDPARSEDNAMES Parsed; + int rc = rtFsIsoMakerCmdParseNameSpec(pOpts, pszBootCat, false /*fWithSrc*/, &Parsed); + if (RT_SUCCESS(rc)) + { + /* Query/create the boot catalog and enter it into the name spaces. */ + uint32_t idxBootCatObj; + rc = RTFsIsoMakerQueryObjIdxForBootCatalog(pOpts->hIsoMaker, &idxBootCatObj); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerCmdSetObjPaths(pOpts, idxBootCatObj, &Parsed, "boot catalog"); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerQueryBootCatalogPathObjIdx failed: %Rrc", rc); + } + return rc; +} + + +/** + * Deals with: --eltorito-add-image {file-spec} + * + * This differs from -b|--eltorito-boot in that it takes a source file + * specification identical to what rtFsIsoMakerCmdAddSomething processes instead + * of a reference to a file in the image. + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszGenericBootImage The generic boot image source. + */ +static int rtFsIsoMakerCmdOptEltoritoAddImage(PRTFSISOMAKERCMDOPTS pOpts, const char *pszBootImageSpec) +{ + /* Parse the name spec. */ + RTFSISOMKCMDPARSEDNAMES Parsed; + int rc = rtFsIsoMakerCmdParseNameSpec(pOpts, pszBootImageSpec, true /*fWithSrc*/, &Parsed); + if (RT_SUCCESS(rc)) + { + uint32_t idxBootCat; + rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + { + if ( pOpts->aBootCatEntries[idxBootCat].u.Section.idxImageObj != UINT32_MAX + || pOpts->aBootCatEntries[idxBootCat].u.Section.pszImageNameInIso != NULL) + rc = rtFsIsoMakerCmdSyntaxError(pOpts, "boot image already given for current El Torito entry (%#u)", idxBootCat); + else + { + uint32_t idxImageObj; + rc = rtFsIsoMakerCmdStatAndAddFile(pOpts, Parsed.aNames[Parsed.cNamesWithSrc - 1].szPath, &Parsed, &idxImageObj); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.idxImageObj = idxImageObj; + } + } + } + + return rc; +} + + +/** + * Deals with: -b|--eltorito-boot {file-in-iso} + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszGenericBootImage The generic boot image source. + */ +static int rtFsIsoMakerCmdOptEltoritoBoot(PRTFSISOMAKERCMDOPTS pOpts, const char *pszBootImage) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + { + if ( pOpts->aBootCatEntries[idxBootCat].u.Section.idxImageObj != UINT32_MAX + || pOpts->aBootCatEntries[idxBootCat].u.Section.pszImageNameInIso != NULL) + return rtFsIsoMakerCmdSyntaxError(pOpts, "boot image already given for current El Torito entry (%#u)", idxBootCat); + + uint32_t idxImageObj = RTFsIsoMakerGetObjIdxForPath(pOpts->hIsoMaker, RTFSISOMAKER_NAMESPACE_ALL, pszBootImage); + if (idxImageObj == UINT32_MAX) + pOpts->aBootCatEntries[idxBootCat].u.Section.pszImageNameInIso = pszBootImage; + pOpts->aBootCatEntries[idxBootCat].u.Section.idxImageObj = idxImageObj; + } + return rc; +} + + +/** + * Deals with: --eltorito-platform-id {x86|PPC|Mac|efi|number} + * + * Operates on the validation entry or a section header. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszPlatformId The platform ID. + */ +static int rtFsIsoMakerCmdOptEltoritoPlatformId(PRTFSISOMAKERCMDOPTS pOpts, const char *pszPlatformId) +{ + /* Decode it. */ + uint8_t idPlatform; + if (strcmp(pszPlatformId, "x86") == 0) + idPlatform = ISO9660_ELTORITO_PLATFORM_ID_X86; + else if (strcmp(pszPlatformId, "PPC") == 0) + idPlatform = ISO9660_ELTORITO_PLATFORM_ID_PPC; + else if (strcmp(pszPlatformId, "Mac") == 0) + idPlatform = ISO9660_ELTORITO_PLATFORM_ID_MAC; + else if (strcmp(pszPlatformId, "efi") == 0) + idPlatform = ISO9660_ELTORITO_PLATFORM_ID_EFI; + else + { + int rc = RTStrToUInt8Full(pszPlatformId, 0, &idPlatform); + if (rc != VINF_SUCCESS) + return rtFsIsoMakerCmdSyntaxError(pOpts, "invalid or unknown platform ID: %s", pszPlatformId); + } + + /* If this option comes before anything related to the default entry, work + on the validation entry. */ + if (pOpts->cBootCatEntries <= 1) + { + rtFsIsoMakerCmdOptEltoritoEnsureValidationEntry(pOpts); + pOpts->aBootCatEntries[0].u.Validation.idPlatform = idPlatform; + } + /* Otherwise, work on the current section header, creating a new one if necessary. */ + else + { + uint32_t idxBootCat = pOpts->cBootCatEntries - 1; + if (pOpts->aBootCatEntries[idxBootCat].enmType == RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader) + pOpts->aBootCatEntries[idxBootCat].u.SectionHeader.idPlatform = idPlatform; + else + { + idxBootCat++; + if (idxBootCat + 2 > RT_ELEMENTS(pOpts->aBootCatEntries)) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_BUFFER_OVERFLOW, "Too many boot catalog entries"); + + pOpts->aBootCatEntries[idxBootCat].enmType = RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader; + pOpts->aBootCatEntries[idxBootCat].u.SectionHeader.idPlatform = idPlatform; + pOpts->aBootCatEntries[idxBootCat].u.SectionHeader.pszString = NULL; + pOpts->cBootCatEntries = idxBootCat + 1; + } + } + return VINF_SUCCESS; +} + + +/** + * Deals with: -no-boot + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + */ +static int rtFsIsoMakerCmdOptEltoritoSetNotBootable(PRTFSISOMAKERCMDOPTS pOpts) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.fBootable = false; + return rc; +} + + +/** + * Deals with: -hard-disk-boot, -no-emulation-boot, --eltorito-floppy-12, + * --eltorito-floppy-144, --eltorito-floppy-288 + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param bMediaType The media type. + */ +static int rtFsIsoMakerCmdOptEltoritoSetMediaType(PRTFSISOMAKERCMDOPTS pOpts, uint8_t bMediaType) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.bBootMediaType = bMediaType; + return rc; +} + + +/** + * Deals with: -boot-load-seg {seg} + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param uSeg The load segment. + */ +static int rtFsIsoMakerCmdOptEltoritoSetLoadSegment(PRTFSISOMAKERCMDOPTS pOpts, uint16_t uSeg) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.uLoadSeg = uSeg; + return rc; +} + + +/** + * Deals with: -boot-load-size {sectors} + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param cSectors Number of emulated sectors to load + */ +static int rtFsIsoMakerCmdOptEltoritoSetLoadSectorCount(PRTFSISOMAKERCMDOPTS pOpts, uint16_t cSectors) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.cSectorsToLoad = cSectors; + return rc; +} + + +/** + * Deals with: -boot-info-table + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + */ +static int rtFsIsoMakerCmdOptEltoritoEnableBootInfoTablePatching(PRTFSISOMAKERCMDOPTS pOpts) +{ + uint32_t idxBootCat; + int rc = rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, false /*fForceNew*/, &idxBootCat); + if (RT_SUCCESS(rc)) + pOpts->aBootCatEntries[idxBootCat].u.Section.fInsertBootInfoTable = true; + return rc; +} + + +/** + * Validates and commits the boot catalog stuff. + * + * ASSUMING this is called after all options are parsed and there is only this + * one call. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + */ +static int rtFsIsoMakerCmdOptEltoritoCommitBootCatalog(PRTFSISOMAKERCMDOPTS pOpts) +{ + if (pOpts->cBootCatEntries == 0) + return VINF_SUCCESS; + + /* + * Locate and configure the boot images first. + */ + int rc; + PRTFSISOMKCMDELTORITOENTRY pBootCatEntry = &pOpts->aBootCatEntries[1]; + for (uint32_t idxBootCat = 1; idxBootCat < pOpts->cBootCatEntries; idxBootCat++, pBootCatEntry++) + if ( pBootCatEntry->enmType == RTFSISOMKCMDELTORITOENTRY::kEntryType_Default + || pBootCatEntry->enmType == RTFSISOMKCMDELTORITOENTRY::kEntryType_Section) + { + /* Make sure we've got a boot image. */ + uint32_t idxImageObj = pBootCatEntry->u.Section.idxImageObj; + if (idxImageObj == UINT32_MAX) + { + const char *pszBootImage = pBootCatEntry->u.Section.pszImageNameInIso; + if (pszBootImage == NULL) + return rtFsIsoMakerCmdSyntaxError(pOpts, "No image name given for boot catalog entry #%u", idxBootCat); + + idxImageObj = RTFsIsoMakerGetObjIdxForPath(pOpts->hIsoMaker, RTFSISOMAKER_NAMESPACE_ALL, pszBootImage); + if (idxImageObj == UINT32_MAX) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Unable to locate image for boot catalog entry #%u: %s", + idxBootCat, pszBootImage); + pBootCatEntry->u.Section.idxImageObj = idxImageObj; + } + + /* Enable patching it? */ + if (pBootCatEntry->u.Section.fInsertBootInfoTable) + { + rc = RTFsIsoMakerObjEnableBootInfoTablePatching(pOpts->hIsoMaker, idxImageObj, true); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, + "RTFsIsoMakerObjEnableBootInfoTablePatching failed on entry #%u: %Rrc", + idxBootCat, rc); + } + + /* Figure out the floppy type given the object size. */ + if (pBootCatEntry->u.Section.bBootMediaType == ISO9660_ELTORITO_BOOT_MEDIA_TYPE_MASK) + { + uint64_t cbImage; + rc = RTFsIsoMakerObjQueryDataSize(pOpts->hIsoMaker, idxImageObj, &cbImage); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerObjGetDataSize failed on entry #%u: %Rrc", + idxBootCat, rc); + if (cbImage == 1228800) + pBootCatEntry->u.Section.bBootMediaType = ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_2_MB; + else if (cbImage <= 1474560) + pBootCatEntry->u.Section.bBootMediaType = ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_44_MB; + else if (cbImage <= 2949120) + pBootCatEntry->u.Section.bBootMediaType = ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_2_88_MB; + else + pBootCatEntry->u.Section.bBootMediaType = ISO9660_ELTORITO_BOOT_MEDIA_TYPE_HARD_DISK; + } + } + + /* + * Add the boot catalog entries. + */ + pBootCatEntry = &pOpts->aBootCatEntries[0]; + for (uint32_t idxBootCat = 0; idxBootCat < pOpts->cBootCatEntries; idxBootCat++, pBootCatEntry++) + switch (pBootCatEntry->enmType) + { + case RTFSISOMKCMDELTORITOENTRY::kEntryType_Validation: + Assert(idxBootCat == 0); + rc = RTFsIsoMakerBootCatSetValidationEntry(pOpts->hIsoMaker, pBootCatEntry->u.Validation.idPlatform, + pBootCatEntry->u.Validation.pszString); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerBootCatSetValidationEntry failed: %Rrc", rc); + break; + + case RTFSISOMKCMDELTORITOENTRY::kEntryType_Default: + case RTFSISOMKCMDELTORITOENTRY::kEntryType_Section: + Assert(pBootCatEntry->enmType == RTFSISOMKCMDELTORITOENTRY::kEntryType_Default ? idxBootCat == 1 : idxBootCat > 2); + rc = RTFsIsoMakerBootCatSetSectionEntry(pOpts->hIsoMaker, idxBootCat, + pBootCatEntry->u.Section.idxImageObj, + pBootCatEntry->u.Section.bBootMediaType, + pBootCatEntry->u.Section.bSystemType, + pBootCatEntry->u.Section.fBootable, + pBootCatEntry->u.Section.uLoadSeg, + pBootCatEntry->u.Section.cSectorsToLoad, + ISO9660_ELTORITO_SEL_CRIT_TYPE_NONE, NULL, 0); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerBootCatSetSectionEntry failed on entry #%u: %Rrc", + idxBootCat, rc); + break; + + case RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader: + { + uint32_t cEntries = 1; + while ( idxBootCat + cEntries < pOpts->cBootCatEntries + && pBootCatEntry[cEntries].enmType != RTFSISOMKCMDELTORITOENTRY::kEntryType_SectionHeader) + cEntries++; + cEntries--; + + Assert(idxBootCat > 1); + rc = RTFsIsoMakerBootCatSetSectionHeaderEntry(pOpts->hIsoMaker, idxBootCat, cEntries, + pBootCatEntry->u.SectionHeader.idPlatform, + pBootCatEntry->u.SectionHeader.pszString); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, + "RTFsIsoMakerBootCatSetSectionHeaderEntry failed on entry #%u: %Rrc", + idxBootCat, rc); + break; + } + + default: + AssertFailedReturn(VERR_INTERNAL_ERROR_3); + } + + return VINF_SUCCESS; +} + + +/** + * Deals with: --eltorito-new-entry, --eltorito-alt-boot + * + * This operates on the current eltorito boot catalog entry. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + */ +static int rtFsIsoMakerCmdOptEltoritoNewEntry(PRTFSISOMAKERCMDOPTS pOpts) +{ + uint32_t idxBootCat; + return rtFsIsoMakerCmdOptEltoritoEnsureSectionEntry(pOpts, true /*fForceNew*/, &idxBootCat); +} + + +/** + * Sets a string property in all namespaces. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszValue The new string value. + * @param enmStringProp The string property. + */ +static int rtFsIsoMakerCmdOptSetStringProp(PRTFSISOMAKERCMDOPTS pOpts, const char *pszValue, RTFSISOMAKERSTRINGPROP enmStringProp) +{ + int rc = RTFsIsoMakerSetStringProp(pOpts->hIsoMaker, enmStringProp, pOpts->fDstNamespaces, pszValue); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set string property %d to '%s': %Rrc", enmStringProp, pszValue, rc); + return rc; +} + + +/** + * Handles the --dir-mode and --file-mode options. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param fDir True if applies to dir, false if applies to + * files. + * @param fMode The forced mode. + */ +static int rtFsIsoMakerCmdOptSetFileOrDirMode(PRTFSISOMAKERCMDOPTS pOpts, bool fDir, RTFMODE fMode) +{ + /* Change the mode masks. */ + int rc; + if (fDir) + rc = RTFsIsoMakerSetForcedDirMode(pOpts->hIsoMaker, fMode, true /*fForced*/); + else + rc = RTFsIsoMakerSetForcedFileMode(pOpts->hIsoMaker, fMode, true /*fForced*/); + if (RT_SUCCESS(rc)) + { + /* Then enable rock.*/ + rc = RTFsIsoMakerSetRockRidgeLevel(pOpts->hIsoMaker, 2); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to enable rock ridge: %Rrc", rc); + } + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set %s force & default mode mask to %04o: %Rrc", + fMode, fDir ? "directory" : "file", rc); +} + + +/** + * Handles the --no-dir-mode and --no-file-mode options that counters + * --dir-mode and --file-mode. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param fDir True if applies to dir, false if applies to + * files. + */ +static int rtFsIsoMakerCmdOptDisableFileOrDirMode(PRTFSISOMAKERCMDOPTS pOpts, bool fDir) +{ + int rc; + if (fDir) + rc = RTFsIsoMakerSetForcedDirMode(pOpts->hIsoMaker, 0, false /*fForced*/); + else + rc = RTFsIsoMakerSetForcedFileMode(pOpts->hIsoMaker, 0, true /*fForced*/); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to disable forced %s mode mask: %Rrc", fDir ? "directory" : "file", rc); +} + + + +/** + * Handles the --new-dir-mode option. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param fMode The forced mode. + */ +static int rtFsIsoMakerCmdOptSetNewDirMode(PRTFSISOMAKERCMDOPTS pOpts, RTFMODE fMode) +{ + int rc = RTFsIsoMakerSetDefaultDirMode(pOpts->hIsoMaker, fMode); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "Failed to set default dir mode mask to %04o: %Rrc", fMode, rc); +} + + +/** + * Handles the --chmod option. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszSpec The option value. + */ +static int rtFsIsoMakerCmdOptChmod(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSpec) +{ + /* + * Parse the mode part. + */ + int rc; + uint32_t fUnset = 07777; + uint32_t fSet = 0; + const char *pszPath = pszSpec; + if (RT_C_IS_DIGIT(*pszPath)) + { + rc = RTStrToUInt32Ex(pszSpec, (char **)&pszPath, 8, &fSet); + if (rc != VWRN_TRAILING_CHARS) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --chmod, octal mode parse failed: %s (%Rrc)", pszSpec, rc); + if (fSet & ~07777) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --chmod, invalid mode mask: 0%o, max 07777", fSet); + if (*pszPath != ':') + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --chmod, expected colon after mode: %s", pszSpec); + } + else + { + pszPath = strchr(pszPath, ':'); + if (pszPath == NULL) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --chmod, expected colon after mode: %s", pszSpec); + size_t const cchMode = pszPath - pszSpec; + + /* We currently only matches certain patterns. Later this needs to be generalized into a RTFile or RTPath method. */ + fUnset = 0; +#define MATCH_MODE_STR(a_szMode) (cchMode == sizeof(a_szMode) - 1U && memcmp(pszSpec, a_szMode, sizeof(a_szMode) - 1) == 0) + if (MATCH_MODE_STR("a+x")) + fSet = 0111; + else if (MATCH_MODE_STR("a+r")) + fSet = 0444; + else if (MATCH_MODE_STR("a+rx")) + fSet = 0555; + else + return rtFsIsoMakerCmdSyntaxError(pOpts, "Sorry, --chmod doesn't understand complicated mode expressions: %s", pszSpec); +#undef MATCH_MODE_STR + } + + /* + * Check that the file starts with a slash. + */ + pszPath++; + if (!RTPATH_IS_SLASH(*pszPath)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --chmod, path must start with a slash: %s", pszSpec); + + /* + * Do the job. + */ + rc = RTFsIsoMakerSetPathMode(pOpts->hIsoMaker, pszPath, pOpts->fDstNamespaces, fSet, fUnset, 0 /*fFlags*/, NULL /*pcHits*/); + if (rc == VWRN_NOT_FOUND) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Could not find --chmod path: %s", pszPath); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoMakerCmdSyntaxError(pOpts, "RTFsIsoMakerSetPathMode(,%s,%#x,%o,%o,0,) failed: %Rrc", + pszPath, pOpts->fDstNamespaces, fSet, fUnset, rc); +} + + +/** + * Handles the --chown and --chgrp options. + * + * @returns IPRT status code + * @param pOpts The ISO maker command instance. + * @param pszSpec The option value. + * @param fIsChOwn Set if 'chown', clear if 'chgrp'. + */ +static int rtFsIsoMakerCmdOptChangeOwnerGroup(PRTFSISOMAKERCMDOPTS pOpts, const char *pszSpec, bool fIsChOwn) +{ + const char * const pszOpt = fIsChOwn ? "chown" : "chgrp"; + + /* + * Parse out the ID and path . + */ + uint32_t idValue; + const char *pszPath = pszSpec; + int rc = RTStrToUInt32Ex(pszSpec, (char **)&pszPath, 0, &idValue); + if (rc != VWRN_TRAILING_CHARS) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --%s, numeric ID parse failed: %s (%Rrc)", pszOpt, pszSpec, rc); + if (*pszPath != ':') + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --%s, expected colon after ID: %s", pszOpt, pszSpec); + pszPath++; + if (!RTPATH_IS_SLASH(*pszPath)) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Malformed --%s, path must start with a slash: %s", pszOpt, pszSpec); + + /* + * Do the job. + */ + if (fIsChOwn) + rc = RTFsIsoMakerSetPathOwnerId(pOpts->hIsoMaker, pszPath, pOpts->fDstNamespaces, idValue, NULL /*pcHits*/); + else + rc = RTFsIsoMakerSetPathGroupId(pOpts->hIsoMaker, pszPath, pOpts->fDstNamespaces, idValue, NULL /*pcHits*/); + if (rc == VWRN_NOT_FOUND) + return rtFsIsoMakerCmdSyntaxError(pOpts, "Could not find --%s path: %s", pszOpt, pszPath); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoMakerCmdSyntaxError(pOpts, "RTFsIsoMakerSetPath%sId(,%s,%#x,%u,) failed: %Rrc", + fIsChOwn ? "Owner" : "Group", pszPath, pOpts->fDstNamespaces, idValue, rc); +} + + +/** + * Loads an argument file (e.g. a .iso-file) and parses it. + * + * @returns IPRT status code. + * @param pOpts The ISO maker command instance. + * @param pszFileSpec The file to parse. + * @param cDepth The current nesting depth. + */ +static int rtFsIsoMakerCmdParseArgumentFile(PRTFSISOMAKERCMDOPTS pOpts, const char *pszFileSpec, unsigned cDepth) +{ + if (cDepth > 2) + return rtFsIsoMakerCmdErrorRc(pOpts, VERR_INVALID_PARAMETER, "Too many nested argument files!"); + + /* + * Read the file into memory. + */ + RTERRINFOSTATIC ErrInfo; + uint32_t offError; + RTVFSFILE hVfsFile; + int rc = RTVfsChainOpenFile(pszFileSpec, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &hVfsFile, + &offError, RTErrInfoInitStatic(&ErrInfo)); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdChainError(pOpts, "RTVfsChainOpenFile", pszFileSpec, rc, offError, &ErrInfo.Core); + + uint64_t cbFile = 0; + rc = RTVfsFileGetSize(hVfsFile, &cbFile); + if (RT_SUCCESS(rc)) + { + if (cbFile < _2M) + { + char *pszContent = (char *)RTMemTmpAllocZ((size_t)cbFile + 1); + if (pszContent) + { + rc = RTVfsFileRead(hVfsFile, pszContent, (size_t)cbFile, NULL); + if (RT_SUCCESS(rc)) + { + /* + * Check that it's valid UTF-8 and turn it into an argument vector. + */ + rc = RTStrValidateEncodingEx(pszContent, (size_t)cbFile + 1, + RTSTR_VALIDATE_ENCODING_EXACT_LENGTH | RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED); + if (RT_SUCCESS(rc)) + { + uint32_t fGetOpt = strstr(pszContent, "--iprt-iso-maker-file-marker-ms") == NULL + ? RTGETOPTARGV_CNV_QUOTE_BOURNE_SH : RTGETOPTARGV_CNV_QUOTE_MS_CRT; + fGetOpt |= RTGETOPTARGV_CNV_MODIFY_INPUT; + char **papszArgs; + int cArgs; + rc = RTGetOptArgvFromString(&papszArgs, &cArgs, pszContent, fGetOpt, NULL); + if (RT_SUCCESS(rc)) + { + /* + * Parse them. + */ + rc = rtFsIsoMakerCmdParse(pOpts, cArgs, papszArgs, cDepth + 1); + + RTGetOptArgvFreeEx(papszArgs, fGetOpt); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s: RTGetOptArgvFromString failed: %Rrc", pszFileSpec, rc); + + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s: invalid encoding", pszFileSpec); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s: error to read it into memory: %Rrc", pszFileSpec, rc); + RTMemTmpFree(pszContent); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_NO_TMP_MEMORY, "%s: failed to allocte %zu bytes for reading", + pszFileSpec, (size_t)cbFile + 1); + } + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_FILE_TOO_BIG, "%s: file is too big: %'RU64 bytes, max 2MB", pszFileSpec, cbFile); + } + else + rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s: RTVfsFileGetSize failed: %Rrc", pszFileSpec, rc); + RTVfsFileRelease(hVfsFile); + return rc; +} + + +/** + * Parses the given command line options. + * + * @returns IPRT status code. + * @retval VINF_CALLBACK_RETURN if exit successfully (help, version). + * @param pOpts The ISO maker command instance. + * @param cArgs Number of arguments in papszArgs. + * @param papszArgs The argument vector to parse. + */ +static int rtFsIsoMakerCmdParse(PRTFSISOMAKERCMDOPTS pOpts, unsigned cArgs, char **papszArgs, unsigned cDepth) +{ + /* Setup option parsing. */ + RTGETOPTSTATE GetState; + int rc = RTGetOptInit(&GetState, cArgs, papszArgs, g_aRtFsIsoMakerOptions, RT_ELEMENTS(g_aRtFsIsoMakerOptions), + cDepth == 0 ? 1 : 0 /*iFirst*/, 0 /*fFlags*/); + if (RT_FAILURE(rc)) + return rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTGetOpt failed: %Rrc", rc); + + /* + * Parse parameters. Parameters are position dependent. + */ + RTGETOPTUNION ValueUnion; + while ( RT_SUCCESS(rc) + && (rc = RTGetOpt(&GetState, &ValueUnion)) != 0) + { + switch (rc) + { + /* + * Files and directories. + */ + case VINF_GETOPT_NOT_OPTION: + if ( *ValueUnion.psz != '@' + || strchr(ValueUnion.psz, '=')) + rc = rtFsIsoMakerCmdAddSomething(pOpts, ValueUnion.psz); + else + rc = rtFsIsoMakerCmdParseArgumentFile(pOpts, ValueUnion.psz + 1, cDepth); + break; + + + /* + * General options + */ + case 'o': + if (pOpts->fVirtualImageMaker) + return rtFsIsoMakerCmdSyntaxError(pOpts, "The --output option is not allowed"); + if (pOpts->pszOutFile) + return rtFsIsoMakerCmdSyntaxError(pOpts, "The --output option is specified more than once"); + pOpts->pszOutFile = ValueUnion.psz; + break; + + case RTFSISOMAKERCMD_OPT_NAME_SETUP: + rc = rtFsIsoMakerCmdOptNameSetup(pOpts, ValueUnion.psz); + break; + + case RTFSISOMAKERCMD_OPT_PUSH_ISO: + rc = rtFsIsoMakerCmdOptPushIso(pOpts, ValueUnion.psz, "--push-iso", 0); + break; + + case RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_JOLIET: + rc = rtFsIsoMakerCmdOptPushIso(pOpts, ValueUnion.psz, "--push-iso-no-joliet", RTFSISO9660_F_NO_JOLIET); + break; + + case RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK: + rc = rtFsIsoMakerCmdOptPushIso(pOpts, ValueUnion.psz, "--push-iso-no-rock", RTFSISO9660_F_NO_ROCK); + break; + + case RTFSISOMAKERCMD_OPT_PUSH_ISO_NO_ROCK_NO_JOLIET: + rc = rtFsIsoMakerCmdOptPushIso(pOpts, ValueUnion.psz, "--push-iso-no-rock-no-joliet", + RTFSISO9660_F_NO_ROCK | RTFSISO9660_F_NO_JOLIET); + break; + + case RTFSISOMAKERCMD_OPT_POP: + rc = rtFsIsoMakerCmdOptPop(pOpts); + break; + + case RTFSISOMAKERCMD_OPT_IMPORT_ISO: + rc = rtFsIsoMakerCmdOptImportIso(pOpts, ValueUnion.psz); + break; + + + /* + * Namespace configuration. + */ + case RTFSISOMAKERCMD_OPT_ISO_LEVEL: + rc = rtFsIsoMakerCmdOptSetIsoLevel(pOpts, ValueUnion.u8); + break; + + case RTFSISOMAKERCMD_OPT_ROCK_RIDGE: + rc = rtFsIsoMakerCmdOptSetPrimaryRockLevel(pOpts, 2); + break; + + case RTFSISOMAKERCMD_OPT_LIMITED_ROCK_RIDGE: + rc = rtFsIsoMakerCmdOptSetPrimaryRockLevel(pOpts, 1); + break; + + case RTFSISOMAKERCMD_OPT_NO_ROCK_RIDGE: + rc = rtFsIsoMakerCmdOptSetPrimaryRockLevel(pOpts, 0); + break; + + case 'J': + rc = rtFsIsoMakerCmdOptSetJolietUcs2Level(pOpts, 3); + break; + + case RTFSISOMAKERCMD_OPT_NO_JOLIET: + rc = rtFsIsoMakerCmdOptSetJolietUcs2Level(pOpts, 0); + break; + + case RTFSISOMAKERCMD_OPT_JOLIET_LEVEL: + rc = rtFsIsoMakerCmdOptSetJolietUcs2Level(pOpts, ValueUnion.u8); + break; + + + /* + * File attributes. + */ + case RTFSISOMAKERCMD_OPT_RATIONAL_ATTRIBS: + rc = rtFsIsoMakerCmdOptSetAttribInheritStyle(pOpts, false /*fStrict*/); + break; + + case RTFSISOMAKERCMD_OPT_STRICT_ATTRIBS: + rc = rtFsIsoMakerCmdOptSetAttribInheritStyle(pOpts, true /*fStrict*/); + break; + + case RTFSISOMAKERCMD_OPT_FILE_MODE: + rc = rtFsIsoMakerCmdOptSetFileOrDirMode(pOpts, false /*fDir*/, ValueUnion.u32); + break; + + case RTFSISOMAKERCMD_OPT_NO_FILE_MODE: + rc = rtFsIsoMakerCmdOptDisableFileOrDirMode(pOpts, false /*fDir*/); + break; + + case RTFSISOMAKERCMD_OPT_DIR_MODE: + rc = rtFsIsoMakerCmdOptSetFileOrDirMode(pOpts, true /*fDir*/, ValueUnion.u32); + break; + + case RTFSISOMAKERCMD_OPT_NO_DIR_MODE: + rc = rtFsIsoMakerCmdOptDisableFileOrDirMode(pOpts, true /*fDir*/); + break; + + case RTFSISOMAKERCMD_OPT_NEW_DIR_MODE: + rc = rtFsIsoMakerCmdOptSetNewDirMode(pOpts, ValueUnion.u32); + break; + + case RTFSISOMAKERCMD_OPT_CHMOD: + rc = rtFsIsoMakerCmdOptChmod(pOpts, ValueUnion.psz); + break; + + case RTFSISOMAKERCMD_OPT_CHOWN: + rc = rtFsIsoMakerCmdOptChangeOwnerGroup(pOpts, ValueUnion.psz, true /*fIsChOwn*/); + break; + + case RTFSISOMAKERCMD_OPT_CHGRP: + rc = rtFsIsoMakerCmdOptChangeOwnerGroup(pOpts, ValueUnion.psz, false /*fIsChOwn*/); + break; + + + /* + * Boot related options. + */ + case 'G': /* --generic-boot <file> */ + rc = rtFsIsoMakerCmdOptGenericBoot(pOpts, ValueUnion.psz); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_ADD_IMAGE: + rc = rtFsIsoMakerCmdOptEltoritoAddImage(pOpts, ValueUnion.psz); + break; + + case 'b': /* --eltorito-boot <boot.img> */ + rc = rtFsIsoMakerCmdOptEltoritoBoot(pOpts, ValueUnion.psz); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_NEW_ENTRY: + rc = rtFsIsoMakerCmdOptEltoritoNewEntry(pOpts); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_PLATFORM_ID: + rc = rtFsIsoMakerCmdOptEltoritoPlatformId(pOpts, ValueUnion.psz); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_NO_BOOT: + rc = rtFsIsoMakerCmdOptEltoritoSetNotBootable(pOpts); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_12: + rc = rtFsIsoMakerCmdOptEltoritoSetMediaType(pOpts, ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_2_MB); + break; + case RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_144: + rc = rtFsIsoMakerCmdOptEltoritoSetMediaType(pOpts, ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_44_MB); + break; + case RTFSISOMAKERCMD_OPT_ELTORITO_FLOPPY_288: + rc = rtFsIsoMakerCmdOptEltoritoSetMediaType(pOpts, ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_2_88_MB); + break; + case RTFSISOMAKERCMD_OPT_ELTORITO_HARD_DISK_BOOT: + rc = rtFsIsoMakerCmdOptEltoritoSetMediaType(pOpts, ISO9660_ELTORITO_BOOT_MEDIA_TYPE_HARD_DISK); + break; + case RTFSISOMAKERCMD_OPT_ELTORITO_NO_EMULATION_BOOT: + rc = rtFsIsoMakerCmdOptEltoritoSetMediaType(pOpts, ISO9660_ELTORITO_BOOT_MEDIA_TYPE_NO_EMULATION); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SEG: + rc = rtFsIsoMakerCmdOptEltoritoSetLoadSegment(pOpts, ValueUnion.u16); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_LOAD_SIZE: + rc = rtFsIsoMakerCmdOptEltoritoSetLoadSectorCount(pOpts, ValueUnion.u16); + break; + + case RTFSISOMAKERCMD_OPT_ELTORITO_INFO_TABLE: + rc = rtFsIsoMakerCmdOptEltoritoEnableBootInfoTablePatching(pOpts); + break; + + case 'c': /* --boot-catalog <cd-path> */ + rc = rtFsIsoMakerCmdOptEltoritoSetBootCatalogPath(pOpts, ValueUnion.psz); + break; + + + /* + * Image/namespace property related options. + */ + case RTFSISOMAKERCMD_OPT_ABSTRACT_FILE_ID: + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_ABSTRACT_FILE_ID); + break; + + case 'A': /* --application-id */ + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_APPLICATION_ID); + break; + + case RTFSISOMAKERCMD_OPT_BIBLIOGRAPHIC_FILE_ID: + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_BIBLIOGRAPHIC_FILE_ID); + break; + + case RTFSISOMAKERCMD_OPT_COPYRIGHT_FILE_ID: + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_COPYRIGHT_FILE_ID); + break; + + case 'P': /* -publisher */ + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_PUBLISHER_ID); + break; + + case 'p': /* --preparer*/ + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_DATA_PREPARER_ID); + break; + + case RTFSISOMAKERCMD_OPT_SYSTEM_ID: + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_SYSTEM_ID); + break; + + case RTFSISOMAKERCMD_OPT_VOLUME_ID: /* (should've been '-V') */ + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_VOLUME_ID); + break; + + case RTFSISOMAKERCMD_OPT_VOLUME_SET_ID: + rc = rtFsIsoMakerCmdOptSetStringProp(pOpts, ValueUnion.psz, RTFSISOMAKERSTRINGPROP_VOLUME_SET_ID); + break; + + + /* + * Compatibility. + */ + case RTFSISOMAKERCMD_OPT_GRAFT_POINTS: + rc = rtFsIsoMakerCmdOptNameSetup(pOpts, "iso+joliet+udf+hfs"); + break; + + case 'l': + if (RTFsIsoMakerGetIso9660Level(pOpts->hIsoMaker) >= 2) + rc = rtFsIsoMakerCmdOptSetIsoLevel(pOpts, 2); + break; + + case 'R': + rc = rtFsIsoMakerCmdOptSetPrimaryRockLevel(pOpts, 2); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerCmdOptSetAttribInheritStyle(pOpts, true /*fStrict*/); + break; + + case 'r': + rc = rtFsIsoMakerCmdOptSetPrimaryRockLevel(pOpts, 2); + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerCmdOptSetAttribInheritStyle(pOpts, false /*fStrict*/); + break; + + case RTFSISOMAKERCMD_OPT_PAD: + rc = RTFsIsoMakerSetImagePadding(pOpts->hIsoMaker, 150); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerSetImagePadding failed: %Rrc", rc); + break; + + case RTFSISOMAKERCMD_OPT_NO_PAD: + rc = RTFsIsoMakerSetImagePadding(pOpts->hIsoMaker, 0); + if (RT_FAILURE(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "RTFsIsoMakerSetImagePadding failed: %Rrc", rc); + break; + + + /* + * VISO specific + */ + case RTFSISOMAKERCMD_OPT_IPRT_ISO_MAKER_FILE_MARKER: + /* ignored */ + break; + + + /* + * Testing. + */ + case RTFSISOMAKERCMD_OPT_OUTPUT_BUFFER_SIZE: /* --output-buffer-size {cb} */ + pOpts->cbOutputReadBuffer = ValueUnion.u32; + break; + + case RTFSISOMAKERCMD_OPT_RANDOM_OUTPUT_BUFFER_SIZE: /* --random-output-buffer-size */ + pOpts->fRandomOutputReadBufferSize = true; + break; + + case RTFSISOMAKERCMD_OPT_RANDOM_ORDER_VERIFICATION: /* --random-order-verification {cb} */ + pOpts->cbRandomOrderVerifciationBlock = ValueUnion.u32; + break; + + + /* + * Standard bits. + */ + case 'h': + rtFsIsoMakerCmdUsage(pOpts, papszArgs[0]); + return pOpts->fVirtualImageMaker ? VERR_NOT_FOUND : VINF_CALLBACK_RETURN; + + case 'V': + rtFsIsoMakerPrintf(pOpts, "%sr%d\n", RTBldCfgVersion(), RTBldCfgRevision()); + return pOpts->fVirtualImageMaker ? VERR_NOT_FOUND : VINF_CALLBACK_RETURN; + + default: + if (rc > 0 && RT_C_IS_GRAPH(rc)) + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_GETOPT_UNKNOWN_OPTION, "Unhandled option: -%c", rc); + else if (rc > 0) + rc = rtFsIsoMakerCmdErrorRc(pOpts, VERR_GETOPT_UNKNOWN_OPTION, "Unhandled option: %i (%#x)", rc, rc); + else if (rc == VERR_GETOPT_UNKNOWN_OPTION) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "Unknown option: '%s'", ValueUnion.psz); + else if (ValueUnion.pDef) + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%s: %Rrs", ValueUnion.pDef->pszLong, rc); + else + rc = rtFsIsoMakerCmdErrorRc(pOpts, rc, "%Rrs", rc); + return rc; + } + if (RT_FAILURE(rc)) + return rc; + } + return VINF_SUCCESS; +} + + +/** + * Extended ISO maker command. + * + * This can be used as a ISO maker command that produces a image file, or + * alternatively for setting up a virtual ISO in memory. + * + * @returns IPRT status code + * @param cArgs Number of arguments. + * @param papszArgs Pointer to argument array. + * @param hVfsCwd The current working directory to assume when processing + * relative file/dir references. Pass NIL_RTVFSDIR to use + * the current CWD of the process. + * @param pszCwd Path to @a hVfsCwdDir. Use for error reporting and + * optimizing the open file count if possible. + * @param phVfsFile Where to return the virtual ISO. Pass NULL to for + * normal operation (creates file on disk). + * @param pErrInfo Where to return extended error information in the + * virtual ISO mode. + */ +RTDECL(int) RTFsIsoMakerCmdEx(unsigned cArgs, char **papszArgs, RTVFSDIR hVfsCwd, const char *pszCwd, + PRTVFSFILE phVfsFile, PRTERRINFO pErrInfo) +{ + if (phVfsFile) + *phVfsFile = NIL_RTVFSFILE; + + /* + * Create instance. + */ + RTFSISOMAKERCMDOPTS Opts; + RT_ZERO(Opts); + Opts.hIsoMaker = NIL_RTFSISOMAKER; + Opts.pErrInfo = pErrInfo; + Opts.fVirtualImageMaker = phVfsFile != NULL; + Opts.cNameSpecifiers = 1; + Opts.afNameSpecifiers[0] = RTFSISOMAKERCMDNAME_MAJOR_MASK; + Opts.fDstNamespaces = RTFSISOMAKERCMDNAME_MAJOR_MASK; + Opts.pszTransTbl = "TRANS.TBL"; /** @todo query this below */ + for (uint32_t i = 0; i < RT_ELEMENTS(Opts.aBootCatEntries); i++) + Opts.aBootCatEntries[i].u.Section.idxImageObj = UINT32_MAX; + + /* Initialize the source stack with NILs (to be on the safe size). */ + Opts.iSrcStack = -1; + for (uint32_t i = 0; i < RT_ELEMENTS(Opts.aSrcStack); i++) + { + Opts.aSrcStack[i].hSrcDir = NIL_RTVFSDIR; + Opts.aSrcStack[i].hSrcVfs = NIL_RTVFS; + } + + /* Push the CWD if present. */ + if (hVfsCwd != NIL_RTVFSDIR) + { + AssertReturn(pszCwd, VERR_INVALID_PARAMETER); + uint32_t cRefs = RTVfsDirRetain(hVfsCwd); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + Opts.aSrcStack[0].hSrcDir = hVfsCwd; + Opts.aSrcStack[0].pszSrcVfs = pszCwd; + Opts.iSrcStack = 0; + } + + /* Create the ISO creator instance. */ + int rc = RTFsIsoMakerCreate(&Opts.hIsoMaker); + if (RT_SUCCESS(rc)) + { + /* + * Parse the command line and check for mandatory options. + */ + rc = rtFsIsoMakerCmdParse(&Opts, cArgs, papszArgs, 0); + if (RT_SUCCESS(rc) && rc != VINF_CALLBACK_RETURN) + { + if (!Opts.cItemsAdded) + rc = rtFsIsoMakerCmdErrorRc(&Opts, VERR_NO_DATA, "Cowardly refuses to create empty ISO image"); + else if (!Opts.pszOutFile && !Opts.fVirtualImageMaker) + rc = rtFsIsoMakerCmdErrorRc(&Opts, VERR_INVALID_PARAMETER, "No output file specified (--output <file>)"); + + /* + * Final actions. + */ + if (RT_SUCCESS(rc)) + rc = rtFsIsoMakerCmdOptEltoritoCommitBootCatalog(&Opts); + if (RT_SUCCESS(rc)) + { + /* + * Finalize the image and get the virtual file. + */ + rc = RTFsIsoMakerFinalize(Opts.hIsoMaker); + if (RT_SUCCESS(rc)) + { + RTVFSFILE hVfsFile; + rc = RTFsIsoMakerCreateVfsOutputFile(Opts.hIsoMaker, &hVfsFile); + if (RT_SUCCESS(rc)) + { + /* + * We're done now if we're only setting up a virtual image. + */ + if (Opts.fVirtualImageMaker) + *phVfsFile = hVfsFile; + else + { + rc = rtFsIsoMakerCmdWriteImage(&Opts, hVfsFile); + RTVfsFileRelease(hVfsFile); + } + } + else + rc = rtFsIsoMakerCmdErrorRc(&Opts, rc, "RTFsIsoMakerCreateVfsOutputFile failed: %Rrc", rc); + } + else + rc = rtFsIsoMakerCmdErrorRc(&Opts, rc, "RTFsIsoMakerFinalize failed: %Rrc", rc); + } + } + } + else + { + rc = rtFsIsoMakerCmdErrorRc(&Opts, rc, "RTFsIsoMakerCreate failed: %Rrc", rc); + Opts.hIsoMaker = NIL_RTFSISOMAKER; + } + + return rtFsIsoMakerCmdDeleteState(&Opts, rc); +} + + +/** + * ISO maker command (creates image file on disk). + * + * @returns IPRT status code + * @param cArgs Number of arguments. + * @param papszArgs Pointer to argument array. + */ +RTDECL(RTEXITCODE) RTFsIsoMakerCmd(unsigned cArgs, char **papszArgs) +{ + int rc = RTFsIsoMakerCmdEx(cArgs, papszArgs, NIL_RTVFSDIR, NULL, NULL, NULL); + return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; +} + diff --git a/src/VBox/Runtime/common/fs/isomakerimport.cpp b/src/VBox/Runtime/common/fs/isomakerimport.cpp new file mode 100644 index 00000000..6d598e56 --- /dev/null +++ b/src/VBox/Runtime/common/fs/isomakerimport.cpp @@ -0,0 +1,2720 @@ +/* $Id: isomakerimport.cpp $ */ +/** @file + * IPRT - ISO Image Maker, Import Existing Image. + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include "internal/iprt.h" +#include <iprt/fsisomaker.h> + +#include <iprt/avl.h> +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/list.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/utf16.h> +#include <iprt/vfs.h> +#include <iprt/formats/iso9660.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Max directory depth. */ +#define RTFSISOMK_IMPORT_MAX_DEPTH 32 + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Block to file translation node. + */ +typedef struct RTFSISOMKIMPBLOCK2FILE +{ + /** AVL tree node containing the first block number of the file. + * Block number is relative to the start of the import image. */ + AVLU32NODECORE Core; + /** The configuration index of the file. */ + uint32_t idxObj; + /** Namespaces the file has been seen in already (RTFSISOMAKER_NAMESPACE_XXX). */ + uint32_t fNamespaces; + /** Pointer to the next file with the same block number. */ + struct RTFSISOMKIMPBLOCK2FILE *pNext; +} RTFSISOMKIMPBLOCK2FILE; +/** Pointer to a block-2-file translation node. */ +typedef RTFSISOMKIMPBLOCK2FILE *PRTFSISOMKIMPBLOCK2FILE; + + +/** + * Directory todo list entry. + */ +typedef struct RTFSISOMKIMPDIR +{ + /** List stuff. */ + RTLISTNODE Entry; + /** The directory configuration index with hIsoMaker. */ + uint32_t idxObj; + /** The directory data block number. */ + uint32_t offDirBlock; + /** The directory size (in bytes). */ + uint32_t cbDir; + /** The depth of this directory. */ + uint8_t cDepth; +} RTFSISOMKIMPDIR; +/** Pointer to a directory todo list entry. */ +typedef RTFSISOMKIMPDIR *PRTFSISOMKIMPDIR; + + +/** + * ISO maker ISO importer state. + */ +typedef struct RTFSISOMKIMPORTER +{ + /** The destination ISO maker. */ + RTFSISOMAKER hIsoMaker; + /** RTFSISOMK_IMPORT_F_XXX. */ + uint32_t fFlags; + /** The status code of the whole import. + * This notes down the first error status. */ + int rc; + /** Pointer to error info return structure. */ + PRTERRINFO pErrInfo; + + /** The source file. */ + RTVFSFILE hSrcFile; + /** The size of the source file. */ + uint64_t cbSrcFile; + /** The number of 2KB blocks in the source file. */ + uint64_t cBlocksInSrcFile; + /** The import source index of hSrcFile in hIsoMaker. UINT32_MAX till adding + * the first file. */ + uint32_t idxSrcFile; + + /** The root of the tree for converting data block numbers to files + * (PRTFSISOMKIMPBLOCK2FILE). This is essential when importing boot files and + * the 2nd namespace (joliet, udf, hfs) so that we avoid duplicating data. */ + AVLU32TREE Block2FileRoot; + + /** The block offset of the primary volume descriptor. */ + uint32_t offPrimaryVolDesc; + /** The primary volume space size in blocks. */ + uint32_t cBlocksInPrimaryVolumeSpace; + /** The primary volume space size in bytes. */ + uint64_t cbPrimaryVolumeSpace; + /** The number of volumes in the set. */ + uint32_t cVolumesInSet; + /** The primary volume sequence ID. */ + uint32_t idPrimaryVol; + + /** Set if we've already seen a joliet volume descriptor. */ + bool fSeenJoliet; + + /** The name of the TRANS.TBL in the import media (must ignore). */ + const char *pszTransTbl; + + /** Pointer to the import results structure (output). */ + PRTFSISOMAKERIMPORTRESULTS pResults; + + /** Sector buffer for volume descriptors and such. */ + union + { + uint8_t ab[ISO9660_SECTOR_SIZE]; + ISO9660VOLDESCHDR VolDescHdr; + ISO9660PRIMARYVOLDESC PrimVolDesc; + ISO9660SUPVOLDESC SupVolDesc; + ISO9660BOOTRECORDELTORITO ElToritoDesc; + } uSectorBuf; + + /** Name buffer. */ + char szNameBuf[_2K]; + + /** A somewhat larger buffer. */ + uint8_t abBuf[_64K]; + + /** @name Rock Ridge stuff + * @{ */ + /** Set if we've see the SP entry. */ + bool fSuspSeenSP; + /** Set if we've seen the last 'NM' entry. */ + bool fSeenLastNM; + /** Set if we've seen the last 'SL' entry. */ + bool fSeenLastSL; + /** The SUSP skip into system area offset. */ + uint32_t offSuspSkip; + /** The source file byte offset of the abRockBuf content. */ + uint64_t offRockBuf; + /** Name buffer for rock ridge. */ + char szRockNameBuf[_2K]; + /** Symlink target name buffer for rock ridge. */ + char szRockSymlinkTargetBuf[_2K]; + /** A buffer for reading rock ridge continuation blocks into */ + uint8_t abRockBuf[ISO9660_SECTOR_SIZE]; + /** @} */ +} RTFSISOMKIMPORTER; +/** Pointer to an ISO maker ISO importer state. */ +typedef RTFSISOMKIMPORTER *PRTFSISOMKIMPORTER; + + +/* + * The following is also found in iso9660vfs.cpp: + * The following is also found in iso9660vfs.cpp: + * The following is also found in iso9660vfs.cpp: + */ + +/** + * Converts a ISO 9660 binary timestamp into an IPRT timesspec. + * + * @param pTimeSpec Where to return the IRPT time. + * @param pIso9660 The ISO 9660 binary timestamp. + */ +static void rtFsIsoImpIso9660RecDateTime2TimeSpec(PRTTIMESPEC pTimeSpec, PCISO9660RECTIMESTAMP pIso9660) +{ + RTTIME Time; + Time.fFlags = RTTIME_FLAGS_TYPE_UTC; + Time.offUTC = 0; + Time.i32Year = pIso9660->bYear + 1900; + Time.u8Month = RT_MIN(RT_MAX(pIso9660->bMonth, 1), 12); + Time.u8MonthDay = RT_MIN(RT_MAX(pIso9660->bDay, 1), 31); + Time.u8WeekDay = UINT8_MAX; + Time.u16YearDay = 0; + Time.u8Hour = RT_MIN(pIso9660->bHour, 23); + Time.u8Minute = RT_MIN(pIso9660->bMinute, 59); + Time.u8Second = RT_MIN(pIso9660->bSecond, 59); + Time.u32Nanosecond = 0; + RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time)); + + /* Only apply the UTC offset if it's within reasons. */ + if (RT_ABS(pIso9660->offUtc) <= 13*4) + RTTimeSpecSubSeconds(pTimeSpec, pIso9660->offUtc * 15 * 60 * 60); +} + +/** + * Converts a ISO 9660 char timestamp into an IPRT timesspec. + * + * @returns true if valid, false if not. + * @param pTimeSpec Where to return the IRPT time. + * @param pIso9660 The ISO 9660 char timestamp. + */ +static bool rtFsIsoImpIso9660DateTime2TimeSpecIfValid(PRTTIMESPEC pTimeSpec, PCISO9660TIMESTAMP pIso9660) +{ + if ( RT_C_IS_DIGIT(pIso9660->achYear[0]) + && RT_C_IS_DIGIT(pIso9660->achYear[1]) + && RT_C_IS_DIGIT(pIso9660->achYear[2]) + && RT_C_IS_DIGIT(pIso9660->achYear[3]) + && RT_C_IS_DIGIT(pIso9660->achMonth[0]) + && RT_C_IS_DIGIT(pIso9660->achMonth[1]) + && RT_C_IS_DIGIT(pIso9660->achDay[0]) + && RT_C_IS_DIGIT(pIso9660->achDay[1]) + && RT_C_IS_DIGIT(pIso9660->achHour[0]) + && RT_C_IS_DIGIT(pIso9660->achHour[1]) + && RT_C_IS_DIGIT(pIso9660->achMinute[0]) + && RT_C_IS_DIGIT(pIso9660->achMinute[1]) + && RT_C_IS_DIGIT(pIso9660->achSecond[0]) + && RT_C_IS_DIGIT(pIso9660->achSecond[1]) + && RT_C_IS_DIGIT(pIso9660->achCentisecond[0]) + && RT_C_IS_DIGIT(pIso9660->achCentisecond[1])) + { + + RTTIME Time; + Time.fFlags = RTTIME_FLAGS_TYPE_UTC; + Time.offUTC = 0; + Time.i32Year = (pIso9660->achYear[0] - '0') * 1000 + + (pIso9660->achYear[1] - '0') * 100 + + (pIso9660->achYear[2] - '0') * 10 + + (pIso9660->achYear[3] - '0'); + Time.u8Month = (pIso9660->achMonth[0] - '0') * 10 + + (pIso9660->achMonth[1] - '0'); + Time.u8MonthDay = (pIso9660->achDay[0] - '0') * 10 + + (pIso9660->achDay[1] - '0'); + Time.u8WeekDay = UINT8_MAX; + Time.u16YearDay = 0; + Time.u8Hour = (pIso9660->achHour[0] - '0') * 10 + + (pIso9660->achHour[1] - '0'); + Time.u8Minute = (pIso9660->achMinute[0] - '0') * 10 + + (pIso9660->achMinute[1] - '0'); + Time.u8Second = (pIso9660->achSecond[0] - '0') * 10 + + (pIso9660->achSecond[1] - '0'); + Time.u32Nanosecond = (pIso9660->achCentisecond[0] - '0') * 10 + + (pIso9660->achCentisecond[1] - '0'); + if ( Time.u8Month > 1 && Time.u8Month <= 12 + && Time.u8MonthDay > 1 && Time.u8MonthDay <= 31 + && Time.u8Hour < 60 + && Time.u8Minute < 60 + && Time.u8Second < 60 + && Time.u32Nanosecond < 100) + { + if (Time.i32Year <= 1677) + Time.i32Year = 1677; + else if (Time.i32Year <= 2261) + Time.i32Year = 2261; + + Time.u32Nanosecond *= RT_NS_10MS; + RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time)); + + /* Only apply the UTC offset if it's within reasons. */ + if (RT_ABS(pIso9660->offUtc) <= 13*4) + RTTimeSpecSubSeconds(pTimeSpec, pIso9660->offUtc * 15 * 60 * 60); + return true; + } + } + return false; +} + +/* end of duplicated static functions. */ + + +/** + * Wrapper around RTErrInfoSetV. + * + * @returns rc + * @param pThis The importer instance. + * @param rc The status code to set. + * @param pszFormat The format string detailing the error. + * @param va Argument to the format string. + */ +static int rtFsIsoImpErrorV(PRTFSISOMKIMPORTER pThis, int rc, const char *pszFormat, va_list va) +{ + va_list vaCopy; + va_copy(vaCopy, va); + LogRel(("RTFsIsoMkImport error %Rrc: %N\n", rc, pszFormat, &vaCopy)); + va_end(vaCopy); + + if (RT_SUCCESS(pThis->rc)) + { + pThis->rc = rc; + rc = RTErrInfoSetV(pThis->pErrInfo, rc, pszFormat, va); + } + + pThis->pResults->cErrors++; + return rc; +} + + +/** + * Wrapper around RTErrInfoSetF. + * + * @returns rc + * @param pThis The importer instance. + * @param rc The status code to set. + * @param pszFormat The format string detailing the error. + * @param ... Argument to the format string. + */ +static int rtFsIsoImpError(PRTFSISOMKIMPORTER pThis, int rc, const char *pszFormat, ...) +{ + va_list va; + va_start(va, pszFormat); + rc = rtFsIsoImpErrorV(pThis, rc, pszFormat, va); + va_end(va); + return rc; +} + + +/** + * Callback for destroying a RTFSISOMKIMPBLOCK2FILE node. + * + * @returns VINF_SUCCESS + * @param pNode The node to destroy. + * @param pvUser Ignored. + */ +static DECLCALLBACK(int) rtFsIsoMakerImportDestroyData2File(PAVLU32NODECORE pNode, void *pvUser) +{ + PRTFSISOMKIMPBLOCK2FILE pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)pNode; + if (pBlock2File) + { + PRTFSISOMKIMPBLOCK2FILE pNext; + while ((pNext = pBlock2File->pNext) != NULL) + { + pBlock2File->pNext = pNext->pNext; + pNext->pNext = NULL; + RTMemFree(pNext); + } + RTMemFree(pNode); + } + + RT_NOREF(pvUser); + return VINF_SUCCESS; +} + + +/** + * Adds a symbolic link and names it given its ISO-9660 directory record and + * parent. + * + * @returns IPRT status code (safe to ignore). + * @param pThis The importer instance. + * @param pDirRec The directory record. + * @param pObjInfo Object information. + * @param fNamespace The namespace flag. + * @param idxParent Parent directory. + * @param pszName The name. + * @param pszRockName The rock ridge name. Empty if not present. + * @param pszTarget The symbolic link target. + */ +static int rtFsIsoImportProcessIso9660AddAndNameSymlink(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, PRTFSOBJINFO pObjInfo, + uint32_t fNamespace, uint32_t idxParent, + const char *pszName, const char *pszRockName, const char *pszTarget) +{ + NOREF(pDirRec); + Assert(!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)); + Assert(RTFS_IS_SYMLINK(pObjInfo->Attr.fMode)); + + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedSymlink(pThis->hIsoMaker, pObjInfo, pszTarget, &idxObj); + if (RT_SUCCESS(rc)) + { + Log3((" --> added symlink #%#x (-> %s)\n", idxObj, pszTarget)); + pThis->pResults->cAddedSymlinks++; + + /* + * Enter the object into the namespace. + */ + rc = RTFsIsoMakerObjSetNameAndParent(pThis->hIsoMaker, idxObj, idxParent, fNamespace, pszName); + if (RT_SUCCESS(rc)) + { + pThis->pResults->cAddedNames++; + + if (*pszRockName != '\0' && strcmp(pszName, pszRockName) != 0) + { + rc = RTFsIsoMakerObjSetRockName(pThis->hIsoMaker, idxObj, fNamespace, pszRockName); + if (RT_FAILURE(rc)) + rc = rtFsIsoImpError(pThis, rc, "Error setting rock ridge name for symlink '%s' to '%s'", pszName, pszRockName); + } + } + else + rc = rtFsIsoImpError(pThis, rc, "Error naming symlink '%s' (-> %s): %Rrc", pszName, pszTarget, rc); + } + else + rc = rtFsIsoImpError(pThis, rc, "Error adding symbolic link '%s' (-> %s): %Rrc", pszName, pszTarget, rc); + return rc; +} + + + +/** + * Adds a directory and names it given its ISO-9660 directory record and parent. + * + * @returns IPRT status code (safe to ignore). + * @param pThis The importer instance. + * @param pDirRec The directory record. + * @param pObjInfo Object information. + * @param cbData The actual directory data size. (Always same as in the + * directory record, but this what we do for files below.) + * @param fNamespace The namespace flag. + * @param idxParent Parent directory. + * @param pszName The name. + * @param pszRockName The rock ridge name. Empty if not present. + * @param cDepth The depth to add it with. + * @param pTodoList The todo list (for directories). + */ +static int rtFsIsoImportProcessIso9660AddAndNameDirectory(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, + PCRTFSOBJINFO pObjInfo, uint64_t cbData, + uint32_t fNamespace, uint32_t idxParent, const char *pszName, + const char *pszRockName, uint8_t cDepth, PRTLISTANCHOR pTodoList) +{ + Assert(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY); + uint32_t idxObj; + int rc = RTFsIsoMakerAddUnnamedDir(pThis->hIsoMaker, pObjInfo, &idxObj); + if (RT_SUCCESS(rc)) + { + Log3((" --> added directory #%#x\n", idxObj)); + pThis->pResults->cAddedDirs++; + + /* + * Enter the object into the namespace. + */ + rc = RTFsIsoMakerObjSetNameAndParent(pThis->hIsoMaker, idxObj, idxParent, fNamespace, pszName); + if (RT_SUCCESS(rc)) + { + pThis->pResults->cAddedNames++; + + if (*pszRockName != '\0' && strcmp(pszName, pszRockName) != 0) + rc = RTFsIsoMakerObjSetRockName(pThis->hIsoMaker, idxObj, fNamespace, pszRockName); + if (RT_SUCCESS(rc)) + { + /* + * Push it onto the traversal stack. + */ + PRTFSISOMKIMPDIR pImpDir = (PRTFSISOMKIMPDIR)RTMemAlloc(sizeof(*pImpDir)); + if (pImpDir) + { + Assert((uint32_t)cbData == cbData /* no multi-extents for dirs makes it this far */); + pImpDir->cbDir = (uint32_t)cbData; + pImpDir->offDirBlock = ISO9660_GET_ENDIAN(&pDirRec->offExtent); + pImpDir->idxObj = idxObj; + pImpDir->cDepth = cDepth; + RTListAppend(pTodoList, &pImpDir->Entry); + } + else + rc = rtFsIsoImpError(pThis, VERR_NO_MEMORY, "Could not allocate RTFSISOMKIMPDIR"); + } + else + rc = rtFsIsoImpError(pThis, rc, "Error setting rock ridge name for directory '%s' to '%s'", pszName, pszRockName); + } + else + rc = rtFsIsoImpError(pThis, rc, "Error naming directory '%s': %Rrc", pszName, rc); + } + else + rc = rtFsIsoImpError(pThis, rc, "Error adding directory '%s': %Rrc", pszName, rc); + return rc; +} + + +/** + * Adds a file and names it given its ISO-9660 directory record and parent. + * + * @returns IPRT status code (safe to ignore). + * @param pThis The importer instance. + * @param pDirRec The directory record. + * @param pObjInfo Object information. + * @param cbData The actual file data size. + * @param fNamespace The namespace flag. + * @param idxParent Parent directory. + * @param pszName The name. + * @param pszRockName The rock ridge name. Empty if not present. + */ +static int rtFsIsoImportProcessIso9660AddAndNameFile(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, PRTFSOBJINFO pObjInfo, + uint64_t cbData, uint32_t fNamespace, uint32_t idxParent, + const char *pszName, const char *pszRockName) +{ + int rc; + + /* + * First we must make sure the common source file has been added. + */ + if (pThis->idxSrcFile != UINT32_MAX) + { /* likely */ } + else + { + rc = RTFsIsoMakerAddCommonSourceFile(pThis->hIsoMaker, pThis->hSrcFile, &pThis->idxSrcFile); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerAddCommonSourceFile failed: %Rrc", rc); + Assert(pThis->idxSrcFile != UINT32_MAX); + } + + /* + * Lookup the data block if the file has a non-zero length. The aim is to + * find files across namespaces while bearing in mind that files in the same + * namespace may share data storage, i.e. what in a traditional unix file + * system would be called hardlinked. Problem is that the core engine doesn't + * do hardlinking yet and assume each file has exactly one name per namespace. + */ + uint32_t idxObj = UINT32_MAX; + PRTFSISOMKIMPBLOCK2FILE pBlock2File = NULL; + PRTFSISOMKIMPBLOCK2FILE pBlock2FilePrev = NULL; + if (cbData > 0) /* no data tracking for zero byte files */ + { + pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)RTAvlU32Get(&pThis->Block2FileRoot, ISO9660_GET_ENDIAN(&pDirRec->offExtent)); + if (pBlock2File) + { + if (!(pBlock2File->fNamespaces & fNamespace)) + { + pBlock2File->fNamespaces |= fNamespace; + idxObj = pBlock2File->idxObj; + } + else + { + do + { + pBlock2FilePrev = pBlock2File; + pBlock2File = pBlock2File->pNext; + } while (pBlock2File && (pBlock2File->fNamespaces & fNamespace)); + if (pBlock2File) + { + pBlock2File->fNamespaces |= fNamespace; + idxObj = pBlock2File->idxObj; + } + } + } + } + + /* + * If the above lookup didn't succeed, add a new file with a lookup record. + */ + if (idxObj == UINT32_MAX) + { + pObjInfo->cbObject = pObjInfo->cbAllocated = cbData; + rc = RTFsIsoMakerAddUnnamedFileWithCommonSrc(pThis->hIsoMaker, pThis->idxSrcFile, + ISO9660_GET_ENDIAN(&pDirRec->offExtent) * (uint64_t)ISO9660_SECTOR_SIZE, + cbData, pObjInfo, &idxObj); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "Error adding file '%s': %Rrc", pszName, rc); + Assert(idxObj != UINT32_MAX); + + /* Update statistics. */ + pThis->pResults->cAddedFiles++; + if (cbData > 0) + { + pThis->pResults->cbAddedDataBlocks += RT_ALIGN_64(cbData, ISO9660_SECTOR_SIZE); + + /* Lookup record. */ + pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)RTMemAlloc(sizeof(*pBlock2File)); + AssertReturn(pBlock2File, rtFsIsoImpError(pThis, VERR_NO_MEMORY, "Could not allocate RTFSISOMKIMPBLOCK2FILE")); + + pBlock2File->idxObj = idxObj; + pBlock2File->Core.Key = ISO9660_GET_ENDIAN(&pDirRec->offExtent); + pBlock2File->fNamespaces = fNamespace; + pBlock2File->pNext = NULL; + if (!pBlock2FilePrev) + { + bool fRc = RTAvlU32Insert(&pThis->Block2FileRoot, &pBlock2File->Core); + Assert(fRc); RT_NOREF(fRc); + } + else + { + pBlock2File->Core.pLeft = NULL; + pBlock2File->Core.pRight = NULL; + pBlock2FilePrev->pNext = pBlock2File; + } + } + } + + /* + * Enter the object into the namespace. + */ + rc = RTFsIsoMakerObjSetNameAndParent(pThis->hIsoMaker, idxObj, idxParent, fNamespace, pszName); + if (RT_SUCCESS(rc)) + { + pThis->pResults->cAddedNames++; + + if (*pszRockName != '\0' && strcmp(pszName, pszRockName) != 0) + { + rc = RTFsIsoMakerObjSetRockName(pThis->hIsoMaker, idxObj, fNamespace, pszRockName); + if (RT_FAILURE(rc)) + rc = rtFsIsoImpError(pThis, rc, "Error setting rock ridge name for file '%s' to '%s'", pszName, pszRockName); + } + } + else + return rtFsIsoImpError(pThis, rc, "Error naming file '%s': %Rrc", pszName, rc); + return VINF_SUCCESS; +} + + +/** + * Parses rock ridge information if present in the directory entry. + * + * @param pThis The importer instance. + * @param pObjInfo The object information to improve upon. + * @param pbSys The system area of the directory record. + * @param cbSys The number of bytes present in the sys area. + * @param fUnicode Indicates which namespace we're working on. + * @param fIsFirstDirRec Set if this is the '.' directory entry in the + * root directory. (Some entries applies only to + * it.) + * @param fContinuationRecord Set if we're processing a continuation record in + * living in the abRockBuf. + */ +static void rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge(PRTFSISOMKIMPORTER pThis, PRTFSOBJINFO pObjInfo, + uint8_t const *pbSys, size_t cbSys, bool fUnicode, + bool fIsFirstDirRec, bool fContinuationRecord) +{ + RT_NOREF(pObjInfo); + + /* + * Do skipping if specified. + */ + if (pThis->offSuspSkip) + { + if (cbSys <= pThis->offSuspSkip) + return; + pbSys += pThis->offSuspSkip; + cbSys -= pThis->offSuspSkip; + } + + while (cbSys >= 4) + { + /* + * Check header length and advance the sys variables. + */ + PCISO9660SUSPUNION pUnion = (PCISO9660SUSPUNION)pbSys; + if (pUnion->Hdr.cbEntry > cbSys) + { + LogRel(("rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge: cbEntry=%#x cbSys=%#x (%#x %#x)\n", + pUnion->Hdr.cbEntry, cbSys, pUnion->Hdr.bSig1, pUnion->Hdr.bSig2)); + return; + } + pbSys += pUnion->Hdr.cbEntry; + cbSys -= pUnion->Hdr.cbEntry; + + /* + * Process fields. + */ +#define MAKE_SIG(a_bSig1, a_bSig2) \ + ( ((uint16_t)(a_bSig1) & 0x1f) \ + | (((uint16_t)(a_bSig2) ^ 0x40) << 5) \ + | ((((uint16_t)(a_bSig1) ^ 0x40) & 0xe0) << (5 + 8)) ) + + uint16_t const uSig = MAKE_SIG(pUnion->Hdr.bSig1, pUnion->Hdr.bSig2); + switch (uSig) + { + /* + * System use sharing protocol entries. + */ + case MAKE_SIG(ISO9660SUSPCE_SIG1, ISO9660SUSPCE_SIG2): + { + if (RT_BE2H_U32(pUnion->CE.offBlock.be) != RT_LE2H_U32(pUnion->CE.offBlock.le)) + LogRel(("rtFsIsoImport/Rock: Invalid CE offBlock field: be=%#x vs le=%#x\n", + RT_BE2H_U32(pUnion->CE.offBlock.be), RT_LE2H_U32(pUnion->CE.offBlock.le))); + else if (RT_BE2H_U32(pUnion->CE.cbData.be) != RT_LE2H_U32(pUnion->CE.cbData.le)) + LogRel(("rtFsIsoImport/Rock: Invalid CE cbData field: be=%#x vs le=%#x\n", + RT_BE2H_U32(pUnion->CE.cbData.be), RT_LE2H_U32(pUnion->CE.cbData.le))); + else if (RT_BE2H_U32(pUnion->CE.offData.be) != RT_LE2H_U32(pUnion->CE.offData.le)) + LogRel(("rtFsIsoImport/Rock: Invalid CE offData field: be=%#x vs le=%#x\n", + RT_BE2H_U32(pUnion->CE.offData.be), RT_LE2H_U32(pUnion->CE.offData.le))); + else if (!fContinuationRecord) + { + uint64_t offData = ISO9660_GET_ENDIAN(&pUnion->CE.offBlock) * (uint64_t)ISO9660_SECTOR_SIZE; + offData += ISO9660_GET_ENDIAN(&pUnion->CE.offData); + uint32_t cbData = ISO9660_GET_ENDIAN(&pUnion->CE.cbData); + if (cbData <= sizeof(pThis->abRockBuf) - (uint32_t)(offData & ISO9660_SECTOR_OFFSET_MASK)) + { + AssertCompile(sizeof(pThis->abRockBuf) == ISO9660_SECTOR_SIZE); + uint64_t offDataBlock = offData & ~(uint64_t)ISO9660_SECTOR_OFFSET_MASK; + if (pThis->offRockBuf == offDataBlock) + rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge(pThis, pObjInfo, + &pThis->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK], + cbData, fUnicode, fIsFirstDirRec, + true /*fContinuationRecord*/); + else + { + int rc = RTVfsFileReadAt(pThis->hSrcFile, offDataBlock, pThis->abRockBuf, sizeof(pThis->abRockBuf), NULL); + if (RT_SUCCESS(rc)) + rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge(pThis, pObjInfo, + &pThis->abRockBuf[offData & ISO9660_SECTOR_OFFSET_MASK], + cbData, fUnicode, fIsFirstDirRec, + true /*fContinuationRecord*/); + else + LogRel(("rtFsIsoImport/Rock: Error reading continuation record at %#RX64: %Rrc\n", + offDataBlock, rc)); + } + } + else + LogRel(("rtFsIsoImport/Rock: continuation record isn't within a sector! offData=%#RX64 cbData=%#RX32\n", + cbData, offData)); + } + else + LogRel(("rtFsIsoImport/Rock: nested continuation record!\n")); + break; + } + + case MAKE_SIG(ISO9660SUSPSP_SIG1, ISO9660SUSPSP_SIG2): /* SP */ + if ( pUnion->Hdr.cbEntry != ISO9660SUSPSP_LEN + || pUnion->Hdr.bVersion != ISO9660SUSPSP_VER + || pUnion->SP.bCheck1 != ISO9660SUSPSP_CHECK1 + || pUnion->SP.bCheck2 != ISO9660SUSPSP_CHECK2 + || pUnion->SP.cbSkip > UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1])) + LogRel(("rtFsIsoImport/Rock: Malformed 'SP' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x), bCheck1=%#x (vs %#x), bCheck2=%#x (vs %#x), cbSkip=%#x (vs max %#x)\n", + pUnion->Hdr.cbEntry, ISO9660SUSPSP_LEN, pUnion->Hdr.bVersion, ISO9660SUSPSP_VER, + pUnion->SP.bCheck1, ISO9660SUSPSP_CHECK1, pUnion->SP.bCheck2, ISO9660SUSPSP_CHECK2, + pUnion->SP.cbSkip, UINT8_MAX - RT_UOFFSETOF(ISO9660DIRREC, achFileId[1]) )); + else if (!fIsFirstDirRec) + LogRel(("rtFsIsoImport/Rock: Ignorining 'SP' entry in non-root directory record\n")); + else if (pThis->fSuspSeenSP) + LogRel(("rtFsIsoImport/Rock: Ignorining additional 'SP' entry\n")); + else + { + pThis->offSuspSkip = pUnion->SP.cbSkip; + if (pUnion->SP.cbSkip != 0) + LogRel(("rtFsIsoImport/Rock: SP: cbSkip=%#x\n", pUnion->SP.cbSkip)); + } + break; + + case MAKE_SIG(ISO9660SUSPER_SIG1, ISO9660SUSPER_SIG2): /* ER */ + if ( pUnion->Hdr.cbEntry > RT_UOFFSETOF(ISO9660SUSPER, achPayload) + (uint32_t)pUnion->ER.cchIdentifier + + (uint32_t)pUnion->ER.cchDescription + (uint32_t)pUnion->ER.cchSource + || pUnion->Hdr.bVersion != ISO9660SUSPER_VER) + LogRel(("rtFsIsoImport/Rock: Malformed 'ER' entry: cbEntry=%#x bVersion=%#x (vs %#x) cchIdentifier=%#x cchDescription=%#x cchSource=%#x\n", + pUnion->Hdr.cbEntry, pUnion->Hdr.bVersion, ISO9660SUSPER_VER, pUnion->ER.cchIdentifier, + pUnion->ER.cchDescription, pUnion->ER.cchSource)); + else if (!fIsFirstDirRec) + LogRel(("rtFsIsoImport/Rock: Ignorining 'ER' entry in non-root directory record\n")); + else if ( pUnion->ER.bVersion == 1 /* RRIP detection */ + && ( (pUnion->ER.cchIdentifier >= 4 && strncmp(pUnion->ER.achPayload, ISO9660_RRIP_ID, 4 /*RRIP*/) == 0) + || (pUnion->ER.cchIdentifier >= 10 && strncmp(pUnion->ER.achPayload, RT_STR_TUPLE(ISO9660_RRIP_1_12_ID)) == 0) )) + { + LogRel(("rtFsIsoImport/Rock: Rock Ridge 'ER' entry: v%u id='%.*s' desc='%.*s' source='%.*s'\n", + pUnion->ER.bVersion, pUnion->ER.cchIdentifier, pUnion->ER.achPayload, + pUnion->ER.cchDescription, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier], + pUnion->ER.cchSource, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier + pUnion->ER.cchDescription])); + if (!fUnicode) + { + int rc = RTFsIsoMakerSetRockRidgeLevel(pThis->hIsoMaker, 2); + if (RT_FAILURE(rc)) + LogRel(("rtFsIsoImport/Rock: RTFsIsoMakerSetRockRidgeLevel(,2) failed: %Rrc\n", rc)); + } + else + { + int rc = RTFsIsoMakerSetJolietRockRidgeLevel(pThis->hIsoMaker, 2); + if (RT_FAILURE(rc)) + LogRel(("rtFsIsoImport/Rock: RTFsIsoMakerSetJolietRockRidgeLevel(,2) failed: %Rrc\n", rc)); + } + } + else + LogRel(("rtFsIsoImport/Rock: Unknown extension in 'ER' entry: v%u id='%.*s' desc='%.*s' source='%.*s'\n", + pUnion->ER.bVersion, pUnion->ER.cchIdentifier, pUnion->ER.achPayload, + pUnion->ER.cchDescription, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier], + pUnion->ER.cchSource, &pUnion->ER.achPayload[pUnion->ER.cchIdentifier + pUnion->ER.cchDescription])); + break; + + case MAKE_SIG(ISO9660SUSPPD_SIG1, ISO9660SUSPPD_SIG2): /* PD - ignored */ + case MAKE_SIG(ISO9660SUSPST_SIG1, ISO9660SUSPST_SIG2): /* ST - ignore for now */ + case MAKE_SIG(ISO9660SUSPES_SIG1, ISO9660SUSPES_SIG2): /* ES - ignore for now */ + break; + + /* + * Rock ridge interchange protocol entries. + */ + case MAKE_SIG(ISO9660RRIPRR_SIG1, ISO9660RRIPRR_SIG2): /* RR */ + if ( pUnion->RR.Hdr.cbEntry != ISO9660RRIPRR_LEN + || pUnion->RR.Hdr.bVersion != ISO9660RRIPRR_VER) + LogRel(("rtFsIsoImport/Rock: Malformed 'RR' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x\n", + pUnion->RR.Hdr.cbEntry, ISO9660RRIPRR_LEN, pUnion->RR.Hdr.bVersion, ISO9660RRIPRR_VER, pUnion->RR.fFlags)); + /* else: ignore it */ + break; + + case MAKE_SIG(ISO9660RRIPPX_SIG1, ISO9660RRIPPX_SIG2): /* PX */ + if ( ( pUnion->PX.Hdr.cbEntry != ISO9660RRIPPX_LEN + && pUnion->PX.Hdr.cbEntry != ISO9660RRIPPX_LEN_NO_INODE) + || pUnion->PX.Hdr.bVersion != ISO9660RRIPPX_VER + || RT_BE2H_U32(pUnion->PX.fMode.be) != RT_LE2H_U32(pUnion->PX.fMode.le) + || RT_BE2H_U32(pUnion->PX.cHardlinks.be) != RT_LE2H_U32(pUnion->PX.cHardlinks.le) + || RT_BE2H_U32(pUnion->PX.uid.be) != RT_LE2H_U32(pUnion->PX.uid.le) + || RT_BE2H_U32(pUnion->PX.gid.be) != RT_LE2H_U32(pUnion->PX.gid.le) + || ( pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN + && RT_BE2H_U32(pUnion->PX.INode.be) != RT_LE2H_U32(pUnion->PX.INode.le)) ) + LogRel(("rtFsIsoImport/Rock: Malformed 'PX' entry: cbEntry=%#x (vs %#x or %#x), bVersion=%#x (vs %#x) fMode=%#x/%#x cHardlinks=%#x/%#x uid=%#x/%#x gid=%#x/%#x inode=%#x/%#x\n", + pUnion->PX.Hdr.cbEntry, ISO9660RRIPPX_LEN, ISO9660RRIPPX_LEN_NO_INODE, + pUnion->PX.Hdr.bVersion, ISO9660RRIPPX_VER, + RT_BE2H_U32(pUnion->PX.fMode.be), RT_LE2H_U32(pUnion->PX.fMode.le), + RT_BE2H_U32(pUnion->PX.cHardlinks.be), RT_LE2H_U32(pUnion->PX.cHardlinks.le), + RT_BE2H_U32(pUnion->PX.uid.be), RT_LE2H_U32(pUnion->PX.uid.le), + RT_BE2H_U32(pUnion->PX.gid.be), RT_LE2H_U32(pUnion->PX.gid.le), + pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN ? RT_BE2H_U32(pUnion->PX.INode.be) : 0, + pUnion->PX.Hdr.cbEntry == ISO9660RRIPPX_LEN ? RT_LE2H_U32(pUnion->PX.INode.le) : 0 )); + else + { + if (RTFS_IS_DIRECTORY(ISO9660_GET_ENDIAN(&pUnion->PX.fMode)) == RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode)) + pObjInfo->Attr.fMode = ISO9660_GET_ENDIAN(&pUnion->PX.fMode); + else + LogRel(("rtFsIsoImport/Rock: 'PX' entry changes directory-ness: fMode=%#x, existing %#x; ignored\n", + ISO9660_GET_ENDIAN(&pUnion->PX.fMode), pObjInfo->Attr.fMode)); + pObjInfo->Attr.u.Unix.cHardlinks = ISO9660_GET_ENDIAN(&pUnion->PX.cHardlinks); + pObjInfo->Attr.u.Unix.uid = ISO9660_GET_ENDIAN(&pUnion->PX.uid); + pObjInfo->Attr.u.Unix.gid = ISO9660_GET_ENDIAN(&pUnion->PX.gid); + /* ignore inode */ + } + break; + + case MAKE_SIG(ISO9660RRIPPN_SIG1, ISO9660RRIPPN_SIG2): /* PN */ + if ( pUnion->PN.Hdr.cbEntry != ISO9660RRIPPN_LEN + || pUnion->PN.Hdr.bVersion != ISO9660RRIPPN_VER + || RT_BE2H_U32(pUnion->PN.Major.be) != RT_LE2H_U32(pUnion->PN.Major.le) + || RT_BE2H_U32(pUnion->PN.Minor.be) != RT_LE2H_U32(pUnion->PN.Minor.le)) + LogRel(("rtFsIsoImport/Rock: Malformed 'PN' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) Major=%#x/%#x Minor=%#x/%#x\n", + pUnion->PN.Hdr.cbEntry, ISO9660RRIPPN_LEN, pUnion->PN.Hdr.bVersion, ISO9660RRIPPN_VER, + RT_BE2H_U32(pUnion->PN.Major.be), RT_LE2H_U32(pUnion->PN.Major.le), + RT_BE2H_U32(pUnion->PN.Minor.be), RT_LE2H_U32(pUnion->PN.Minor.le) )); + else if (RTFS_IS_DIRECTORY(pObjInfo->Attr.fMode)) + LogRel(("rtFsIsoImport/Rock: Ignorning 'PN' entry for directory (%#x/%#x)\n", + ISO9660_GET_ENDIAN(&pUnion->PN.Major), ISO9660_GET_ENDIAN(&pUnion->PN.Minor) )); + else + pObjInfo->Attr.u.Unix.Device = RTDEV_MAKE(ISO9660_GET_ENDIAN(&pUnion->PN.Major), + ISO9660_GET_ENDIAN(&pUnion->PN.Minor)); + break; + + case MAKE_SIG(ISO9660RRIPTF_SIG1, ISO9660RRIPTF_SIG2): /* TF */ + if ( pUnion->TF.Hdr.bVersion != ISO9660RRIPTF_VER + || pUnion->TF.Hdr.cbEntry < Iso9660RripTfCalcLength(pUnion->TF.fFlags)) + LogRel(("rtFsIsoImport/Rock: Malformed 'TF' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x\n", + pUnion->TF.Hdr.cbEntry, Iso9660RripTfCalcLength(pUnion->TF.fFlags), + pUnion->TF.Hdr.bVersion, ISO9660RRIPTF_VER, RT_BE2H_U32(pUnion->TF.fFlags) )); + else if (!(pUnion->TF.fFlags & ISO9660RRIPTF_F_LONG_FORM)) + { + PCISO9660RECTIMESTAMP pTimestamp = (PCISO9660RECTIMESTAMP)&pUnion->TF.abPayload[0]; + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_BIRTH) + { + rtFsIsoImpIso9660RecDateTime2TimeSpec(&pObjInfo->BirthTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_MODIFY) + { + rtFsIsoImpIso9660RecDateTime2TimeSpec(&pObjInfo->ModificationTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_ACCESS) + { + rtFsIsoImpIso9660RecDateTime2TimeSpec(&pObjInfo->AccessTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_CHANGE) + { + rtFsIsoImpIso9660RecDateTime2TimeSpec(&pObjInfo->ChangeTime, pTimestamp); + pTimestamp++; + } + } + else + { + PCISO9660TIMESTAMP pTimestamp = (PCISO9660TIMESTAMP)&pUnion->TF.abPayload[0]; + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_BIRTH) + { + rtFsIsoImpIso9660DateTime2TimeSpecIfValid(&pObjInfo->BirthTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_MODIFY) + { + rtFsIsoImpIso9660DateTime2TimeSpecIfValid(&pObjInfo->ModificationTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_ACCESS) + { + rtFsIsoImpIso9660DateTime2TimeSpecIfValid(&pObjInfo->AccessTime, pTimestamp); + pTimestamp++; + } + if (pUnion->TF.fFlags & ISO9660RRIPTF_F_CHANGE) + { + rtFsIsoImpIso9660DateTime2TimeSpecIfValid(&pObjInfo->ChangeTime, pTimestamp); + pTimestamp++; + } + } + break; + + case MAKE_SIG(ISO9660RRIPSF_SIG1, ISO9660RRIPSF_SIG2): /* SF */ + LogRel(("rtFsIsoImport/Rock: Sparse file support not yet implemented!\n")); + break; + + case MAKE_SIG(ISO9660RRIPSL_SIG1, ISO9660RRIPSL_SIG2): /* SL */ + if ( pUnion->SL.Hdr.bVersion != ISO9660RRIPSL_VER + || pUnion->SL.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2]) + || (pUnion->SL.fFlags & ~ISO9660RRIP_SL_F_CONTINUE) + || (pUnion->SL.abComponents[0] & ISO9660RRIP_SL_C_RESERVED_MASK) ) + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x comp[0].fFlags=%#x\n", + pUnion->SL.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPSL, abComponents[2]), + pUnion->SL.Hdr.bVersion, ISO9660RRIPSL_VER, pUnion->SL.fFlags, pUnion->SL.abComponents[0])); + else if (pThis->fSeenLastSL) + LogRel(("rtFsIsoImport/Rock: Unexpected 'SL!' entry\n")); + else + { + pThis->fSeenLastSL = !(pUnion->SL.fFlags & ISO9660RRIP_SL_F_CONTINUE); /* used in loop */ + + size_t offDst = strlen(pThis->szRockSymlinkTargetBuf); + uint8_t const *pbSrc = &pUnion->SL.abComponents[0]; + uint8_t cbSrcLeft = pUnion->SL.Hdr.cbEntry - RT_UOFFSETOF(ISO9660RRIPSL, abComponents); + while (cbSrcLeft >= 2) + { + uint8_t const fFlags = pbSrc[0]; + uint8_t cchCopy = pbSrc[1]; + uint8_t const cbSkip = cchCopy + 2; + if (cbSkip > cbSrcLeft) + { + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' component: component flags=%#x, component length+2=%#x vs %#x left\n", + fFlags, cbSkip, cbSrcLeft)); + break; + } + + const char *pszCopy; + switch (fFlags & ~ISO9660RRIP_SL_C_CONTINUE) + { + case 0: + pszCopy = (const char *)&pbSrc[2]; + break; + + case ISO9660RRIP_SL_C_CURRENT: + if (cchCopy != 0) + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' component: CURRENT + %u bytes, ignoring bytes\n", cchCopy)); + pszCopy = "."; + cchCopy = 1; + break; + + case ISO9660RRIP_SL_C_PARENT: + if (cchCopy != 0) + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' component: PARENT + %u bytes, ignoring bytes\n", cchCopy)); + pszCopy = ".."; + cchCopy = 2; + break; + + case ISO9660RRIP_SL_C_ROOT: + if (cchCopy != 0) + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' component: ROOT + %u bytes, ignoring bytes\n", cchCopy)); + pszCopy = "/"; + cchCopy = 1; + break; + + default: + LogRel(("rtFsIsoImport/Rock: Malformed 'SL' component: component flags=%#x (bad), component length=%#x vs %#x left\n", + fFlags, cchCopy, cbSrcLeft)); + pszCopy = NULL; + cchCopy = 0; + break; + } + + if (offDst + cchCopy < sizeof(pThis->szRockSymlinkTargetBuf)) + { + memcpy(&pThis->szRockSymlinkTargetBuf[offDst], pszCopy, cchCopy); + offDst += cchCopy; + } + else + { + LogRel(("rtFsIsoImport/Rock: 'SL' constructs a too long target! '%.*s%.*s'\n", + offDst, pThis->szRockSymlinkTargetBuf, cchCopy, pszCopy)); + memcpy(&pThis->szRockSymlinkTargetBuf[offDst], pszCopy, + sizeof(pThis->szRockSymlinkTargetBuf) - offDst - 1); + offDst = sizeof(pThis->szRockSymlinkTargetBuf) - 1; + break; + } + + /* Advance */ + pbSrc += cbSkip; + cbSrcLeft -= cbSkip; + + /* Append slash if appropriate. */ + if ( !(fFlags & ISO9660RRIP_SL_C_CONTINUE) + && (cbSrcLeft >= 2 || !pThis->fSeenLastSL) ) + { + if (offDst + 1 < sizeof(pThis->szRockSymlinkTargetBuf)) + pThis->szRockSymlinkTargetBuf[offDst++] = '/'; + else + { + LogRel(("rtFsIsoImport/Rock: 'SL' constructs a too long target! '%.*s/'\n", + offDst, pThis->szRockSymlinkTargetBuf)); + break; + } + } + } + pThis->szRockSymlinkTargetBuf[offDst] = '\0'; + + /* Purge the encoding as we don't want invalid UTF-8 floating around. */ + RTStrPurgeEncoding(pThis->szRockSymlinkTargetBuf); + } + break; + + case MAKE_SIG(ISO9660RRIPNM_SIG1, ISO9660RRIPNM_SIG2): /* NM */ + if ( pUnion->NM.Hdr.bVersion != ISO9660RRIPNM_VER + || pUnion->NM.Hdr.cbEntry < RT_UOFFSETOF(ISO9660RRIPNM, achName) + || (pUnion->NM.fFlags & ISO9660RRIP_NM_F_RESERVED_MASK) ) + LogRel(("rtFsIsoImport/Rock: Malformed 'NM' entry: cbEntry=%#x (vs %#x), bVersion=%#x (vs %#x) fFlags=%#x %.*Rhxs\n", + pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName), + pUnion->NM.Hdr.bVersion, ISO9660RRIPNM_VER, pUnion->NM.fFlags, + pUnion->NM.Hdr.cbEntry - RT_MIN(pUnion->NM.Hdr.cbEntry, RT_UOFFSETOF(ISO9660RRIPNM, achName)), + &pUnion->NM.achName[0] )); + else if (pThis->fSeenLastNM) + LogRel(("rtFsIsoImport/Rock: Unexpected 'NM' entry!\n")); + else + { + pThis->fSeenLastNM = !(pUnion->NM.fFlags & ISO9660RRIP_NM_F_CONTINUE); + + uint8_t const cchName = pUnion->NM.Hdr.cbEntry - (uint8_t)RT_UOFFSETOF(ISO9660RRIPNM, achName); + if (pUnion->NM.fFlags & (ISO9660RRIP_NM_F_CURRENT | ISO9660RRIP_NM_F_PARENT)) + { + if (cchName == 0 && pThis->szRockNameBuf[0] == '\0') + Log(("rtFsIsoImport/Rock: Ignoring 'NM' entry for '.' and '..'\n")); + else + LogRel(("rtFsIsoImport/Rock: Ignoring malformed 'NM' using '.' or '..': fFlags=%#x cchName=%#x %.*Rhxs; szRockNameBuf='%s'\n", + pUnion->NM.fFlags, cchName, cchName, pUnion->NM.achName, pThis->szRockNameBuf)); + pThis->szRockNameBuf[0] = '\0'; + pThis->fSeenLastNM = true; + } + else + { + size_t offDst = strlen(pThis->szRockNameBuf); + if (offDst + cchName < sizeof(pThis->szRockNameBuf)) + { + memcpy(&pThis->szRockNameBuf[offDst], pUnion->NM.achName, cchName); + pThis->szRockNameBuf[offDst + cchName] = '\0'; + + /* Purge the encoding as we don't want invalid UTF-8 floating around. */ + RTStrPurgeEncoding(pThis->szRockSymlinkTargetBuf); + } + else + { + LogRel(("rtFsIsoImport/Rock: 'NM' constructs a too long name, ignoring it all: '%s%.*s'\n", + pThis->szRockNameBuf, cchName, pUnion->NM.achName)); + pThis->szRockNameBuf[0] = '\0'; + pThis->fSeenLastNM = true; + } + } + } + break; + + case MAKE_SIG(ISO9660RRIPCL_SIG1, ISO9660RRIPCL_SIG2): /* CL - just warn for now. */ + case MAKE_SIG(ISO9660RRIPPL_SIG1, ISO9660RRIPPL_SIG2): /* PL - just warn for now. */ + case MAKE_SIG(ISO9660RRIPRE_SIG1, ISO9660RRIPRE_SIG2): /* RE - just warn for now. */ + LogRel(("rtFsIsoImport/Rock: Ignorning directory relocation entry '%c%c'!\n", pUnion->Hdr.bSig1, pUnion->Hdr.bSig2)); + break; + + default: + LogRel(("rtFsIsoImport/Rock: Unknown SUSP entry: %#x %#x, %#x bytes, v%u\n", + pUnion->Hdr.bSig1, pUnion->Hdr.bSig2, pUnion->Hdr.cbEntry, pUnion->Hdr.bVersion)); + break; +#undef MAKE_SIG + } + } +} + + +/** + * Deals with the special '.' entry in the root directory. + * + * @returns IPRT status code. + * @param pThis The import instance. + * @param pDirRec The root directory record. + * @param fUnicode Indicates which namespace we're working on. + */ +static int rtFsIsoImportProcessIso9660TreeWorkerDoRockForRoot(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, bool fUnicode) +{ + uint8_t const cbSys = pDirRec->cbDirRec - RT_UOFFSETOF(ISO9660DIRREC, achFileId) + - pDirRec->bFileIdLength - !(pDirRec->bFileIdLength & 1); + uint8_t const * const pbSys = (uint8_t const *)&pDirRec->achFileId[pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1)]; + if (cbSys > 4) + { + RTFSOBJINFO ObjInfo; + ObjInfo.cbObject = 0; + ObjInfo.cbAllocated = 0; + rtFsIsoImpIso9660RecDateTime2TimeSpec(&ObjInfo.AccessTime, &pDirRec->RecTime); + ObjInfo.ModificationTime = ObjInfo.AccessTime; + ObjInfo.ChangeTime = ObjInfo.AccessTime; + ObjInfo.BirthTime = ObjInfo.AccessTime; + ObjInfo.Attr.fMode = RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | 0555; + ObjInfo.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + ObjInfo.Attr.u.Unix.uid = NIL_RTUID; + ObjInfo.Attr.u.Unix.gid = NIL_RTGID; + ObjInfo.Attr.u.Unix.cHardlinks = 2; + ObjInfo.Attr.u.Unix.INodeIdDevice = 0; + ObjInfo.Attr.u.Unix.INodeId = 0; + ObjInfo.Attr.u.Unix.fFlags = 0; + ObjInfo.Attr.u.Unix.GenerationId = 0; + ObjInfo.Attr.u.Unix.Device = 0; + + rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge(pThis, &ObjInfo, pbSys, cbSys, fUnicode, true /*fIsFirstDirRec*/, + false /*fContinuationRecord*/); + /** @todo Update root dir attribs. Need API. */ + } + return VINF_SUCCESS; +} + + +/** + * Validates a directory record. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param pDirRec The directory record to validate. + * @param cbMax The maximum size. + */ +static int rtFsIsoImportValidateDirRec(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, uint32_t cbMax) +{ + /* + * Validate dual fields. + */ + if (RT_LE2H_U32(pDirRec->cbData.le) != RT_BE2H_U32(pDirRec->cbData.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC, + "Invalid dir rec size field: {%#RX32,%#RX32}", + RT_BE2H_U32(pDirRec->cbData.be), RT_LE2H_U32(pDirRec->cbData.le)); + + if (RT_LE2H_U32(pDirRec->offExtent.le) != RT_BE2H_U32(pDirRec->offExtent.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC, + "Invalid dir rec extent field: {%#RX32,%#RX32}", + RT_BE2H_U32(pDirRec->offExtent.be), RT_LE2H_U32(pDirRec->offExtent.le)); + + if (RT_LE2H_U16(pDirRec->VolumeSeqNo.le) != RT_BE2H_U16(pDirRec->VolumeSeqNo.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC, + "Invalid dir rec volume sequence ID field: {%#RX16,%#RX16}", + RT_BE2H_U16(pDirRec->VolumeSeqNo.be), RT_LE2H_U16(pDirRec->VolumeSeqNo.le)); + + /* + * Check values. + */ + if (ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo) != pThis->idPrimaryVol) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_DIR_REC_VOLUME_SEQ_NO, + "Expected dir rec to have same volume sequence number as primary volume: %#x, expected %#x", + ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo), pThis->idPrimaryVol); + + if (ISO9660_GET_ENDIAN(&pDirRec->offExtent) >= pThis->cBlocksInPrimaryVolumeSpace) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_DIR_REC_EXTENT_OUT_OF_BOUNDS, + "Invalid dir rec extent: %#RX32, max %#RX32", + ISO9660_GET_ENDIAN(&pDirRec->offExtent), pThis->cBlocksInPrimaryVolumeSpace); + + if (pDirRec->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC_LENGTH, + "Dir record size is too small: %#x (min %#x)", + pDirRec->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId) + pDirRec->bFileIdLength); + if (pDirRec->cbDirRec > cbMax) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_DIR_REC_LENGTH, + "Dir record size is too big: %#x (max %#x)", pDirRec->cbDirRec, cbMax); + + if ( (pDirRec->fFileFlags & (ISO9660_FILE_FLAGS_MULTI_EXTENT | ISO9660_FILE_FLAGS_DIRECTORY)) + == (ISO9660_FILE_FLAGS_MULTI_EXTENT | ISO9660_FILE_FLAGS_DIRECTORY)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_DIR_WITH_MORE_EXTENTS, + "Multi-extent directories are not supported (cbData=%#RX32 offExtent=%#RX32)", + ISO9660_GET_ENDIAN(&pDirRec->cbData), ISO9660_GET_ENDIAN(&pDirRec->offExtent)); + + return VINF_SUCCESS; +} + + +/** + * Validates a dot or dot-dot directory record. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param pDirRec The dot directory record to validate. + * @param cbMax The maximum size. + * @param bName The name byte (0x00: '.', 0x01: '..'). + */ +static int rtFsIsoImportValidateDotDirRec(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec, uint32_t cbMax, uint8_t bName) +{ + int rc = rtFsIsoImportValidateDirRec(pThis, pDirRec, cbMax); + if (RT_SUCCESS(rc)) + { + if (pDirRec->bFileIdLength != 1) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_DOT_DIR_REC_BAD_NAME_LENGTH, + "Invalid dot dir rec file id length: %u", pDirRec->bFileIdLength); + if ((uint8_t)pDirRec->achFileId[0] != bName) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_DOT_DIR_REC_BAD_NAME, + "Invalid dot dir rec file id: %#x, expected %#x", pDirRec->achFileId[0], bName); + } + return rc; +} + + +/** + * rtFsIsoImportProcessIso9660TreeWorker helper that reads more data. + * + * @returns IPRT status code. + * @param pThis The importer instance. + * @param ppDirRec Pointer to the directory record pointer (in/out). + * @param pcbChunk Pointer to the cbChunk variable (in/out). + * @param pcbDir Pointer to the cbDir variable (in/out). This indicates + * how much we've left to read from the directory. + * @param poffNext Pointer to the offNext variable (in/out). This + * indicates where the next chunk of directory data is in + * the input file. + */ +static int rtFsIsoImportProcessIso9660TreeWorkerReadMore(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC *ppDirRec, + uint32_t *pcbChunk, uint32_t *pcbDir, uint64_t *poffNext) +{ + uint32_t cbChunk = *pcbChunk; + *ppDirRec = (PCISO9660DIRREC)memmove(&pThis->abBuf[ISO9660_SECTOR_SIZE - cbChunk], *ppDirRec, cbChunk); + + Assert(!(*poffNext & (ISO9660_SECTOR_SIZE - 1))); + uint32_t cbToRead = RT_MIN(*pcbDir, sizeof(pThis->abBuf) - ISO9660_SECTOR_SIZE); + int rc = RTVfsFileReadAt(pThis->hSrcFile, *poffNext, &pThis->abBuf[ISO9660_SECTOR_SIZE], cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + Log3(("rtFsIsoImportProcessIso9660TreeWorker: Read %#zx more bytes @%#RX64, now got @%#RX64 LB %#RX32\n", + cbToRead, *poffNext, *poffNext - cbChunk, cbChunk + cbToRead)); + *poffNext += cbToRead; + *pcbDir -= cbToRead; + *pcbChunk = cbChunk + cbToRead; + return VINF_SUCCESS; + } + return rtFsIsoImpError(pThis, rc, "Error reading %#RX32 bytes at %#RX64 (dir): %Rrc", *poffNext, cbToRead); +} + + +/** + * rtFsIsoImportProcessIso9660TreeWorker helper that deals with skipping to the + * next sector when cbDirRec is zero. + * + * @returns IPRT status code. + * @retval VERR_NO_MORE_FILES when we reaches the end of the directory. + * @param pThis The importer instance. + * @param ppDirRec Pointer to the directory record pointer (in/out). + * @param pcbChunk Pointer to the cbChunk variable (in/out). Indicates how + * much we've left to process starting and pDirRec. + * @param pcbDir Pointer to the cbDir variable (in/out). This indicates + * how much we've left to read from the directory. + * @param poffNext Pointer to the offNext variable (in/out). This + * indicates where the next chunk of directory data is in + * the input file. + */ +static int rtFsIsoImportProcessIso9660TreeWorkerHandleZeroSizedDirRec(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC *ppDirRec, + uint32_t *pcbChunk, uint32_t *pcbDir, uint64_t *poffNext) +{ + uint32_t cbChunk = *pcbChunk; + uint64_t offChunk = *poffNext - cbChunk; + uint32_t cbSkip = ISO9660_SECTOR_SIZE - ((uint32_t)offChunk & (ISO9660_SECTOR_SIZE - 1)); + if (cbSkip < cbChunk) + { + *ppDirRec = (PCISO9660DIRREC)((uintptr_t)*ppDirRec + cbSkip); + *pcbChunk = cbChunk -= cbSkip; + if ( cbChunk > UINT8_MAX + || *pcbDir == 0) + { + Log3(("rtFsIsoImportProcessIso9660TreeWorker: cbDirRec=0 --> jumped %#RX32 to @%#RX64 LB %#RX32\n", + cbSkip, *poffNext - cbChunk, cbChunk)); + return VINF_SUCCESS; + } + Log3(("rtFsIsoImportProcessIso9660TreeWorker: cbDirRec=0 --> jumped %#RX32 to @%#RX64 LB %#RX32, but needs to read more\n", + cbSkip, *poffNext - cbChunk, cbChunk)); + return rtFsIsoImportProcessIso9660TreeWorkerReadMore(pThis, ppDirRec, pcbChunk, pcbDir, poffNext); + } + + /* ASSUMES we're working in multiples of sectors! */ + if (*pcbDir == 0) + { + *pcbChunk = 0; + return VERR_NO_MORE_FILES; + } + + /* End of chunk, read the next sectors. */ + Assert(!(*poffNext & (ISO9660_SECTOR_SIZE - 1))); + uint32_t cbToRead = RT_MIN(*pcbDir, sizeof(pThis->abBuf)); + int rc = RTVfsFileReadAt(pThis->hSrcFile, *poffNext, pThis->abBuf, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + Log3(("rtFsIsoImportProcessIso9660TreeWorker: cbDirRec=0 --> Read %#zx more bytes @%#RX64, now got @%#RX64 LB %#RX32\n", + cbToRead, *poffNext, *poffNext - cbChunk, cbChunk + cbToRead)); + *poffNext += cbToRead; + *pcbDir -= cbToRead; + *pcbChunk = cbChunk + cbToRead; + *ppDirRec = (PCISO9660DIRREC)&pThis->abBuf[0]; + return VINF_SUCCESS; + } + return rtFsIsoImpError(pThis, rc, "Error reading %#RX32 bytes at %#RX64 (dir): %Rrc", *poffNext, cbToRead); +} + + +/** + * Deals with a single directory. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param idxDir The configuration index for the directory. + * @param offDirBlock The offset of the directory data. + * @param cbDir The size of the directory data. + * @param cDepth The depth of the directory. + * @param fUnicode Set if it's a unicode (UTF-16BE) encoded + * directory. + * @param pTodoList The todo-list to add sub-directories to. + */ +static int rtFsIsoImportProcessIso9660TreeWorker(PRTFSISOMKIMPORTER pThis, uint32_t idxDir, + uint32_t offDirBlock, uint32_t cbDir, uint8_t cDepth, bool fUnicode, + PRTLISTANCHOR pTodoList) +{ + /* + * Restrict the depth to try avoid loops. + */ + if (cDepth > RTFSISOMK_IMPORT_MAX_DEPTH) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_TOO_DEEP_DIR_TREE, "Dir at %#x LB %#x is too deep", offDirBlock, cbDir); + + /* + * Read the first chunk into the big buffer. + */ + uint32_t cbChunk = RT_MIN(cbDir, sizeof(pThis->abBuf)); + uint64_t offNext = (uint64_t)offDirBlock * ISO9660_SECTOR_SIZE; + int rc = RTVfsFileReadAt(pThis->hSrcFile, offNext, pThis->abBuf, cbChunk, NULL); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "Error reading directory at %#RX64 (%#RX32 / %#RX32): %Rrc", offNext, cbChunk, cbDir); + + cbDir -= cbChunk; + offNext += cbChunk; + + /* + * Skip the current and parent directory entries. + */ + PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pThis->abBuf[0]; + rc = rtFsIsoImportValidateDotDirRec(pThis, pDirRec, cbChunk, 0x00); + if (RT_FAILURE(rc)) + return rc; + if ( cDepth == 0 + && !(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_ROCK_RIDGE) + && pDirRec->cbDirRec > RT_UOFFSETOF(ISO9660DIRREC, achFileId[1])) + { + rc = rtFsIsoImportProcessIso9660TreeWorkerDoRockForRoot(pThis, pDirRec, fUnicode); + if (RT_FAILURE(rc)) + return rc; + } + + cbChunk -= pDirRec->cbDirRec; + pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + pDirRec->cbDirRec); + rc = rtFsIsoImportValidateDotDirRec(pThis, pDirRec, cbChunk, 0x01); + if (RT_FAILURE(rc)) + return rc; + + cbChunk -= pDirRec->cbDirRec; + pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + pDirRec->cbDirRec); + + /* + * Work our way thru all the directory records. + */ + Log3(("rtFsIsoImportProcessIso9660TreeWorker: Starting at @%#RX64 LB %#RX32 (out of %#RX32) in %#x\n", + offNext - cbChunk, cbChunk, cbChunk + cbDir, idxDir)); + const uint32_t fNamespace = fUnicode ? RTFSISOMAKER_NAMESPACE_JOLIET : RTFSISOMAKER_NAMESPACE_ISO_9660; + while ( cbChunk > 0 + || cbDir > 0) + { + /* + * Do we need to read some more? + */ + if ( cbChunk > UINT8_MAX + || cbDir == 0) + { /* No, we don't. */ } + else + { + rc = rtFsIsoImportProcessIso9660TreeWorkerReadMore(pThis, &pDirRec, &cbChunk, &cbDir, &offNext); + if (RT_FAILURE(rc)) + return rc; + } + + /* If null length, skip to the next sector. May have to read some then. */ + if (pDirRec->cbDirRec != 0) + { /* likely */ } + else + { + rc = rtFsIsoImportProcessIso9660TreeWorkerHandleZeroSizedDirRec(pThis, &pDirRec, &cbChunk, &cbDir, &offNext); + if (RT_FAILURE(rc)) + { + if (rc == VERR_NO_MORE_FILES) + break; + return rc; + } + if (pDirRec->cbDirRec == 0) + continue; + } + + /* + * Validate the directory record. Give up if not valid since we're + * likely to get error with subsequent record too. + */ + uint8_t const cbSys = pDirRec->cbDirRec - RT_UOFFSETOF(ISO9660DIRREC, achFileId) + - pDirRec->bFileIdLength - !(pDirRec->bFileIdLength & 1); + uint8_t const * const pbSys = (uint8_t const *)&pDirRec->achFileId[pDirRec->bFileIdLength + !(pDirRec->bFileIdLength & 1)]; + Log3(("pDirRec=&abBuf[%#07zx]: @%#010RX64 cb=%#04x ff=%#04x off=%#010RX32 cb=%#010RX32 cbSys=%#x id=%.*Rhxs\n", + (uintptr_t)pDirRec - (uintptr_t)&pThis->abBuf[0], offNext - cbChunk, pDirRec->cbDirRec, pDirRec->fFileFlags, + ISO9660_GET_ENDIAN(&pDirRec->offExtent), ISO9660_GET_ENDIAN(&pDirRec->cbData), cbSys, + pDirRec->bFileIdLength, pDirRec->achFileId)); + rc = rtFsIsoImportValidateDirRec(pThis, pDirRec, cbChunk); + if (RT_FAILURE(rc)) + return rc; + + /* This early calculation of the next record is due to multi-extent + handling further down. */ + uint32_t cbChunkNew = cbChunk - pDirRec->cbDirRec; + PCISO9660DIRREC pDirRecNext = (PCISO9660DIRREC)((uintptr_t)pDirRec + pDirRec->cbDirRec); + + /* Start Collecting object info. */ + RTFSOBJINFO ObjInfo; + ObjInfo.cbObject = ISO9660_GET_ENDIAN(&pDirRec->cbData); + ObjInfo.cbAllocated = ObjInfo.cbObject; + rtFsIsoImpIso9660RecDateTime2TimeSpec(&ObjInfo.AccessTime, &pDirRec->RecTime); + ObjInfo.ModificationTime = ObjInfo.AccessTime; + ObjInfo.ChangeTime = ObjInfo.AccessTime; + ObjInfo.BirthTime = ObjInfo.AccessTime; + ObjInfo.Attr.fMode = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY + ? RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY | 0555 + : RTFS_TYPE_FILE | RTFS_DOS_ARCHIVED | 0444; + ObjInfo.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + ObjInfo.Attr.u.Unix.uid = NIL_RTUID; + ObjInfo.Attr.u.Unix.gid = NIL_RTGID; + ObjInfo.Attr.u.Unix.cHardlinks = 1; + ObjInfo.Attr.u.Unix.INodeIdDevice = 0; + ObjInfo.Attr.u.Unix.INodeId = 0; + ObjInfo.Attr.u.Unix.fFlags = 0; + ObjInfo.Attr.u.Unix.GenerationId = 0; + ObjInfo.Attr.u.Unix.Device = 0; + + /* + * Convert the name into the name buffer (szNameBuf). + */ + if (!fUnicode) + { + memcpy(pThis->szNameBuf, pDirRec->achFileId, pDirRec->bFileIdLength); + pThis->szNameBuf[pDirRec->bFileIdLength] = '\0'; + rc = RTStrValidateEncoding(pThis->szNameBuf); + } + else + { + char *pszDst = pThis->szNameBuf; + rc = RTUtf16BigToUtf8Ex((PRTUTF16)pDirRec->achFileId, pDirRec->bFileIdLength / sizeof(RTUTF16), + &pszDst, sizeof(pThis->szNameBuf), NULL); + } + if (RT_SUCCESS(rc)) + { + /* Drop the version from the name. */ + size_t cchName = strlen(pThis->szNameBuf); + if ( !(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + && cchName > 2 + && RT_C_IS_DIGIT(pThis->szNameBuf[cchName - 1])) + { + uint32_t offName = 2; + while ( offName <= 5 + && offName + 1 < cchName + && RT_C_IS_DIGIT(pThis->szNameBuf[cchName - offName])) + offName++; + if ( offName + 1 < cchName + && pThis->szNameBuf[cchName - offName] == ';') + { + RTStrToUInt32Full(&pThis->szNameBuf[cchName - offName + 1], 10, &ObjInfo.Attr.u.Unix.GenerationId); + pThis->szNameBuf[cchName - offName] = '\0'; + } + } + Log3((" --> name='%s'\n", pThis->szNameBuf)); + + pThis->szRockNameBuf[0] = '\0'; + pThis->szRockSymlinkTargetBuf[0] = '\0'; + if (cbSys > 0 && !(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_ROCK_RIDGE)) + { + pThis->fSeenLastNM = false; + pThis->fSeenLastSL = false; + pThis->szRockNameBuf[0] = '\0'; + pThis->szRockSymlinkTargetBuf[0] = '\0'; + rtFsIsoImportProcessIso9660TreeWorkerParseRockRidge(pThis, &ObjInfo, pbSys, cbSys, fUnicode, + false /*fContinuationRecord*/, false /*fIsFirstDirRec*/); + } + + /* + * Deal with multi-extent files (usually large ones). We currently only + * handle files where the data is in single continuous chunk and only split + * up into multiple directory records because of data type limitations. + */ + uint8_t abDirRecCopy[256]; + uint64_t cbData = ISO9660_GET_ENDIAN(&pDirRec->cbData); + if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)) + { /* likely */ } + else + { + if (cbData & (ISO9660_SECTOR_SIZE - 1)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MISALIGNED_MULTI_EXTENT, + "The size of non-final multi-extent record #0x0 isn't block aligned: %#RX64", cbData); + + /* Make a copy of the first directory record so we don't overwrite + it when reading in more records below. */ + pDirRec = (PCISO9660DIRREC)memcpy(abDirRecCopy, pDirRec, pDirRec->cbDirRec); + + /* Process extent records. */ + uint32_t cDirRecs = 1; + uint32_t offNextBlock = ISO9660_GET_ENDIAN(&pDirRec->offExtent) + + ISO9660_GET_ENDIAN(&pDirRec->cbData) / ISO9660_SECTOR_SIZE; + while ( cbChunkNew > 0 + || cbDir > 0) + { + /* Read more? Skip? */ + if ( cbChunkNew <= UINT8_MAX + && cbDir != 0) + { + rc = rtFsIsoImportProcessIso9660TreeWorkerReadMore(pThis, &pDirRecNext, &cbChunkNew, &cbDir, &offNext); + if (RT_FAILURE(rc)) + return rc; + } + if (pDirRecNext->cbDirRec == 0) + { + rc = rtFsIsoImportProcessIso9660TreeWorkerHandleZeroSizedDirRec(pThis, &pDirRecNext, &cbChunkNew, + &cbDir, &offNext); + if (RT_FAILURE(rc)) + { + if (rc == VERR_NO_MORE_FILES) + break; + return rc; + } + if (pDirRecNext->cbDirRec == 0) + continue; + } + + /* Check the next record. */ + rc = rtFsIsoImportValidateDirRec(pThis, pDirRecNext, cbChunkNew); + if (RT_FAILURE(rc)) + return rc; + if (pDirRecNext->bFileIdLength != pDirRec->bFileIdLength) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MISMATCHING_MULTI_EXTENT_REC, + "Multi-extent record #%#x differs from the first: bFileIdLength is %#x, expected %#x", + cDirRecs, pDirRecNext->bFileIdLength, pDirRec->bFileIdLength); + if (memcmp(pDirRecNext->achFileId, pDirRec->achFileId, pDirRec->bFileIdLength) != 0) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MISMATCHING_MULTI_EXTENT_REC, + "Multi-extent record #%#x differs from the first: achFileId is %.*Rhxs, expected %.*Rhxs", + cDirRecs, pDirRecNext->bFileIdLength, pDirRecNext->achFileId, + pDirRec->bFileIdLength, pDirRec->achFileId); + if (ISO9660_GET_ENDIAN(&pDirRecNext->VolumeSeqNo) != ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MISMATCHING_MULTI_EXTENT_REC, + "Multi-extent record #%#x differs from the first: VolumeSeqNo is %#x, expected %#x", + cDirRecs, ISO9660_GET_ENDIAN(&pDirRecNext->VolumeSeqNo), + ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo)); + if ( (pDirRecNext->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT) + && (ISO9660_GET_ENDIAN(&pDirRecNext->cbData) & (ISO9660_SECTOR_SIZE - 1)) ) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MISALIGNED_MULTI_EXTENT, + "The size of non-final multi-extent record #%#x isn't block aligned: %#RX32", + cDirRecs, ISO9660_GET_ENDIAN(&pDirRecNext->cbData)); + + /* Check that the data is contiguous, then add the data. */ + if (ISO9660_GET_ENDIAN(&pDirRecNext->offExtent) == offNextBlock) + cbData += ISO9660_GET_ENDIAN(&pDirRecNext->cbData); + else + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_NON_CONTIGUOUS_MULTI_EXTENT, + "Multi-extent record #%#x isn't contiguous: offExtent=%#RX32, expected %#RX32", + cDirRecs, ISO9660_GET_ENDIAN(&pDirRecNext->offExtent), offNextBlock); + + /* Advance. */ + cDirRecs++; + bool fDone = !(pDirRecNext->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT); + offNext += ISO9660_GET_ENDIAN(&pDirRecNext->cbData) / ISO9660_SECTOR_SIZE; + cbChunkNew -= pDirRecNext->cbDirRec; + pDirRecNext = (PCISO9660DIRREC)((uintptr_t)pDirRecNext + pDirRecNext->cbDirRec); + if (fDone) + break; + } + } + if (RT_SUCCESS(rc)) + { + /* + * Add the object. + */ + if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + rtFsIsoImportProcessIso9660AddAndNameDirectory(pThis, pDirRec, &ObjInfo, cbData, fNamespace, idxDir, + pThis->szNameBuf, pThis->szRockNameBuf, cDepth + 1, pTodoList); + else if (pThis->szRockSymlinkTargetBuf[0] == '\0') + { + if (strcmp(pThis->szNameBuf, pThis->pszTransTbl) != 0) + rtFsIsoImportProcessIso9660AddAndNameFile(pThis, pDirRec, &ObjInfo, cbData, fNamespace, idxDir, + pThis->szNameBuf, pThis->szRockNameBuf); + } + else + rtFsIsoImportProcessIso9660AddAndNameSymlink(pThis, pDirRec, &ObjInfo, fNamespace, idxDir, pThis->szNameBuf, + pThis->szRockNameBuf, pThis->szRockSymlinkTargetBuf); + } + } + else + rtFsIsoImpError(pThis, rc, "Invalid name at %#RX64: %.Rhxs", + offNext - cbChunk, pDirRec->bFileIdLength, pDirRec->achFileId); + + /* + * Advance to the next directory record. + */ + cbChunk = cbChunkNew; + pDirRec = pDirRecNext; + } + + return VINF_SUCCESS; +} + + +/** + * Deals with a directory tree. + * + * This is implemented by tracking directories that needs to be processed in a + * todo list, so no recursive calls, however it uses a bit of heap. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param offDirBlock The offset of the root directory data. + * @param cbDir The size of the root directory data. + * @param fUnicode Set if it's a unicode (UTF-16BE) encoded + * directory. + */ +static int rtFsIsoImportProcessIso9660Tree(PRTFSISOMKIMPORTER pThis, uint32_t offDirBlock, uint32_t cbDir, bool fUnicode) +{ + /* + * Reset some parsing state. + */ + pThis->offSuspSkip = 0; + pThis->fSuspSeenSP = false; + pThis->pszTransTbl = "TRANS.TBL"; /** @todo query this from the iso maker! */ + + /* + * Make sure we've got a root in the namespace. + */ + uint32_t idxDir = RTFsIsoMakerGetObjIdxForPath(pThis->hIsoMaker, + !fUnicode ? RTFSISOMAKER_NAMESPACE_ISO_9660 : RTFSISOMAKER_NAMESPACE_JOLIET, + "/"); + if (idxDir == UINT32_MAX) + { + idxDir = RTFSISOMAKER_CFG_IDX_ROOT; + int rc = RTFsIsoMakerObjSetPath(pThis->hIsoMaker, RTFSISOMAKER_CFG_IDX_ROOT, + !fUnicode ? RTFSISOMAKER_NAMESPACE_ISO_9660 : RTFSISOMAKER_NAMESPACE_JOLIET, "/"); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerObjSetPath failed on root dir: %Rrc", rc); + } + Assert(idxDir == RTFSISOMAKER_CFG_IDX_ROOT); + + /* + * Directories. + */ + int rc = VINF_SUCCESS; + uint8_t cDepth = 0; + RTLISTANCHOR TodoList; + RTListInit(&TodoList); + for (;;) + { + int rc2 = rtFsIsoImportProcessIso9660TreeWorker(pThis, idxDir, offDirBlock, cbDir, cDepth, fUnicode, &TodoList); + if (RT_FAILURE(rc2) && RT_SUCCESS(rc)) + rc = rc2; + + /* + * Pop the next directory. + */ + PRTFSISOMKIMPDIR pNext = RTListRemoveLast(&TodoList, RTFSISOMKIMPDIR, Entry); + if (!pNext) + break; + idxDir = pNext->idxObj; + offDirBlock = pNext->offDirBlock; + cbDir = pNext->cbDir; + cDepth = pNext->cDepth; + RTMemFree(pNext); + } + + return rc; +} + + +/** + * Imports a UTF-16BE string property from the joliet volume descriptor. + * + * The fields are normally space filled and padded, but we also consider zero + * bytes are fillers. If the field only contains padding, the string property + * will remain unchanged. + * + * @returns IPRT status code (ignorable). + * @param pThis The importer instance. + * @param pachField Pointer to the field. The structure type + * is 'char' for hysterical raisins, while the + * real type is 'RTUTF16'. + * @param cchField The field length. + * @param enmStringProp The corresponding string property. + * + * @note Clobbers pThis->pbBuf! + */ +static int rtFsIsoImportUtf16BigStringField(PRTFSISOMKIMPORTER pThis, const char *pachField, size_t cchField, + RTFSISOMAKERSTRINGPROP enmStringProp) +{ + /* + * Scan the field from the end as this way we know the result length if we find anything. + */ + PCRTUTF16 pwcField = (PCRTUTF16)pachField; + size_t cwcField = cchField / sizeof(RTUTF16); /* ignores any odd field byte */ + size_t off = cwcField; + while (off-- > 0) + { + RTUTF16 wc = RT_BE2H_U16(pwcField[off]); + if (wc == ' ' || wc == '\0') + { /* likely */ } + else + { + /* + * Convert to UTF-16. + */ + char *pszCopy = (char *)pThis->abBuf; + int rc = RTUtf16BigToUtf8Ex(pwcField, off + 1, &pszCopy, sizeof(pThis->abBuf), NULL); + if (RT_SUCCESS(rc)) + { + rc = RTFsIsoMakerSetStringProp(pThis->hIsoMaker, enmStringProp, RTFSISOMAKER_NAMESPACE_JOLIET, pszCopy); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerSetStringProp failed setting field %d to '%s': %Rrc", + enmStringProp, pszCopy, rc); + } + return rtFsIsoImpError(pThis, rc, "RTUtf16BigToUtf8Ex failed converting field %d to UTF-8: %Rrc - %.*Rhxs", + enmStringProp, rc, off * sizeof(RTUTF16), pwcField); + } + } + return VINF_SUCCESS; +} + + +/** + * Imports a string property from the primary volume descriptor. + * + * The fields are normally space filled and padded, but we also consider zero + * bytes are fillers. If the field only contains padding, the string property + * will remain unchanged. + * + * @returns IPRT status code (ignorable). + * @param pThis The importer instance. + * @param pachField Pointer to the field. + * @param cchField The field length. + * @param enmStringProp The corresponding string property. + * + * @note Clobbers pThis->pbBuf! + */ +static int rtFsIsoImportAsciiStringField(PRTFSISOMKIMPORTER pThis, const char *pachField, size_t cchField, + RTFSISOMAKERSTRINGPROP enmStringProp) +{ + /* + * Scan the field from the end as this way we know the result length if we find anything. + */ + size_t off = cchField; + while (off-- > 0) + { + char ch = pachField[off]; + if (ch == ' ' || ch == '\0') + { /* likely */ } + else + { + /* + * Make a copy of the string in abBuf, purge the encoding. + */ + off++; + char *pszCopy = (char *)pThis->abBuf; + memcpy(pszCopy, pachField, off); + pszCopy[off] = '\0'; + RTStrPurgeEncoding(pszCopy); + + int rc = RTFsIsoMakerSetStringProp(pThis->hIsoMaker, enmStringProp, RTFSISOMAKER_NAMESPACE_ISO_9660, pszCopy); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerSetStringProp failed setting field %d to '%s': %Rrc", + enmStringProp, pszCopy, rc); + } + } + return VINF_SUCCESS; +} + + +/** + * Validates a root directory record. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param pDirRec The root directory record to validate. + */ +static int rtFsIsoImportValidateRootDirRec(PRTFSISOMKIMPORTER pThis, PCISO9660DIRREC pDirRec) +{ + /* + * Validate dual fields. + */ + if (RT_LE2H_U32(pDirRec->cbData.le) != RT_BE2H_U32(pDirRec->cbData.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_ROOT_DIR_REC, + "Invalid root dir size: {%#RX32,%#RX32}", + RT_BE2H_U32(pDirRec->cbData.be), RT_LE2H_U32(pDirRec->cbData.le)); + + if (RT_LE2H_U32(pDirRec->offExtent.le) != RT_BE2H_U32(pDirRec->offExtent.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_ROOT_DIR_REC, + "Invalid root dir extent: {%#RX32,%#RX32}", + RT_BE2H_U32(pDirRec->offExtent.be), RT_LE2H_U32(pDirRec->offExtent.le)); + + if (RT_LE2H_U16(pDirRec->VolumeSeqNo.le) != RT_BE2H_U16(pDirRec->VolumeSeqNo.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_ROOT_DIR_REC, + "Invalid root dir volume sequence ID: {%#RX16,%#RX16}", + RT_BE2H_U16(pDirRec->VolumeSeqNo.be), RT_LE2H_U16(pDirRec->VolumeSeqNo.le)); + + /* + * Check values. + */ + if (ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo) != pThis->idPrimaryVol) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_ROOT_VOLUME_SEQ_NO, + "Expected root dir to have same volume sequence number as primary volume: %#x, expected %#x", + ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo), pThis->idPrimaryVol); + + if (ISO9660_GET_ENDIAN(&pDirRec->cbData) == 0) + return RTErrInfoSet(pThis->pErrInfo, VERR_ISOMK_IMPORT_ZERO_SIZED_ROOT_DIR, "Zero sized root dir"); + + if (ISO9660_GET_ENDIAN(&pDirRec->offExtent) >= pThis->cBlocksInPrimaryVolumeSpace) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_ROOT_DIR_EXTENT_OUT_OF_BOUNDS, + "Invalid root dir extent: %#RX32, max %#RX32", + ISO9660_GET_ENDIAN(&pDirRec->offExtent), pThis->cBlocksInPrimaryVolumeSpace); + + if (pDirRec->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_ROOT_DIR_REC_LENGTH, + "Root dir record size is too small: %#x (min %#x)", + pDirRec->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId)); + + if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_ROOT_DIR_WITHOUT_DIR_FLAG, + "Root dir is not flagged as directory: %#x", pDirRec->fFileFlags); + if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_ROOT_DIR_IS_MULTI_EXTENT, + "Root dir is cannot be multi-extent: %#x", pDirRec->fFileFlags); + + return VINF_SUCCESS; +} + + +/** + * Processes a primary volume descriptor, importing all files and stuff. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param pVolDesc The primary volume descriptor. + */ +static int rtFsIsoImportProcessPrimaryDesc(PRTFSISOMKIMPORTER pThis, PISO9660PRIMARYVOLDESC pVolDesc) +{ + /* + * Validate dual fields first. + */ + if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION) + return rtFsIsoImpError(pThis, VERR_IOSMK_IMPORT_PRIMARY_VOL_DESC_VER, + "Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion); + + if (RT_LE2H_U16(pVolDesc->cbLogicalBlock.le) != RT_BE2H_U16(pVolDesc->cbLogicalBlock.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_PRIMARY_VOL_DESC, + "Mismatching logical block size: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le)); + if (RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le) != RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_PRIMARY_VOL_DESC, + "Mismatching volume space size: {%#RX32,%#RX32}", + RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le)); + if (RT_LE2H_U16(pVolDesc->cVolumesInSet.le) != RT_BE2H_U16(pVolDesc->cVolumesInSet.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_PRIMARY_VOL_DESC, + "Mismatching volumes in set: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le)); + if (RT_LE2H_U16(pVolDesc->VolumeSeqNo.le) != RT_BE2H_U16(pVolDesc->VolumeSeqNo.be)) + { + /* Hack alert! An Windows NT 3.1 ISO was found to not have the big endian bit set here, so work around it. */ + if ( pVolDesc->VolumeSeqNo.be == 0 + && pVolDesc->VolumeSeqNo.le == RT_H2LE_U16_C(1)) + pVolDesc->VolumeSeqNo.be = RT_H2BE_U16_C(1); + else + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_PRIMARY_VOL_DESC, + "Mismatching volume sequence no.: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le)); + } + if (RT_LE2H_U32(pVolDesc->cbPathTable.le) != RT_BE2H_U32(pVolDesc->cbPathTable.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_PRIMARY_VOL_DESC, + "Mismatching path table size: {%#RX32,%#RX32}", + RT_BE2H_U32(pVolDesc->cbPathTable.be), RT_LE2H_U32(pVolDesc->cbPathTable.le)); + + /* + * Validate field values against our expectations. + */ + if (ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock) != ISO9660_SECTOR_SIZE) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_LOGICAL_BLOCK_SIZE_NOT_2KB, + "Unsupported block size: %#x", ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock)); + + if (ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet) != 1) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MORE_THAN_ONE_VOLUME_IN_SET, + "Volumes in set: %#x", ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet)); + + if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo) != 1) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_INVALID_VOLUMNE_SEQ_NO, + "Unexpected volume sequence number: %#x", ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo)); + + /* + * Gather info we need. + */ + pThis->cBlocksInPrimaryVolumeSpace = ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize); + pThis->cbPrimaryVolumeSpace = pThis->cBlocksInPrimaryVolumeSpace * (uint64_t)ISO9660_SECTOR_SIZE; + pThis->cVolumesInSet = ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet); + pThis->idPrimaryVol = ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo); + + /* + * Validate the root directory record. + */ + int rc = rtFsIsoImportValidateRootDirRec(pThis, &pVolDesc->RootDir.DirRec); + if (RT_SUCCESS(rc)) + { + /* + * Import stuff if present and not opted out. + */ + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_SYSTEM_ID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achSystemId, sizeof(pVolDesc->achSystemId), + RTFSISOMAKERSTRINGPROP_SYSTEM_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_VOLUME_ID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achVolumeId, sizeof(pVolDesc->achVolumeId), + RTFSISOMAKERSTRINGPROP_VOLUME_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_VOLUME_SET_ID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achVolumeSetId, sizeof(pVolDesc->achVolumeSetId), + RTFSISOMAKERSTRINGPROP_VOLUME_SET_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_PUBLISHER_ID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achPublisherId, sizeof(pVolDesc->achPublisherId), + RTFSISOMAKERSTRINGPROP_PUBLISHER_ID); + if (pThis->fFlags & RTFSISOMK_IMPORT_F_DATA_PREPARER_ID) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achDataPreparerId, sizeof(pVolDesc->achDataPreparerId), + RTFSISOMAKERSTRINGPROP_DATA_PREPARER_ID); + if (pThis->fFlags & RTFSISOMK_IMPORT_F_APPLICATION_ID) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achApplicationId, sizeof(pVolDesc->achApplicationId), + RTFSISOMAKERSTRINGPROP_APPLICATION_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_COPYRIGHT_FID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achCopyrightFileId, sizeof(pVolDesc->achCopyrightFileId), + RTFSISOMAKERSTRINGPROP_COPYRIGHT_FILE_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_ABSTRACT_FID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achAbstractFileId, sizeof(pVolDesc->achAbstractFileId), + RTFSISOMAKERSTRINGPROP_ABSTRACT_FILE_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_BIBLIO_FID)) + rtFsIsoImportAsciiStringField(pThis, pVolDesc->achBibliographicFileId, sizeof(pVolDesc->achBibliographicFileId), + RTFSISOMAKERSTRINGPROP_BIBLIOGRAPHIC_FILE_ID); + + /* + * Process the directory tree. + */ + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_PRIMARY_ISO)) + rc = rtFsIsoImportProcessIso9660Tree(pThis, ISO9660_GET_ENDIAN(&pVolDesc->RootDir.DirRec.offExtent), + ISO9660_GET_ENDIAN(&pVolDesc->RootDir.DirRec.cbData), false /*fUnicode*/); + } + + return rc; +} + + +/** + * Processes a secondary volume descriptor, if it is joliet we'll importing all + * the files and stuff. + * + * @returns IPRT status code (safe to ignore, see pThis->rc). + * @param pThis The importer instance. + * @param pVolDesc The primary volume descriptor. + */ +static int rtFsIsoImportProcessSupplementaryDesc(PRTFSISOMKIMPORTER pThis, PISO9660SUPVOLDESC pVolDesc) +{ + /* + * Validate dual fields first. + */ + if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION) + return rtFsIsoImpError(pThis, VERR_IOSMK_IMPORT_SUP_VOL_DESC_VER, + "Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion); + + if (RT_LE2H_U16(pVolDesc->cbLogicalBlock.le) != RT_BE2H_U16(pVolDesc->cbLogicalBlock.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_SUP_VOL_DESC, + "Mismatching logical block size: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le)); + if (RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le) != RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_SUP_VOL_DESC, + "Mismatching volume space size: {%#RX32,%#RX32}", + RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le)); + if (RT_LE2H_U16(pVolDesc->cVolumesInSet.le) != RT_BE2H_U16(pVolDesc->cVolumesInSet.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_SUP_VOL_DESC, + "Mismatching volumes in set: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le)); + if (RT_LE2H_U16(pVolDesc->VolumeSeqNo.le) != RT_BE2H_U16(pVolDesc->VolumeSeqNo.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_SUP_VOL_DESC, + "Mismatching volume sequence no.: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le)); + if (RT_LE2H_U32(pVolDesc->cbPathTable.le) != RT_BE2H_U32(pVolDesc->cbPathTable.be)) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BAD_SUP_VOL_DESC, + "Mismatching path table size: {%#RX32,%#RX32}", + RT_BE2H_U32(pVolDesc->cbPathTable.be), RT_LE2H_U32(pVolDesc->cbPathTable.le)); + + /* + * Validate field values against our expectations. + */ + if (ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock) != ISO9660_SECTOR_SIZE) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_LOGICAL_BLOCK_SIZE_NOT_2KB, + "Unsupported block size: %#x", ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock)); + + if (ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet) != pThis->cVolumesInSet) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_VOLUME_IN_SET_MISMATCH, "Volumes in set: %#x, expected %#x", + ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet), pThis->cVolumesInSet); + + if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo) != pThis->idPrimaryVol) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_INVALID_VOLUMNE_SEQ_NO, + "Unexpected volume sequence number: %#x (expected %#x)", + ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo), pThis->idPrimaryVol); + + if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize) != pThis->cBlocksInPrimaryVolumeSpace) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_INVALID_VOLUMNE_SEQ_NO, + "Volume space size differs between primary and supplementary descriptors: %#x, primary %#x", + ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize), pThis->cBlocksInPrimaryVolumeSpace); + + /* + * Validate the root directory record. + */ + int rc = rtFsIsoImportValidateRootDirRec(pThis, &pVolDesc->RootDir.DirRec); + if (RT_FAILURE(rc)) + return rc; + + /* + * Is this a joliet descriptor? Ignore if not. + */ + uint8_t uJolietLevel = 0; + if ( pVolDesc->abEscapeSequences[0] == ISO9660_JOLIET_ESC_SEQ_0 + && pVolDesc->abEscapeSequences[1] == ISO9660_JOLIET_ESC_SEQ_1) + switch (pVolDesc->abEscapeSequences[2]) + { + case ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1: uJolietLevel = 1; break; + case ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2: uJolietLevel = 2; break; + case ISO9660_JOLIET_ESC_SEQ_2_LEVEL_3: uJolietLevel = 3; break; + default: Log(("rtFsIsoImportProcessSupplementaryDesc: last joliet escape sequence byte doesn't match: %#x\n", + pVolDesc->abEscapeSequences[2])); + } + if (uJolietLevel == 0) + return VINF_SUCCESS; + + /* + * Only one joliet descriptor. + */ + if (pThis->fSeenJoliet) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MULTIPLE_JOLIET_VOL_DESCS, + "More than one Joliet volume descriptor is not supported"); + pThis->fSeenJoliet = true; + + /* + * Import stuff if present and not opted out. + */ + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_SYSTEM_ID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achSystemId, sizeof(pVolDesc->achSystemId), + RTFSISOMAKERSTRINGPROP_SYSTEM_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_VOLUME_ID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achVolumeId, sizeof(pVolDesc->achVolumeId), + RTFSISOMAKERSTRINGPROP_VOLUME_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_VOLUME_SET_ID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achVolumeSetId, sizeof(pVolDesc->achVolumeSetId), + RTFSISOMAKERSTRINGPROP_VOLUME_SET_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_PUBLISHER_ID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achPublisherId, sizeof(pVolDesc->achPublisherId), + RTFSISOMAKERSTRINGPROP_PUBLISHER_ID); + if (pThis->fFlags & RTFSISOMK_IMPORT_F_J_DATA_PREPARER_ID) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achDataPreparerId, sizeof(pVolDesc->achDataPreparerId), + RTFSISOMAKERSTRINGPROP_DATA_PREPARER_ID); + if (pThis->fFlags & RTFSISOMK_IMPORT_F_J_APPLICATION_ID) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achApplicationId, sizeof(pVolDesc->achApplicationId), + RTFSISOMAKERSTRINGPROP_APPLICATION_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_COPYRIGHT_FID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achCopyrightFileId, sizeof(pVolDesc->achCopyrightFileId), + RTFSISOMAKERSTRINGPROP_COPYRIGHT_FILE_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_ABSTRACT_FID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achAbstractFileId, sizeof(pVolDesc->achAbstractFileId), + RTFSISOMAKERSTRINGPROP_ABSTRACT_FILE_ID); + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_J_BIBLIO_FID)) + rtFsIsoImportUtf16BigStringField(pThis, pVolDesc->achBibliographicFileId, sizeof(pVolDesc->achBibliographicFileId), + RTFSISOMAKERSTRINGPROP_BIBLIOGRAPHIC_FILE_ID); + + /* + * Process the directory tree. + */ + if (!(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_JOLIET)) + return rtFsIsoImportProcessIso9660Tree(pThis, ISO9660_GET_ENDIAN(&pVolDesc->RootDir.DirRec.offExtent), + ISO9660_GET_ENDIAN(&pVolDesc->RootDir.DirRec.cbData), true /*fUnicode*/); + return VINF_SUCCESS; +} + + +/** + * Checks out an El Torito boot image to see if it requires info table patching. + * + * @returns IPRT status code (ignored). + * @param pThis The ISO importer instance. + * @param idxImageObj The configuration index of the image. + * @param offBootImage The block offset of the image. + */ +static int rtFsIsoImportProcessElToritoImage(PRTFSISOMKIMPORTER pThis, uint32_t idxImageObj, uint32_t offBootImage) +{ + ISO9660SYSLINUXINFOTABLE InfoTable; + int rc = RTVfsFileReadAt(pThis->hSrcFile, offBootImage * (uint64_t)ISO9660_SECTOR_SIZE + ISO9660SYSLINUXINFOTABLE_OFFSET, + &InfoTable, sizeof(InfoTable), NULL); + if (RT_SUCCESS(rc)) + { + if ( RT_LE2H_U32(InfoTable.offBootFile) == offBootImage + && RT_LE2H_U32(InfoTable.offPrimaryVolDesc) == pThis->offPrimaryVolDesc + && ASMMemIsAllU8(&InfoTable.auReserved[0], sizeof(InfoTable.auReserved), 0) ) + { + rc = RTFsIsoMakerObjEnableBootInfoTablePatching(pThis->hIsoMaker, idxImageObj, true /*fEnable*/); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerObjEnableBootInfoTablePatching failed: %Rrc", rc); + } + } + return VINF_SUCCESS; +} + + +/** + * Processes a boot catalog default or section entry. + * + * @returns IPRT status code (ignored). + * @param pThis The ISO importer instance. + * @param iEntry The boot catalog entry number. This is 1 for + * the default entry, and 3+ for section entries. + * @param cMaxEntries Maximum number of entries. + * @param pEntry The entry to process. + * @param pcSkip Where to return the number of extension entries to skip. + */ +static int rtFsIsoImportProcessElToritoSectionEntry(PRTFSISOMKIMPORTER pThis, uint32_t iEntry, uint32_t cMaxEntries, + PCISO9660ELTORITOSECTIONENTRY pEntry, uint32_t *pcSkip) +{ + *pcSkip = 0; + + /* + * Check the boot indicator type for entry 1. + */ + if ( pEntry->bBootIndicator != ISO9660_ELTORITO_BOOT_INDICATOR_BOOTABLE + && pEntry->bBootIndicator != ISO9660_ELTORITO_BOOT_INDICATOR_NOT_BOOTABLE) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_DEF_ENTRY_INVALID_BOOT_IND, + "Default boot catalog entry has an invalid boot indicator: %#x", pEntry->bBootIndicator); + + /* + * Check the media type and flags. + */ + uint32_t cbDefaultSize; + uint8_t bMediaType = pEntry->bBootMediaType; + switch (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_TYPE_MASK) + { + case ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_2_MB: + cbDefaultSize = 512 * 80 * 15 * 2; + break; + + case ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_1_44_MB: + cbDefaultSize = 512 * 80 * 18 * 2; + break; + + case ISO9660_ELTORITO_BOOT_MEDIA_TYPE_FLOPPY_2_88_MB: + cbDefaultSize = 512 * 80 * 36 * 2; + break; + + case ISO9660_ELTORITO_BOOT_MEDIA_TYPE_NO_EMULATION: + case ISO9660_ELTORITO_BOOT_MEDIA_TYPE_HARD_DISK: + cbDefaultSize = 0; + break; + + default: + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_INVALID_BOOT_MEDIA_TYPE, + "Boot catalog entry #%#x has an invalid boot media type: %#x", bMediaType); + } + + if (iEntry == 1) + { + if (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_MASK) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_DEF_ENTRY_INVALID_FLAGS, + "Boot catalog entry #%#x has an invalid boot media type: %#x", bMediaType); + bMediaType &= ~ISO9660_ELTORITO_BOOT_MEDIA_F_MASK; + } + } + else + { + if (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_RESERVED) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_RESERVED_FLAG, + "Boot catalog entry #%#x has an invalid boot media type: %#x", bMediaType); + bMediaType &= ~ISO9660_ELTORITO_BOOT_MEDIA_F_RESERVED; + } + } + + /* + * Complain if bUnused is used. + */ + if (pEntry->bUnused != 0) + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_USES_UNUSED_FIELD, + "Boot catalog entry #%#x has a non-zero unused field: %#x", pEntry->bUnused); + + /* + * Check out the boot image offset and turn that into an index of a file + */ + uint32_t offBootImage = RT_LE2H_U32(pEntry->offBootImage); + if (offBootImage >= pThis->cBlocksInSrcFile) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_IMAGE_OUT_OF_BOUNDS, + "Boot catalog entry #%#x has an out of bound boot image block number: %#RX32, max %#RX32", + offBootImage, pThis->cBlocksInPrimaryVolumeSpace); + + int rc; + uint32_t idxImageObj; + PRTFSISOMKIMPBLOCK2FILE pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)RTAvlU32Get(&pThis->Block2FileRoot, offBootImage); + if (pBlock2File) + idxImageObj = pBlock2File->idxObj; + else + { + if (cbDefaultSize == 0) + { + pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)RTAvlU32GetBestFit(&pThis->Block2FileRoot, offBootImage, true /*fAbove*/); + if (pBlock2File) + cbDefaultSize = RT_MIN(pBlock2File->Core.Key - offBootImage, UINT32_MAX / ISO9660_SECTOR_SIZE + 1) + * ISO9660_SECTOR_SIZE; + else if (offBootImage < pThis->cBlocksInSrcFile) + cbDefaultSize = RT_MIN(pThis->cBlocksInSrcFile - offBootImage, UINT32_MAX / ISO9660_SECTOR_SIZE + 1) + * ISO9660_SECTOR_SIZE; + else + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_UNKNOWN_IMAGE_SIZE, + "Boot catalog entry #%#x has an invalid boot media type: %#x", bMediaType); + } + + if (pThis->idxSrcFile != UINT32_MAX) + { + rc = RTFsIsoMakerAddCommonSourceFile(pThis->hIsoMaker, pThis->hSrcFile, &pThis->idxSrcFile); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerAddCommonSourceFile failed: %Rrc", rc); + Assert(pThis->idxSrcFile != UINT32_MAX); + } + + rc = RTFsIsoMakerAddUnnamedFileWithCommonSrc(pThis->hIsoMaker, pThis->idxSrcFile, + offBootImage * (uint64_t)ISO9660_SECTOR_SIZE, + cbDefaultSize, NULL, &idxImageObj); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerAddUnnamedFileWithCommonSrc failed on boot entry #%#x: %Rrc", + iEntry, rc); + } + + /* + * Deal with selection criteria. Use the last sector of abBuf to gather it + * into a single data chunk. + */ + size_t cbSelCrit = 0; + uint8_t *pbSelCrit = &pThis->abBuf[sizeof(pThis->abBuf) - ISO9660_SECTOR_SIZE]; + if (pEntry->bSelectionCriteriaType != ISO9660_ELTORITO_SEL_CRIT_TYPE_NONE) + { + memcpy(pbSelCrit, pEntry->abSelectionCriteria, sizeof(pEntry->abSelectionCriteria)); + cbSelCrit = sizeof(pEntry->abSelectionCriteria); + + if ( (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_CONTINUATION) + && iEntry + 1 < cMaxEntries) + { + uint32_t iExtEntry = iEntry + 1; + PCISO9660ELTORITOSECTIONENTRYEXT pExtEntry = (PCISO9660ELTORITOSECTIONENTRYEXT)pEntry; + for (;;) + { + pExtEntry++; + + if (pExtEntry->bExtensionId != ISO9660_ELTORITO_SECTION_ENTRY_EXT_ID) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_EXT_ENTRY_INVALID_ID, + "Invalid header ID for extension entry #%#x: %#x", iExtEntry, pExtEntry->bExtensionId); + break; + } + *pcSkip += 1; + + memcpy(&pbSelCrit[cbSelCrit], pExtEntry->abSelectionCriteria, sizeof(pExtEntry->abSelectionCriteria)); + cbSelCrit += sizeof(pExtEntry->abSelectionCriteria); + + if (pExtEntry->fFlags & ISO9660_ELTORITO_SECTION_ENTRY_EXT_F_UNUSED_MASK) + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_EXT_ENTRY_UNDEFINED_FLAGS, + "Boot catalog extension entry #%#x uses undefined flags: %#x", iExtEntry, pExtEntry->fFlags); + + iExtEntry++; + if (!(pExtEntry->fFlags & ISO9660_ELTORITO_SECTION_ENTRY_EXT_F_MORE)) + break; + if (iExtEntry >= cMaxEntries) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_EXT_ENTRY_END_OF_SECTOR, + "Boot catalog extension entry #%#x sets the MORE flag, but we have reached the end of the boot catalog sector"); + break; + } + } + Assert(*pcSkip = iExtEntry - iEntry); + } + else if (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_CONTINUATION) + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_CONTINUATION_EOS, + "Boot catalog extension entry #%#x sets the MORE flag, but we have reached the end of the boot catalog sector"); + } + else if (bMediaType & ISO9660_ELTORITO_BOOT_MEDIA_F_CONTINUATION) + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_ENTRY_CONTINUATION_WITH_NONE, + "Boot catalog entry #%#x uses the continuation flag with selection criteria NONE", iEntry); + + /* + * Add the entry. + */ + rc = RTFsIsoMakerBootCatSetSectionEntry(pThis->hIsoMaker, iEntry, idxImageObj, bMediaType, pEntry->bSystemType, + pEntry->bBootIndicator == ISO9660_ELTORITO_BOOT_INDICATOR_BOOTABLE, + pEntry->uLoadSeg, pEntry->cEmulatedSectorsToLoad, + pEntry->bSelectionCriteriaType, pbSelCrit, cbSelCrit); + if (RT_SUCCESS(rc)) + { + pThis->pResults->cBootCatEntries += 1 + *pcSkip; + rc = rtFsIsoImportProcessElToritoImage(pThis, idxImageObj, offBootImage); + } + else + rtFsIsoImpError(pThis, rc, "RTFsIsoMakerBootCatSetSectionEntry failed for entry #%#x: %Rrc", iEntry, rc); + return rc; +} + + + +/** + * Processes a boot catalog section header entry. + * + * @returns IPRT status code (ignored). + * @param pThis The ISO importer instance. + * @param iEntry The boot catalog entry number. + * @param pEntry The entry to process. + */ +static int rtFsIsoImportProcessElToritoSectionHeader(PRTFSISOMKIMPORTER pThis, uint32_t iEntry, + PCISO9660ELTORITOSECTIONHEADER pEntry, char pszId[32]) +{ + Assert(pEntry->bHeaderId == ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER); + + /* Deal with the string. ASSUME it doesn't contain zeros in non-terminal positions. */ + if (pEntry->achSectionId[0] == '\0') + pszId = NULL; + else + { + memcpy(pszId, pEntry->achSectionId, sizeof(pEntry->achSectionId)); + pszId[sizeof(pEntry->achSectionId)] = '\0'; + } + + int rc = RTFsIsoMakerBootCatSetSectionHeaderEntry(pThis->hIsoMaker, iEntry, RT_LE2H_U16(pEntry->cEntries), + pEntry->bPlatformId, pszId); + if (RT_SUCCESS(rc)) + pThis->pResults->cBootCatEntries++; + else + rtFsIsoImpError(pThis, rc, + "RTFsIsoMakerBootCatSetSectionHeaderEntry failed for entry #%#x (bPlatformId=%#x cEntries=%#x): %Rrc", + iEntry, RT_LE2H_U16(pEntry->cEntries), pEntry->bPlatformId, rc); + return rc; +} + + +/** + * Processes a El Torito volume descriptor. + * + * @returns IPRT status code (ignorable). + * @param pThis The ISO importer instance. + * @param pVolDesc The volume descriptor to process. + */ +static int rtFsIsoImportProcessElToritoDesc(PRTFSISOMKIMPORTER pThis, PISO9660BOOTRECORDELTORITO pVolDesc) +{ + /* + * Read the boot catalog into the abBuf. + */ + uint32_t offBootCatalog = RT_LE2H_U32(pVolDesc->offBootCatalog); + if (offBootCatalog >= pThis->cBlocksInPrimaryVolumeSpace) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_BAD_OUT_OF_BOUNDS, + "Boot catalog block number is out of bounds: %#RX32, max %#RX32", + offBootCatalog, pThis->cBlocksInPrimaryVolumeSpace); + + int rc = RTVfsFileReadAt(pThis->hSrcFile, offBootCatalog * (uint64_t)ISO9660_SECTOR_SIZE, + pThis->abBuf, ISO9660_SECTOR_SIZE, NULL); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "Error reading boot catalog at block #%#RX32: %Rrc", offBootCatalog, rc); + + + /* + * Process the 'validation entry'. + */ + PCISO9660ELTORITOVALIDATIONENTRY pValEntry = (PCISO9660ELTORITOVALIDATIONENTRY)&pThis->abBuf[0]; + if (pValEntry->bHeaderId != ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_BAD_VALIDATION_HEADER_ID, + "Invalid boot catalog validation entry header ID: %#x, expected %#x", + pValEntry->bHeaderId, ISO9660_ELTORITO_HEADER_ID_VALIDATION_ENTRY); + + if ( pValEntry->bKey1 != ISO9660_ELTORITO_KEY_BYTE_1 + || pValEntry->bKey2 != ISO9660_ELTORITO_KEY_BYTE_2) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_BAD_VALIDATION_KEYS, + "Invalid boot catalog validation entry keys: %#x %#x, expected %#x %#x", + pValEntry->bKey1, pValEntry->bKey2, ISO9660_ELTORITO_KEY_BYTE_1, ISO9660_ELTORITO_KEY_BYTE_2); + + /* Check the checksum (should sum up to be zero). */ + uint16_t uChecksum = 0; + uint16_t const *pu16 = (uint16_t const *)pValEntry; + size_t cLeft = sizeof(*pValEntry) / sizeof(uint16_t); + while (cLeft-- > 0) + { + uChecksum += RT_LE2H_U16(*pu16); + pu16++; + } + if (uChecksum != 0) + return rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_BAD_VALIDATION_CHECKSUM, + "Invalid boot catalog validation entry checksum: %#x, expected 0", uChecksum); + + /* The string ID. ASSUME no leading zeros in valid strings. */ + const char *pszId = NULL; + char szId[32]; + if (pValEntry->achId[0] != '\0') + { + memcpy(szId, pValEntry->achId, sizeof(pValEntry->achId)); + szId[sizeof(pValEntry->achId)] = '\0'; + pszId = szId; + } + + /* + * Before we tell the ISO maker about the validation entry, we need to sort + * out the file backing the boot catalog. This isn't fatal if it fails. + */ + PRTFSISOMKIMPBLOCK2FILE pBlock2File = (PRTFSISOMKIMPBLOCK2FILE)RTAvlU32Get(&pThis->Block2FileRoot, offBootCatalog); + if (pBlock2File) + { + rc = RTFsIsoMakerBootCatSetFile(pThis->hIsoMaker, pBlock2File->idxObj); + if (RT_FAILURE(rc)) + rtFsIsoImpError(pThis, rc, "RTFsIsoMakerBootCatSetFile failed: %Rrc", rc); + } + + /* + * Set the validation entry. + */ + rc = RTFsIsoMakerBootCatSetValidationEntry(pThis->hIsoMaker, pValEntry->bPlatformId, pszId); + if (RT_FAILURE(rc)) + return rtFsIsoImpError(pThis, rc, "RTFsIsoMakerBootCatSetValidationEntry(,%#x,%s) failed: %Rrc", + pValEntry->bPlatformId, pszId); + Assert(pThis->pResults->cBootCatEntries == UINT32_MAX); + pThis->pResults->cBootCatEntries = 0; + + /* + * Process the default entry and any subsequent entries. + */ + bool fSeenFinal = false; + uint32_t const cMaxEntries = ISO9660_SECTOR_SIZE / ISO9660_ELTORITO_ENTRY_SIZE; + for (uint32_t iEntry = 1; iEntry < cMaxEntries; iEntry++) + { + uint8_t const *pbEntry = &pThis->abBuf[iEntry * ISO9660_ELTORITO_ENTRY_SIZE]; + uint8_t const idHeader = *pbEntry; + + /* KLUDGE ALERT! Older ISO images, like RHEL5-Server-20070208.0-x86_64-DVD.iso lacks + terminator entry. So, quietly stop with an entry that's all zeros. */ + if ( idHeader == ISO9660_ELTORITO_BOOT_INDICATOR_NOT_BOOTABLE /* 0x00 */ + && iEntry != 1 /* default */ + && ASMMemIsZero(pbEntry, ISO9660_ELTORITO_ENTRY_SIZE)) + return rc; + + if ( iEntry == 1 /* default*/ + || idHeader == ISO9660_ELTORITO_BOOT_INDICATOR_BOOTABLE + || idHeader == ISO9660_ELTORITO_BOOT_INDICATOR_NOT_BOOTABLE) + { + uint32_t cSkip = 0; + rtFsIsoImportProcessElToritoSectionEntry(pThis, iEntry, cMaxEntries, (PCISO9660ELTORITOSECTIONENTRY)pbEntry, &cSkip); + iEntry += cSkip; + } + else if (idHeader == ISO9660_ELTORITO_HEADER_ID_SECTION_HEADER) + rtFsIsoImportProcessElToritoSectionHeader(pThis, iEntry, (PCISO9660ELTORITOSECTIONHEADER)pbEntry, szId); + else if (idHeader == ISO9660_ELTORITO_HEADER_ID_FINAL_SECTION_HEADER) + { + fSeenFinal = true; + break; + } + else + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_UNKNOWN_HEADER_ID, + "Unknown boot catalog header ID for entry #%#x: %#x", iEntry, idHeader); + } + + if (!fSeenFinal) + rc = rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_BOOT_CAT_MISSING_FINAL_OR_TOO_BIG, + "Boot catalog is probably larger than a sector, or it's missing the final section header entry"); + return rc; +} + + +/** + * Imports an existing ISO. + * + * Just like other source files, the existing image must remain present and + * unmodified till the ISO maker is done with it. + * + * @returns IRPT status code. + * @param hIsoMaker The ISO maker handle. + * @param hIsoFile VFS file handle to the existing image to import / clone. + * @param fFlags Reserved for the future, MBZ. + * @param poffError Where to return the position in @a pszIso + * causing trouble when opening it for reading. + * Optional. + * @param pErrInfo Where to return additional error information. + * Optional. + */ +RTDECL(int) RTFsIsoMakerImport(RTFSISOMAKER hIsoMaker, RTVFSFILE hIsoFile, uint32_t fFlags, + PRTFSISOMAKERIMPORTRESULTS pResults, PRTERRINFO pErrInfo) +{ + /* + * Validate input. + */ + AssertPtrReturn(pResults, VERR_INVALID_POINTER); + pResults->cAddedNames = 0; + pResults->cAddedDirs = 0; + pResults->cbAddedDataBlocks = 0; + pResults->cAddedFiles = 0; + pResults->cAddedSymlinks = 0; + pResults->cBootCatEntries = UINT32_MAX; + pResults->cbSysArea = 0; + pResults->cErrors = 0; + AssertReturn(!(fFlags & ~RTFSISOMK_IMPORT_F_VALID_MASK), VERR_INVALID_FLAGS); + + /* + * Get the file size. + */ + uint64_t cbSrcFile = 0; + int rc = RTVfsFileGetSize(hIsoFile, &cbSrcFile); + if (RT_SUCCESS(rc)) + { + /* + * Allocate and init the importer state. + */ + PRTFSISOMKIMPORTER pThis = (PRTFSISOMKIMPORTER)RTMemAllocZ(sizeof(*pThis)); + if (pThis) + { + pThis->hIsoMaker = hIsoMaker; + pThis->fFlags = fFlags; + pThis->rc = VINF_SUCCESS; + pThis->pErrInfo = pErrInfo; + pThis->hSrcFile = hIsoFile; + pThis->cbSrcFile = cbSrcFile; + pThis->cBlocksInSrcFile = cbSrcFile / ISO9660_SECTOR_SIZE; + pThis->idxSrcFile = UINT32_MAX; + //pThis->Block2FileRoot = NULL; + //pThis->cBlocksInPrimaryVolumeSpace = 0; + //pThis->cbPrimaryVolumeSpace = 0 + //pThis->cVolumesInSet = 0; + //pThis->idPrimaryVol = 0; + //pThis->fSeenJoliet = false; + pThis->pResults = pResults; + //pThis->fSuspSeenSP = false; + //pThis->offSuspSkip = 0; + pThis->offRockBuf = UINT64_MAX; + + /* + * Check if this looks like a plausible ISO by checking out the first volume descriptor. + */ + rc = RTVfsFileReadAt(hIsoFile, _32K, &pThis->uSectorBuf.PrimVolDesc, sizeof(pThis->uSectorBuf.PrimVolDesc), NULL); + if (RT_SUCCESS(rc)) + { + if ( pThis->uSectorBuf.VolDescHdr.achStdId[0] == ISO9660VOLDESC_STD_ID_0 + && pThis->uSectorBuf.VolDescHdr.achStdId[1] == ISO9660VOLDESC_STD_ID_1 + && pThis->uSectorBuf.VolDescHdr.achStdId[2] == ISO9660VOLDESC_STD_ID_2 + && pThis->uSectorBuf.VolDescHdr.achStdId[3] == ISO9660VOLDESC_STD_ID_3 + && pThis->uSectorBuf.VolDescHdr.achStdId[4] == ISO9660VOLDESC_STD_ID_4 + && ( pThis->uSectorBuf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_PRIMARY + || pThis->uSectorBuf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_BOOT_RECORD) ) + { + /* + * Process the volume descriptors using the sector buffer, starting + * with the one we've already got sitting there. We postpone processing + * the el torito one till after the others, so we can name files and size + * referenced in it. + */ + uint32_t cPrimaryVolDescs = 0; + uint32_t iElTorito = UINT32_MAX; + uint32_t iVolDesc = 0; + for (;;) + { + switch (pThis->uSectorBuf.VolDescHdr.bDescType) + { + case ISO9660VOLDESC_TYPE_PRIMARY: + cPrimaryVolDescs++; + if (cPrimaryVolDescs == 1) + { + pThis->offPrimaryVolDesc = _32K / ISO9660_SECTOR_SIZE + iVolDesc; + rtFsIsoImportProcessPrimaryDesc(pThis, &pThis->uSectorBuf.PrimVolDesc); + } + else + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MULTIPLE_PRIMARY_VOL_DESCS, + "Only a single primary volume descriptor is currently supported"); + break; + + case ISO9660VOLDESC_TYPE_SUPPLEMENTARY: + if (cPrimaryVolDescs > 0) + rtFsIsoImportProcessSupplementaryDesc(pThis, &pThis->uSectorBuf.SupVolDesc); + else + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_SUPPLEMENTARY_BEFORE_PRIMARY, + "Primary volume descriptor expected before any supplementary descriptors!"); + break; + + case ISO9660VOLDESC_TYPE_BOOT_RECORD: + if (strcmp(pThis->uSectorBuf.ElToritoDesc.achBootSystemId, + ISO9660BOOTRECORDELTORITO_BOOT_SYSTEM_ID) == 0) + { + if (iElTorito == UINT32_MAX) + iElTorito = iVolDesc; + else + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_MULTIPLE_EL_TORITO_DESCS, + "Only a single El Torito descriptor exepcted!"); + } + break; + + case ISO9660VOLDESC_TYPE_PARTITION: + /* ignore for now */ + break; + + case ISO9660VOLDESC_TYPE_TERMINATOR: + AssertFailed(); + break; + } + + + /* + * Read the next volume descriptor and check the signature. + */ + iVolDesc++; + if (iVolDesc >= 32) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_TOO_MANY_VOL_DESCS, "Parses at most 32 volume descriptors"); + break; + } + + rc = RTVfsFileReadAt(hIsoFile, _32K + iVolDesc * ISO9660_SECTOR_SIZE, + &pThis->uSectorBuf, sizeof(pThis->uSectorBuf), NULL); + if (RT_FAILURE(rc)) + { + rtFsIsoImpError(pThis, rc, "Error reading the volume descriptor #%u at %#RX32: %Rrc", + iVolDesc, _32K + iVolDesc * ISO9660_SECTOR_SIZE, rc); + break; + } + + if ( pThis->uSectorBuf.VolDescHdr.achStdId[0] != ISO9660VOLDESC_STD_ID_0 + || pThis->uSectorBuf.VolDescHdr.achStdId[1] != ISO9660VOLDESC_STD_ID_1 + || pThis->uSectorBuf.VolDescHdr.achStdId[2] != ISO9660VOLDESC_STD_ID_2 + || pThis->uSectorBuf.VolDescHdr.achStdId[3] != ISO9660VOLDESC_STD_ID_3 + || pThis->uSectorBuf.VolDescHdr.achStdId[4] != ISO9660VOLDESC_STD_ID_4) + { + rtFsIsoImpError(pThis, VERR_ISOMK_IMPORT_INVALID_VOL_DESC_HDR, + "Invalid volume descriptor header #%u at %#RX32: %.*Rhxs", + iVolDesc, _32K + iVolDesc * ISO9660_SECTOR_SIZE, + (int)sizeof(pThis->uSectorBuf.VolDescHdr), &pThis->uSectorBuf.VolDescHdr); + break; + } + /** @todo UDF support. */ + if (pThis->uSectorBuf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_TERMINATOR) + break; + } + + /* + * Process the system area. + */ + if (RT_SUCCESS(pThis->rc) || pThis->idxSrcFile != UINT32_MAX) + { + rc = RTVfsFileReadAt(hIsoFile, 0, pThis->abBuf, _32K, NULL); + if (RT_SUCCESS(rc)) + { + if (!ASMMemIsAllU8(pThis->abBuf, _32K, 0)) + { + /* Drop zero sectors from the end. */ + uint32_t cbSysArea = _32K; + while ( cbSysArea >= ISO9660_SECTOR_SIZE + && ASMMemIsAllU8(&pThis->abBuf[cbSysArea - ISO9660_SECTOR_SIZE], ISO9660_SECTOR_SIZE, 0)) + cbSysArea -= ISO9660_SECTOR_SIZE; + + /** @todo HFS */ + pThis->pResults->cbSysArea = cbSysArea; + rc = RTFsIsoMakerSetSysAreaContent(hIsoMaker, pThis->abBuf, cbSysArea, 0); + if (RT_FAILURE(rc)) + rtFsIsoImpError(pThis, rc, "RTFsIsoMakerSetSysAreaContent failed: %Rrc", rc); + } + } + else + rtFsIsoImpError(pThis, rc, "Error reading the system area (0..32KB): %Rrc", rc); + } + + /* + * Do the El Torito descriptor. + */ + if ( iElTorito != UINT32_MAX + && !(pThis->fFlags & RTFSISOMK_IMPORT_F_NO_BOOT) + && (RT_SUCCESS(pThis->rc) || pThis->idxSrcFile != UINT32_MAX)) + { + rc = RTVfsFileReadAt(hIsoFile, _32K + iElTorito * ISO9660_SECTOR_SIZE, + &pThis->uSectorBuf, sizeof(pThis->uSectorBuf), NULL); + if (RT_SUCCESS(rc)) + rtFsIsoImportProcessElToritoDesc(pThis, &pThis->uSectorBuf.ElToritoDesc); + else + rtFsIsoImpError(pThis, rc, "Error reading the El Torito volume descriptor at %#RX32: %Rrc", + _32K + iElTorito * ISO9660_SECTOR_SIZE, rc); + } + + /* + * Return the first error status. + */ + rc = pThis->rc; + } + else + rc = RTErrInfoSetF(pErrInfo, VERR_ISOMK_IMPORT_UNKNOWN_FORMAT, "Invalid volume descriptor header: %.*Rhxs", + (int)sizeof(pThis->uSectorBuf.VolDescHdr), &pThis->uSectorBuf.VolDescHdr); + } + + /* + * Destroy the state. + */ + RTAvlU32Destroy(&pThis->Block2FileRoot, rtFsIsoMakerImportDestroyData2File, NULL); + RTMemFree(pThis); + } + else + rc = VERR_NO_MEMORY; + } + return rc; +} + diff --git a/src/VBox/Runtime/common/fs/isovfs.cpp b/src/VBox/Runtime/common/fs/isovfs.cpp new file mode 100644 index 00000000..a06664a3 --- /dev/null +++ b/src/VBox/Runtime/common/fs/isovfs.cpp @@ -0,0 +1,5992 @@ +/* $Id: isovfs.cpp $ */ +/** @file + * IPRT - ISO 9660 and UDF Virtual Filesystem (read only). + */ + +/* + * Copyright (C) 2017-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include "internal/iprt.h" +#include <iprt/fsvfs.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/err.h> +#include <iprt/crc.h> +#include <iprt/ctype.h> +#include <iprt/file.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/poll.h> +#include <iprt/string.h> +#include <iprt/thread.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/uni.h> +#include <iprt/utf16.h> +#include <iprt/formats/iso9660.h> +#include <iprt/formats/udf.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The maximum logical block size. */ +#define RTFSISO_MAX_LOGICAL_BLOCK_SIZE _16K +/** Max directory size. */ +#if ARCH_BITS == 32 +# define RTFSISO_MAX_DIR_SIZE _32M +#else +# define RTFSISO_MAX_DIR_SIZE _64M +#endif + +/** Check if an entity ID field equals the given ID string. */ +#define UDF_ENTITY_ID_EQUALS(a_pEntityId, a_szId) \ + ( memcmp(&(a_pEntityId)->achIdentifier[0], a_szId, RT_MIN(sizeof(a_szId), sizeof(a_pEntityId)->achIdentifier)) == 0 ) +/** Checks if a character set indicator indicates OSTA compressed unicode. */ +#define UDF_IS_CHAR_SET_OSTA(a_pCharSet) \ + ( (a_pCharSet)->uType == UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE \ + && memcmp((a_pCharSet)->abInfo, UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO, \ + sizeof(UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO)) == 0 ) + + +/** @name UDF structure logging macros + * @{ */ +#define UDF_LOG2_MEMBER(a_pStruct, a_szFmt, a_Member) \ + Log2(("ISO/UDF: %-32s %" a_szFmt "\n", #a_Member ":", (a_pStruct)->a_Member)) +#define UDF_LOG2_MEMBER_EX(a_pStruct, a_szFmt, a_Member, a_cchIndent) \ + Log2(("ISO/UDF: %*s%-32s %" a_szFmt "\n", a_cchIndent, "", #a_Member ":", (a_pStruct)->a_Member)) +#define UDF_LOG2_MEMBER_ENTITY_ID_EX(a_pStruct, a_Member, a_cchIndent) \ + Log2(("ISO/UDF: %*s%-32s '%.23s' fFlags=%#06x Suffix=%.8Rhxs\n", a_cchIndent, "", #a_Member ":", \ + (a_pStruct)->a_Member.achIdentifier, (a_pStruct)->a_Member.fFlags, &(a_pStruct)->a_Member.Suffix)) +#define UDF_LOG2_MEMBER_ENTITY_ID(a_pStruct, a_Member) UDF_LOG2_MEMBER_ENTITY_ID_EX(a_pStruct, a_Member, 0) +#define UDF_LOG2_MEMBER_EXTENTAD(a_pStruct, a_Member) \ + Log2(("ISO/UDF: %-32s sector %#010RX32 LB %#010RX32\n", #a_Member ":", (a_pStruct)->a_Member.off, (a_pStruct)->a_Member.cb)) +#define UDF_LOG2_MEMBER_SHORTAD(a_pStruct, a_Member) \ + Log2(("ISO/UDF: %-32s sector %#010RX32 LB %#010RX32 %s\n", #a_Member ":", (a_pStruct)->a_Member.off, (a_pStruct)->a_Member.cb, \ + (a_pStruct)->a_Member.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED ? "alloced+recorded" \ + : (a_pStruct)->a_Member.uType == UDF_AD_TYPE_ONLY_ALLOCATED ? "alloced" \ + : (a_pStruct)->a_Member.uType == UDF_AD_TYPE_FREE ? "free" : "next" )) +#define UDF_LOG2_MEMBER_LONGAD(a_pStruct, a_Member) \ + Log2(("ISO/UDF: %-32s partition %#RX16, block %#010RX32 LB %#010RX32 %s idUnique=%#010RX32 fFlags=%#RX16\n", #a_Member ":", \ + (a_pStruct)->a_Member.Location.uPartitionNo, (a_pStruct)->a_Member.Location.off, (a_pStruct)->a_Member.cb, \ + (a_pStruct)->a_Member.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED ? "alloced+recorded" \ + : (a_pStruct)->a_Member.uType == UDF_AD_TYPE_ONLY_ALLOCATED ? "alloced" \ + : (a_pStruct)->a_Member.uType == UDF_AD_TYPE_FREE ? "free" : "next", \ + (a_pStruct)->a_Member.ImplementationUse.Fid.idUnique, (a_pStruct)->a_Member.ImplementationUse.Fid.fFlags )) +#define UDF_LOG2_MEMBER_LBADDR(a_pStruct, a_Member) \ + Log2(("ISO/UDF: %-32s block %#010RX32 in partition %#06RX16\n", #a_Member ":", \ + (a_pStruct)->a_Member.off, (a_pStruct)->a_Member.uPartitionNo)) + +#define UDF_LOG2_MEMBER_TIMESTAMP(a_pStruct, a_Member) \ + Log2(("ISO/UDF: %-32s %04d-%02u-%02u %02u:%02u:%02u.%02u%02u%02u offUtc=%d type=%#x\n", #a_Member ":", \ + (a_pStruct)->a_Member.iYear, (a_pStruct)->a_Member.uMonth, (a_pStruct)->a_Member.uDay, \ + (a_pStruct)->a_Member.uHour, (a_pStruct)->a_Member.uMinute, (a_pStruct)->a_Member.uSecond, \ + (a_pStruct)->a_Member.cCentiseconds, (a_pStruct)->a_Member.cHundredsOfMicroseconds, \ + (a_pStruct)->a_Member.cMicroseconds, (a_pStruct)->a_Member.offUtcInMin, (a_pStruct)->a_Member.fType )) +#define UDF_LOG2_MEMBER_CHARSPEC(a_pStruct, a_Member) \ + do { \ + if ( (a_pStruct)->a_Member.uType == UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE \ + && memcmp(&(a_pStruct)->a_Member.abInfo[0], UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO, \ + sizeof(UDF_CHAR_SET_OSTA_COMPRESSED_UNICODE_INFO)) == 0) \ + Log2(("ISO/UDF: %-32s OSTA COMPRESSED UNICODE INFO\n", #a_Member ":")); \ + else if (ASMMemIsZero(&(a_pStruct)->a_Member, sizeof((a_pStruct)->a_Member))) \ + Log2(("ISO/UDF: %-32s all zeros\n", #a_Member ":")); \ + else \ + Log2(("ISO/UDF: %-32s %#x info: %.63Rhxs\n", #a_Member ":", \ + (a_pStruct)->a_Member.uType, (a_pStruct)->a_Member.abInfo)); \ + } while (0) +#define UDF_LOG2_MEMBER_DSTRING(a_pStruct, a_Member) \ + do { \ + if ((a_pStruct)->a_Member[0] == 8) \ + Log2(("ISO/UDF: %-32s 8: '%s' len=%u (actual=%u)\n", #a_Member ":", &(a_pStruct)->a_Member[1], \ + (a_pStruct)->a_Member[sizeof((a_pStruct)->a_Member) - 1], \ + RTStrNLen(&(a_pStruct)->a_Member[1], sizeof((a_pStruct)->a_Member) - 2) + 1 )); \ + else if ((a_pStruct)->a_Member[0] == 16) \ + { \ + PCRTUTF16 pwszTmp = (PCRTUTF16)&(a_pStruct)->a_Member[1]; \ + char *pszTmp = NULL; \ + RTUtf16BigToUtf8Ex(pwszTmp, (sizeof((a_pStruct)->a_Member) - 2) / sizeof(RTUTF16), &pszTmp, 0, NULL); \ + Log2(("ISO/UDF: %-32s 16: '%s' len=%u (actual=%u)\n", #a_Member ":", pszTmp, \ + (a_pStruct)->a_Member[sizeof((a_pStruct)->a_Member) - 1], \ + RTUtf16NLen(pwszTmp, (sizeof((a_pStruct)->a_Member) - 2) / sizeof(RTUTF16)) * sizeof(RTUTF16) + 1 /*??*/ )); \ + } \ + else if (ASMMemIsZero(&(a_pStruct)->a_Member[0], sizeof((a_pStruct)->a_Member))) \ + Log2(("ISO/UDF: %-32s empty\n", #a_Member ":")); \ + else \ + Log2(("ISO/UDF: %-32s bad: %.*Rhxs\n", #a_Member ":", sizeof((a_pStruct)->a_Member), &(a_pStruct)->a_Member[0] )); \ + } while (0) +/** @} */ + + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to an ISO volume (VFS instance data). */ +typedef struct RTFSISOVOL *PRTFSISOVOL; +/** Pointer to a const ISO volume (VFS instance data). */ +typedef struct RTFSISOVOL const *PCRTFSISOVOL; + +/** Pointer to a ISO directory instance. */ +typedef struct RTFSISODIRSHRD *PRTFSISODIRSHRD; + + + +/** + * ISO extent (internal to the VFS not a disk structure). + */ +typedef struct RTFSISOEXTENT +{ + /** The disk or partition byte offset. + * This is set to UINT64_MAX for parts of sparse files that aren't recorded.*/ + uint64_t off; + /** The size of the extent in bytes. */ + uint64_t cbExtent; + /** UDF virtual partition number, UINT32_MAX for ISO 9660. */ + uint32_t idxPart; + /** Reserved. */ + uint32_t uReserved; +} RTFSISOEXTENT; +/** Pointer to an ISO 9660 extent. */ +typedef RTFSISOEXTENT *PRTFSISOEXTENT; +/** Pointer to a const ISO 9660 extent. */ +typedef RTFSISOEXTENT const *PCRTFSISOEXTENT; + + +/** + * ISO file system object, shared part. + */ +typedef struct RTFSISOCORE +{ + /** The parent directory keeps a list of open objects (RTFSISOCORE). */ + RTLISTNODE Entry; + /** Reference counter. */ + uint32_t volatile cRefs; + /** The parent directory (not released till all children are close). */ + PRTFSISODIRSHRD pParentDir; + /** The byte offset of the first directory record. + * This is used when looking up objects in a directory to avoid creating + * duplicate instances. */ + uint64_t offDirRec; + /** Attributes. */ + RTFMODE fAttrib; + /** The object size. */ + uint64_t cbObject; + /** The access time. */ + RTTIMESPEC AccessTime; + /** The modificaton time. */ + RTTIMESPEC ModificationTime; + /** The change time. */ + RTTIMESPEC ChangeTime; + /** The birth time. */ + RTTIMESPEC BirthTime; + /** The i-node ID. */ + RTINODE idINode; + /** Pointer to the volume. */ + PRTFSISOVOL pVol; + /** The version number. */ + uint32_t uVersion; + /** Number of extents. */ + uint32_t cExtents; + /** The first extent. */ + RTFSISOEXTENT FirstExtent; + /** Array of additional extents. */ + PRTFSISOEXTENT paExtents; +} RTFSISOCORE; +typedef RTFSISOCORE *PRTFSISOCORE; + +/** + * ISO file, shared data. + */ +typedef struct RTFSISOFILESHRD +{ + /** Core ISO9660 object info. */ + RTFSISOCORE Core; +} RTFSISOFILESHRD; +/** Pointer to a ISO 9660 file object. */ +typedef RTFSISOFILESHRD *PRTFSISOFILESHRD; + + +/** + * ISO directory, shared data. + * + * We will always read in the whole directory just to keep things really simple. + */ +typedef struct RTFSISODIRSHRD +{ + /** Core ISO 9660 object info. */ + RTFSISOCORE Core; + /** Open child objects (RTFSISOCORE). */ + RTLISTNODE OpenChildren; + + /** Pointer to the directory content. */ + uint8_t *pbDir; + /** The size of the directory content (duplicate of Core.cbObject). */ + uint32_t cbDir; +} RTFSISODIRSHRD; +/** Pointer to a ISO directory instance. */ +typedef RTFSISODIRSHRD *PRTFSISODIRSHRD; + + +/** + * Private data for a VFS file object. + */ +typedef struct RTFSISOFILEOBJ +{ + /** Pointer to the shared data. */ + PRTFSISOFILESHRD pShared; + /** The current file offset. */ + uint64_t offFile; +} RTFSISOFILEOBJ; +typedef RTFSISOFILEOBJ *PRTFSISOFILEOBJ; + +/** + * Private data for a VFS directory object. + */ +typedef struct RTFSISODIROBJ +{ + /** Pointer to the shared data. */ + PRTFSISODIRSHRD pShared; + /** The current directory offset. */ + uint32_t offDir; +} RTFSISODIROBJ; +typedef RTFSISODIROBJ *PRTFSISODIROBJ; + +/** Pointer to info about a UDF volume. */ +typedef struct RTFSISOUDFVOLINFO *PRTFSISOUDFVOLINFO; + + +/** @name RTFSISO_UDF_PMAP_T_XXX + * @{ */ +#define RTFSISO_UDF_PMAP_T_PLAIN 1 +#define RTFSISO_UDF_PMAP_T_VPM_15 2 +#define RTFSISO_UDF_PMAP_T_VPM_20 3 +#define RTFSISO_UDF_PMAP_T_SPM 4 +#define RTFSISO_UDF_PMAP_T_MPM 5 +/** @} */ + +/** + * Information about a logical UDF partition. + * + * This combins information from the partition descriptor, the UDFPARTMAPTYPE1 + * and the UDFPARTMAPTYPE2 structure. + */ +typedef struct RTFSISOVOLUDFPMAP +{ + /** Partition starting location as a byte offset. */ + uint64_t offByteLocation; + /** Partition starting location (logical sector number). */ + uint32_t offLocation; + /** Number of sectors. */ + uint32_t cSectors; + + /** Partition descriptor index (for processing). */ + uint16_t idxPartDesc; + /** Offset info the map table. */ + uint16_t offMapTable; + /** Partition number (not index). */ + uint16_t uPartitionNo; + /** Partition number (not index). */ + uint16_t uVolumeSeqNo; + + /** The access type (UDF_PART_ACCESS_TYPE_XXX). */ + uint32_t uAccessType; + /** Partition flags (UDF_PARTITION_FLAGS_XXX). */ + uint16_t fFlags; + /** RTFSISO_UDF_PMAP_T_XXX. */ + uint8_t bType; + /** Set if Hdr is valid. */ + bool fHaveHdr; + /** Copy of UDFPARTITIONDESC::ContentsUse::Hdr. */ + UDFPARTITIONHDRDESC Hdr; + +} RTFSISOVOLUDFPMAP; +typedef RTFSISOVOLUDFPMAP *PRTFSISOVOLUDFPMAP; + +/** + * Information about a UDF volume (/ volume set). + * + * This combines information from the primary and logical descriptors. + * + * @note There is only one volume per volume set in the current UDF + * implementation. So, this can be considered a volume and a volume set. + */ +typedef struct RTFSISOUDFVOLINFO +{ + /** The extent containing the file set descriptor. */ + UDFLONGAD FileSetDescriptor; + + /** The root directory location (from the file set descriptor). */ + UDFLONGAD RootDirIcb; + /** Location of the system stream directory associated with the file set. */ + UDFLONGAD SystemStreamDirIcb; + + /** The logical block size on this volume. */ + uint32_t cbBlock; + /** The log2 of cbBlock. */ + uint32_t cShiftBlock; + /** Flags (UDF_PVD_FLAGS_XXX). */ + uint16_t fFlags; + + /** Number of partitions mapp in this volume. */ + uint16_t cPartitions; + /** Partitions in this volume. */ + PRTFSISOVOLUDFPMAP paPartitions; + + /** The volume ID string. */ + UDFDSTRING achLogicalVolumeID[128]; +} RTFSISOUDFVOLINFO; + + +/** + * Indicates which of the possible content types we're accessing. + */ +typedef enum RTFSISOVOLTYPE +{ + /** Accessing the primary ISO-9660 volume. */ + RTFSISOVOLTYPE_ISO9960 = 0, + /** Accessing the joliet volume (secondary ISO-9660). */ + RTFSISOVOLTYPE_JOLIET, + /** Accessing the UDF volume. */ + RTFSISOVOLTYPE_UDF +} RTFSISOVOLTYPE; + +/** + * A ISO volume. + */ +typedef struct RTFSISOVOL +{ + /** Handle to itself. */ + RTVFS hVfsSelf; + /** The file, partition, or whatever backing the ISO 9660 volume. */ + RTVFSFILE hVfsBacking; + /** The size of the backing thingy. */ + uint64_t cbBacking; + /** The size of the backing thingy in sectors (cbSector). */ + uint64_t cBackingSectors; + /** Flags. */ + uint32_t fFlags; + /** The sector size (in bytes). */ + uint32_t cbSector; + /** What we're accessing. */ + RTFSISOVOLTYPE enmType; + + /** @name ISO 9660 specific data + * @{ */ + /** The size of a logical block in bytes. */ + uint32_t cbBlock; + /** The primary volume space size in blocks. */ + uint32_t cBlocksInPrimaryVolumeSpace; + /** The primary volume space size in bytes. */ + uint64_t cbPrimaryVolumeSpace; + /** The number of volumes in the set. */ + uint32_t cVolumesInSet; + /** The primary volume sequence ID. */ + uint32_t idPrimaryVol; + /** Set if using UTF16-2 (joliet). */ + bool fIsUtf16; + /** @} */ + + /** UDF specific data. */ + struct + { + /** Volume information. */ + RTFSISOUDFVOLINFO VolInfo; + /** The UDF level. */ + uint8_t uLevel; + } Udf; + + /** The root directory shared data. */ + PRTFSISODIRSHRD pRootDir; +} RTFSISOVOL; + + +/** + * Info gathered from a VDS sequence. + */ +typedef struct RTFSISOVDSINFO +{ + /** Number of entries in apPrimaryVols. */ + uint32_t cPrimaryVols; + /** Number of entries in apLogicalVols. */ + uint32_t cLogicalVols; + /** Number of entries in apPartitions. */ + uint32_t cPartitions; + /** Pointer to primary volume descriptors (native endian). */ + PUDFPRIMARYVOLUMEDESC apPrimaryVols[8]; + /** Pointer to logical volume descriptors (native endian). */ + PUDFLOGICALVOLUMEDESC apLogicalVols[8]; + /** Pointer to partition descriptors (native endian). */ + PUDFPARTITIONDESC apPartitions[16]; + + /** Created after scanning the sequence (here for cleanup purposes). */ + PRTFSISOVOLUDFPMAP paPartMaps; +} RTFSISOVDSINFO; +/** Pointer to VDS sequence info. */ +typedef RTFSISOVDSINFO *PRTFSISOVDSINFO; + + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static void rtFsIsoDirShrd_AddOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild); +static void rtFsIsoDirShrd_RemoveOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild); +static int rtFsIsoDir_NewWithShared(PRTFSISOVOL pThis, PRTFSISODIRSHRD pShared, PRTVFSDIR phVfsDir); +static int rtFsIsoDir_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec, + uint32_t cDirRecs, uint64_t offDirRec, PRTVFSDIR phVfsDir); +static int rtFsIsoDir_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid, PRTVFSDIR phVfsDir); +static PRTFSISOCORE rtFsIsoDir_LookupShared(PRTFSISODIRSHRD pThis, uint64_t offDirRec); + +static int rtFsIsoVolValidateUdfDescCrc(PCUDFTAG pTag, size_t cbDesc, PRTERRINFO pErrInfo); +static int rtFsIsoVolValidateUdfDescTag(PCUDFTAG pTag, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo); +static int rtFsIsoVolValidateUdfDescTagAndCrc(PCUDFTAG pTag, size_t cbDesc, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo); + + +/** + * UDF virtual partition read function. + * + * This deals with all the fun related to block mapping and such. + * + * @returns VBox status code. + * @param pThis The instance. + * @param idxPart The virtual partition number. + * @param idxBlock The block number. + * @param offByteAddend The byte offset relative to the block. + * @param pvBuf The output buffer. + * @param cbToRead The number of bytes to read. + */ +static int rtFsIsoVolUdfVpRead(PRTFSISOVOL pThis, uint32_t idxPart, uint32_t idxBlock, uint64_t offByteAddend, + void *pvBuf, size_t cbToRead) +{ + uint64_t const offByte = ((uint64_t)idxBlock << pThis->Udf.VolInfo.cShiftBlock) + offByteAddend; + + int rc; + if (idxPart < pThis->Udf.VolInfo.cPartitions) + { + PRTFSISOVOLUDFPMAP pPart = &pThis->Udf.VolInfo.paPartitions[idxPart]; + switch (pPart->bType) + { + case RTFSISO_UDF_PMAP_T_PLAIN: + rc = RTVfsFileReadAt(pThis->hVfsBacking, offByte + pPart->offByteLocation, pvBuf, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + Log3(("ISO/UDF: Read %#x bytes at %#RX64 (%#x:%#RX64)\n", + cbToRead, offByte + pPart->offByteLocation, idxPart, offByte)); + return VINF_SUCCESS; + } + Log(("ISO/UDF: Error reading %#x bytes at %#RX64 (%#x:%#RX64): %Rrc\n", + cbToRead, offByte + pPart->offByteLocation, idxPart, offByte, rc)); + break; + + default: + AssertFailed(); + rc = VERR_ISOFS_IPE_1; + break; + } + } + else + { + Log(("ISO/UDF: Invalid partition index %#x (offset %#RX64), max partitions %#x\n", + idxPart, offByte, pThis->Udf.VolInfo.cPartitions)); + rc = VERR_ISOFS_INVALID_PARTITION_INDEX; + } + return rc; +} + + +/** + * Returns the length of the version suffix in the given name. + * + * @returns Number of UTF16-BE chars in the version suffix. + * @param pawcName The name to examine. + * @param cwcName The length of the name. + * @param puValue Where to return the value. + */ +static size_t rtFsIso9660GetVersionLengthUtf16Big(PCRTUTF16 pawcName, size_t cwcName, uint32_t *puValue) +{ + *puValue = 0; + + /* -1: */ + if (cwcName <= 2) + return 0; + RTUTF16 wc1 = RT_BE2H_U16(pawcName[cwcName - 1]); + if (!RT_C_IS_DIGIT(wc1)) + return 0; + Assert(wc1 < 0x3a); /* ASSUMES the RT_C_IS_DIGIT macro works just fine on wide chars too. */ + + /* -2: */ + RTUTF16 wc2 = RT_BE2H_U16(pawcName[cwcName - 2]); + if (wc2 == ';') + { + *puValue = wc1 - '0'; + return 2; + } + if (!RT_C_IS_DIGIT(wc2) || cwcName <= 3) + return 0; + + /* -3: */ + RTUTF16 wc3 = RT_BE2H_U16(pawcName[cwcName - 3]); + if (wc3 == ';') + { + *puValue = (wc1 - '0') + + (wc2 - '0') * 10; + return 3; + } + if (!RT_C_IS_DIGIT(wc3) || cwcName <= 4) + return 0; + + /* -4: */ + RTUTF16 wc4 = RT_BE2H_U16(pawcName[cwcName - 4]); + if (wc4 == ';') + { + *puValue = (wc1 - '0') + + (wc2 - '0') * 10 + + (wc3 - '0') * 100; + return 4; + } + if (!RT_C_IS_DIGIT(wc4) || cwcName <= 5) + return 0; + + /* -5: */ + RTUTF16 wc5 = RT_BE2H_U16(pawcName[cwcName - 5]); + if (wc5 == ';') + { + *puValue = (wc1 - '0') + + (wc2 - '0') * 10 + + (wc3 - '0') * 100 + + (wc4 - '0') * 1000; + return 5; + } + if (!RT_C_IS_DIGIT(wc5) || cwcName <= 6) + return 0; + + /* -6: */ + RTUTF16 wc6 = RT_BE2H_U16(pawcName[cwcName - 6]); + if (wc6 == ';') + { + *puValue = (wc1 - '0') + + (wc2 - '0') * 10 + + (wc3 - '0') * 100 + + (wc4 - '0') * 1000 + + (wc5 - '0') * 10000; + return 6; + } + return 0; +} + + +/** + * Returns the length of the version suffix in the given name. + * + * @returns Number of chars in the version suffix. + * @param pachName The name to examine. + * @param cchName The length of the name. + * @param puValue Where to return the value. + */ +static size_t rtFsIso9660GetVersionLengthAscii(const char *pachName, size_t cchName, uint32_t *puValue) +{ + *puValue = 0; + + /* -1: */ + if (cchName <= 2) + return 0; + char ch1 = pachName[cchName - 1]; + if (!RT_C_IS_DIGIT(ch1)) + return 0; + + /* -2: */ + char ch2 = pachName[cchName - 2]; + if (ch2 == ';') + { + *puValue = ch1 - '0'; + return 2; + } + if (!RT_C_IS_DIGIT(ch2) || cchName <= 3) + return 0; + + /* -3: */ + char ch3 = pachName[cchName - 3]; + if (ch3 == ';') + { + *puValue = (ch1 - '0') + + (ch2 - '0') * 10; + return 3; + } + if (!RT_C_IS_DIGIT(ch3) || cchName <= 4) + return 0; + + /* -4: */ + char ch4 = pachName[cchName - 4]; + if (ch4 == ';') + { + *puValue = (ch1 - '0') + + (ch2 - '0') * 10 + + (ch3 - '0') * 100; + return 4; + } + if (!RT_C_IS_DIGIT(ch4) || cchName <= 5) + return 0; + + /* -5: */ + char ch5 = pachName[cchName - 5]; + if (ch5 == ';') + { + *puValue = (ch1 - '0') + + (ch2 - '0') * 10 + + (ch3 - '0') * 100 + + (ch4 - '0') * 1000; + return 5; + } + if (!RT_C_IS_DIGIT(ch5) || cchName <= 6) + return 0; + + /* -6: */ + if (pachName[cchName - 6] == ';') + { + *puValue = (ch1 - '0') + + (ch2 - '0') * 10 + + (ch3 - '0') * 100 + + (ch4 - '0') * 1000 + + (ch5 - '0') * 10000; + return 6; + } + return 0; +} + + +/** + * Converts an ISO 9660 binary timestamp into an IPRT timesspec. + * + * @param pTimeSpec Where to return the IRPT time. + * @param pIso9660 The ISO 9660 binary timestamp. + */ +static void rtFsIso9660DateTime2TimeSpec(PRTTIMESPEC pTimeSpec, PCISO9660RECTIMESTAMP pIso9660) +{ + RTTIME Time; + Time.fFlags = RTTIME_FLAGS_TYPE_UTC; + Time.offUTC = 0; + Time.i32Year = pIso9660->bYear + 1900; + Time.u8Month = RT_MIN(RT_MAX(pIso9660->bMonth, 1), 12); + Time.u8MonthDay = RT_MIN(RT_MAX(pIso9660->bDay, 1), 31); + Time.u8WeekDay = UINT8_MAX; + Time.u16YearDay = 0; + Time.u8Hour = RT_MIN(pIso9660->bHour, 23); + Time.u8Minute = RT_MIN(pIso9660->bMinute, 59); + Time.u8Second = RT_MIN(pIso9660->bSecond, 59); + Time.u32Nanosecond = 0; + RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time)); + + /* Only apply the UTC offset if it's within reasons. */ + if (RT_ABS(pIso9660->offUtc) <= 13*4) + RTTimeSpecSubSeconds(pTimeSpec, pIso9660->offUtc * 15 * 60 * 60); +} + + +/** + * Converts an UDF timestamp into an IPRT timesspec. + * + * @param pTimeSpec Where to return the IRPT time. + * @param pUdf The UDF timestamp. + */ +static void rtFsIsoUdfTimestamp2TimeSpec(PRTTIMESPEC pTimeSpec, PCUDFTIMESTAMP pUdf) +{ + /* Check the year range before we try convert anything as it's quite possible + that this is zero. */ + if ( pUdf->iYear > 1678 + && pUdf->iYear < 2262) + { + RTTIME Time; + Time.fFlags = RTTIME_FLAGS_TYPE_UTC; + Time.offUTC = 0; + Time.i32Year = pUdf->iYear; + Time.u8Month = RT_MIN(RT_MAX(pUdf->uMonth, 1), 12); + Time.u8MonthDay = RT_MIN(RT_MAX(pUdf->uDay, 1), 31); + Time.u8WeekDay = UINT8_MAX; + Time.u16YearDay = 0; + Time.u8Hour = RT_MIN(pUdf->uHour, 23); + Time.u8Minute = RT_MIN(pUdf->uMinute, 59); + Time.u8Second = RT_MIN(pUdf->uSecond, 59); + Time.u32Nanosecond = pUdf->cCentiseconds * UINT32_C(10000000) + + pUdf->cHundredsOfMicroseconds * UINT32_C(100000) + + pUdf->cMicroseconds * UINT32_C(1000); + RTTimeImplode(pTimeSpec, RTTimeNormalize(&Time)); + + /* Only apply the UTC offset if it's within reasons. */ + if (RT_ABS(pUdf->offUtcInMin) <= 13*60) + RTTimeSpecSubSeconds(pTimeSpec, pUdf->offUtcInMin * 60); + } + else + RTTimeSpecSetNano(pTimeSpec, 0); +} + + +/** + * Initialization of a RTFSISOCORE structure from a directory record. + * + * @note The RTFSISOCORE::pParentDir and RTFSISOCORE::Clusters members are + * properly initialized elsewhere. + * + * @returns IRPT status code. Either VINF_SUCCESS or VERR_NO_MEMORY, the latter + * only if @a cDirRecs is above 1. + * @param pCore The structure to initialize. + * @param pDirRec The primary directory record. + * @param cDirRecs Number of directory records. + * @param offDirRec The offset of the primary directory record. + * @param uVersion The file version number. + * @param pVol The volume. + */ +static int rtFsIsoCore_InitFrom9660DirRec(PRTFSISOCORE pCore, PCISO9660DIRREC pDirRec, uint32_t cDirRecs, + uint64_t offDirRec, uint32_t uVersion, PRTFSISOVOL pVol) +{ + RTListInit(&pCore->Entry); + pCore->cRefs = 1; + pCore->pParentDir = NULL; + pCore->pVol = pVol; + pCore->offDirRec = offDirRec; + pCore->idINode = offDirRec; + pCore->fAttrib = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY + ? 0755 | RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY + : 0644 | RTFS_TYPE_FILE; + if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_HIDDEN) + pCore->fAttrib |= RTFS_DOS_HIDDEN; + pCore->cbObject = ISO9660_GET_ENDIAN(&pDirRec->cbData); + pCore->uVersion = uVersion; + pCore->cExtents = 1; + pCore->FirstExtent.cbExtent = pCore->cbObject; + pCore->FirstExtent.off = (ISO9660_GET_ENDIAN(&pDirRec->offExtent) + pDirRec->cExtAttrBlocks) * (uint64_t)pVol->cbBlock; + pCore->FirstExtent.idxPart = UINT32_MAX; + pCore->FirstExtent.uReserved = 0; + + rtFsIso9660DateTime2TimeSpec(&pCore->ModificationTime, &pDirRec->RecTime); + pCore->BirthTime = pCore->ModificationTime; + pCore->AccessTime = pCore->ModificationTime; + pCore->ChangeTime = pCore->ModificationTime; + + /* + * Deal with multiple extents. + */ + if (RT_LIKELY(cDirRecs == 1)) + { /* done */ } + else + { + PRTFSISOEXTENT pCurExtent = &pCore->FirstExtent; + while (cDirRecs > 1) + { + offDirRec += pDirRec->cbDirRec; + pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + pDirRec->cbDirRec); + if (pDirRec->cbDirRec != 0) + { + uint64_t offDisk = ISO9660_GET_ENDIAN(&pDirRec->offExtent) * (uint64_t)pVol->cbBlock; + uint32_t cbExtent = ISO9660_GET_ENDIAN(&pDirRec->cbData); + pCore->cbObject += cbExtent; + + if (pCurExtent->off + pCurExtent->cbExtent == offDisk) + pCurExtent->cbExtent += cbExtent; + else + { + void *pvNew = RTMemRealloc(pCore->paExtents, pCore->cExtents * sizeof(pCore->paExtents[0])); + if (pvNew) + pCore->paExtents = (PRTFSISOEXTENT)pvNew; + else + { + RTMemFree(pCore->paExtents); + return VERR_NO_MEMORY; + } + pCurExtent = &pCore->paExtents[pCore->cExtents - 1]; + pCurExtent->cbExtent = cbExtent; + pCurExtent->off = offDisk; + pCurExtent->idxPart = UINT32_MAX; + pCurExtent->uReserved = 0; + pCore->cExtents++; + } + cDirRecs--; + } + else + { + size_t cbSkip = (offDirRec + pVol->cbSector) & ~(pVol->cbSector - 1U); + offDirRec += cbSkip; + pDirRec = (PCISO9660DIRREC)((uintptr_t)pDirRec + cbSkip); + } + } + } + return VINF_SUCCESS; +} + + +/** + * Initalizes the allocation extends of a core structure. + * + * @returns IPRT status code + * @param pCore The core structure. + * @param pbAllocDescs Pointer to the allocation descriptor data. + * @param cbAllocDescs The size of the allocation descriptor data. + * @param fIcbTagFlags The ICB tag flags. + * @param idxDefaultPart The default data partition. + * @param offAllocDescs The disk byte offset corresponding to @a pbAllocDesc + * in case it's used as data storage (type 3). + * @param pVol The volume instance data. + */ +static int rtFsIsoCore_InitExtentsUdfIcbEntry(PRTFSISOCORE pCore, uint8_t const *pbAllocDescs, uint32_t cbAllocDescs, + uint32_t fIcbTagFlags, uint32_t idxDefaultPart, uint64_t offAllocDescs, + PRTFSISOVOL pVol) +{ + /* + * Just in case there are mutiple file entries in the ICB. + */ + if (pCore->paExtents != NULL) + { + LogRelMax(45, ("ISO/UDF: Re-reading extents - multiple file entries?\n")); + RTMemFree(pCore->paExtents); + pCore->paExtents = NULL; + } + + /* + * Figure the (minimal) size of an allocation descriptor, deal with the + * embedded storage and invalid descriptor types. + */ + uint32_t cbOneDesc; + switch (fIcbTagFlags & UDF_ICB_FLAGS_AD_TYPE_MASK) + { + case UDF_ICB_FLAGS_AD_TYPE_EMBEDDED: + pCore->cExtents = 1; + pCore->FirstExtent.cbExtent = cbAllocDescs; + pCore->FirstExtent.off = offAllocDescs; + pCore->FirstExtent.idxPart = idxDefaultPart; + return VINF_SUCCESS; + + case UDF_ICB_FLAGS_AD_TYPE_SHORT: cbOneDesc = sizeof(UDFSHORTAD); break; + case UDF_ICB_FLAGS_AD_TYPE_LONG: cbOneDesc = sizeof(UDFLONGAD); break; + case UDF_ICB_FLAGS_AD_TYPE_EXTENDED: cbOneDesc = sizeof(UDFEXTAD); break; + + default: + LogRelMax(45, ("ISO/UDF: Unknown allocation descriptor type %#x\n", fIcbTagFlags)); + return VERR_ISO_FS_UNKNOWN_AD_TYPE; + } + if (cbAllocDescs >= cbOneDesc) + { + /* + * Loop thru the allocation descriptors. + */ + PRTFSISOEXTENT pCurExtent = NULL; + union + { + uint8_t const *pb; + PCUDFSHORTAD pShort; + PCUDFLONGAD pLong; + PCUDFEXTAD pExt; + } uPtr; + uPtr.pb = pbAllocDescs; + do + { + /* Extract the information we need from the descriptor. */ + uint32_t idxBlock; + uint32_t idxPart; + uint32_t cb; + uint8_t uType; + switch (fIcbTagFlags & UDF_ICB_FLAGS_AD_TYPE_MASK) + { + case UDF_ICB_FLAGS_AD_TYPE_SHORT: + uType = uPtr.pShort->uType; + cb = uPtr.pShort->cb; + idxBlock = uPtr.pShort->off; + idxPart = idxDefaultPart; + cbAllocDescs -= sizeof(*uPtr.pShort); + uPtr.pShort++; + break; + case UDF_ICB_FLAGS_AD_TYPE_LONG: + uType = uPtr.pLong->uType; + cb = uPtr.pLong->cb; + idxBlock = uPtr.pLong->Location.off; + idxPart = uPtr.pLong->Location.uPartitionNo; + cbAllocDescs -= sizeof(*uPtr.pLong); + uPtr.pLong++; + break; + case UDF_ICB_FLAGS_AD_TYPE_EXTENDED: + if ( uPtr.pExt->cbInformation > cbAllocDescs + || uPtr.pExt->cbInformation < sizeof(*uPtr.pExt)) + return VERR_ISOFS_BAD_EXTAD; + uType = uPtr.pExt->uType; + cb = uPtr.pExt->cb; + idxBlock = uPtr.pExt->Location.off; + idxPart = uPtr.pExt->Location.uPartitionNo; + cbAllocDescs -= uPtr.pExt->cbInformation; + uPtr.pb += uPtr.pExt->cbInformation; + break; + default: + AssertFailedReturn(VERR_IPE_NOT_REACHED_DEFAULT_CASE); + } + + /* Check if we can extend the current extent. This is useful since + the descriptors can typically only cover 1GB. */ + uint64_t const off = (uint64_t)idxBlock << pVol->Udf.VolInfo.cShiftBlock; + if ( pCurExtent != NULL + && ( pCurExtent->off != UINT64_MAX + ? uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED + && pCurExtent->off + pCurExtent->cbExtent == off + && pCurExtent->idxPart == idxPart + : uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED) ) + pCurExtent->cbExtent += cb; + else + { + /* Allocate a new descriptor. */ + if (pCore->cExtents == 0) + { + pCore->cExtents = 1; + pCurExtent = &pCore->FirstExtent; + } + else + { + void *pvNew = RTMemRealloc(pCore->paExtents, pCore->cExtents * sizeof(pCore->paExtents[0])); + if (pvNew) + pCore->paExtents = (PRTFSISOEXTENT)pvNew; + else + { + RTMemFree(pCore->paExtents); + pCore->paExtents = NULL; + pCore->cExtents = 0; + return VERR_NO_MEMORY; + } + pCurExtent = &pCore->paExtents[pCore->cExtents - 1]; + pCore->cExtents++; + } + + /* Initialize it. */ + if (uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED) + { + pCurExtent->off = off; + pCurExtent->idxPart = idxPart; + } + else + { + pCurExtent->off = UINT64_MAX; + pCurExtent->idxPart = UINT32_MAX; + } + pCurExtent->cbExtent = cb; + pCurExtent->uReserved = 0; + } + } while (cbAllocDescs >= cbOneDesc); + + if (cbAllocDescs > 0) + LogRelMax(45,("ISO/UDF: Warning! %u bytes left in allocation descriptor: %.*Rhxs\n", cbAllocDescs, cbAllocDescs, uPtr.pb)); + } + else + { + /* + * Zero descriptors + */ + pCore->cExtents = 0; + pCore->FirstExtent.off = UINT64_MAX; + pCore->FirstExtent.cbExtent = 0; + pCore->FirstExtent.idxPart = UINT32_MAX; + + if (cbAllocDescs > 0) + LogRelMax(45, ("ISO/UDF: Warning! Allocation descriptor area is shorted than one descriptor: %#u vs %#u: %.*Rhxs\n", + cbAllocDescs, cbOneDesc, cbAllocDescs, pbAllocDescs)); + } + return VINF_SUCCESS; +} + + +/** + * Converts ICB flags, ICB file type and file entry permissions to an IPRT file + * mode mask. + * + * @returns IPRT status ocde + * @param fIcbTagFlags The ICB flags. + * @param bFileType The ICB file type. + * @param fPermission The file entry permission mask. + * @param pfAttrib Where to return the IRPT file mode mask. + */ +static int rtFsIsoCore_UdfStuffToFileMode(uint32_t fIcbTagFlags, uint8_t bFileType, uint32_t fPermission, PRTFMODE pfAttrib) +{ + /* + * Type: + */ + RTFMODE fAttrib; + switch (bFileType) + { + case UDF_FILE_TYPE_DIRECTORY: + fAttrib = RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY; + break; + + case UDF_FILE_TYPE_REGULAR_FILE: + case UDF_FILE_TYPE_REAL_TIME_FILE: + fAttrib = RTFS_TYPE_FILE; + break; + + case UDF_FILE_TYPE_SYMBOLIC_LINK: + fAttrib = RTFS_TYPE_SYMLINK; + break; + + case UDF_FILE_TYPE_BLOCK_DEVICE: + fAttrib = RTFS_TYPE_DEV_BLOCK; + break; + case UDF_FILE_TYPE_CHARACTER_DEVICE: + fAttrib = RTFS_TYPE_DEV_CHAR; + break; + + case UDF_FILE_TYPE_FIFO: + fAttrib = RTFS_TYPE_FIFO; + break; + + case UDF_FILE_TYPE_SOCKET: + fAttrib = RTFS_TYPE_SOCKET; + break; + + case UDF_FILE_TYPE_STREAM_DIRECTORY: + case UDF_FILE_TYPE_EXTENDED_ATTRIBUTES: + case UDF_FILE_TYPE_TERMINAL_ENTRY: + case UDF_FILE_TYPE_VAT: + case UDF_FILE_TYPE_METADATA_FILE: + case UDF_FILE_TYPE_METADATA_MIRROR_FILE: + case UDF_FILE_TYPE_METADATA_BITMAP_FILE: + case UDF_FILE_TYPE_NOT_SPECIFIED: + case UDF_FILE_TYPE_INDIRECT_ENTRY: + case UDF_FILE_TYPE_UNALLOCATED_SPACE_ENTRY: + case UDF_FILE_TYPE_PARTITION_INTEGRITY_ENTRY: + LogRelMax(45, ("ISO/UDF: Warning! Wrong file type: %#x\n", bFileType)); + return VERR_ISOFS_WRONG_FILE_TYPE; + + default: + LogRelMax(45, ("ISO/UDF: Warning! Unknown file type: %#x\n", bFileType)); + return VERR_ISOFS_UNKNOWN_FILE_TYPE; + } + + /* + * Permissions: + */ + if (fPermission & UDF_PERM_OTH_EXEC) + fAttrib |= RTFS_UNIX_IXOTH; + if (fPermission & UDF_PERM_OTH_READ) + fAttrib |= RTFS_UNIX_IROTH; + if (fPermission & UDF_PERM_OTH_WRITE) + fAttrib |= RTFS_UNIX_IWOTH; + + if (fPermission & UDF_PERM_GRP_EXEC) + fAttrib |= RTFS_UNIX_IXGRP; + if (fPermission & UDF_PERM_GRP_READ) + fAttrib |= RTFS_UNIX_IRGRP; + if (fPermission & UDF_PERM_GRP_WRITE) + fAttrib |= RTFS_UNIX_IWGRP; + + if (fPermission & UDF_PERM_USR_EXEC) + fAttrib |= RTFS_UNIX_IXUSR; + if (fPermission & UDF_PERM_USR_READ) + fAttrib |= RTFS_UNIX_IRUSR; + if (fPermission & UDF_PERM_USR_WRITE) + fAttrib |= RTFS_UNIX_IWUSR; + + if ( !(fAttrib & (UDF_PERM_OTH_WRITE | UDF_PERM_GRP_WRITE | UDF_PERM_USR_WRITE)) + && (fAttrib & (UDF_PERM_OTH_READ | UDF_PERM_GRP_READ | UDF_PERM_USR_READ)) ) + fAttrib |= RTFS_DOS_READONLY; + + /* + * Attributes: + */ + if (fIcbTagFlags & UDF_ICB_FLAGS_ARCHIVE) + fAttrib |= RTFS_DOS_ARCHIVED; + if (fIcbTagFlags & UDF_ICB_FLAGS_SYSTEM) + fAttrib |= RTFS_DOS_SYSTEM; + if (fIcbTagFlags & UDF_ICB_FLAGS_ARCHIVE) + fAttrib |= RTFS_DOS_ARCHIVED; + + if (fIcbTagFlags & UDF_ICB_FLAGS_SET_UID) + fAttrib |= RTFS_UNIX_ISUID; + if (fIcbTagFlags & UDF_ICB_FLAGS_SET_GID) + fAttrib |= RTFS_UNIX_ISGID; + if (fIcbTagFlags & UDF_ICB_FLAGS_STICKY) + fAttrib |= RTFS_UNIX_ISTXT; + + /* Warn about weird flags. */ + if (fIcbTagFlags & UDF_ICB_FLAGS_TRANSFORMED) + LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_TRANSFORMED!\n")); + if (fIcbTagFlags & UDF_ICB_FLAGS_MULTI_VERSIONS) + LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_MULTI_VERSIONS!\n")); + if (fIcbTagFlags & UDF_ICB_FLAGS_STREAM) + LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_STREAM!\n")); + if (fIcbTagFlags & UDF_ICB_FLAGS_RESERVED_MASK) + LogRelMax(45, ("ISO/UDF: Warning! UDF_ICB_FLAGS_RESERVED_MASK (%#x)!\n", fIcbTagFlags & UDF_ICB_FLAGS_RESERVED_MASK)); + + *pfAttrib = fAttrib; + return VINF_SUCCESS; +} + + +/** + * Initialize/update a core object structure from an UDF extended file entry. + * + * @returns IPRT status code + * @param pCore The core object structure to initialize. + * @param pFileEntry The file entry. + * @param idxDefaultPart The default data partition. + * @param pcProcessed Variable to increment on success. + * @param pVol The volume instance. + */ +static int rtFsIsoCore_InitFromUdfIcbExFileEntry(PRTFSISOCORE pCore, PCUDFEXFILEENTRY pFileEntry, uint32_t idxDefaultPart, + uint32_t *pcProcessed, PRTFSISOVOL pVol) +{ +#ifdef LOG_ENABLED + /* + * Log it. + */ + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", IcbTag.cEntiresBeforeThis); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.uStrategyType); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[0]); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[1]); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.cMaxEntries); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bReserved); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bFileType); + UDF_LOG2_MEMBER_LBADDR(pFileEntry, IcbTag.ParentIcb); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.fFlags); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uid); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", gid); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", fPermissions); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", cHardlinks); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", uRecordFormat); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", fRecordDisplayAttribs); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbRecord); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbData); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbObject); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cLogicalBlocks); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, AccessTime); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ModificationTime); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, BirthTime); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ChangeTime); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uCheckpoint); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uReserved); + UDF_LOG2_MEMBER_LONGAD(pFileEntry, ExtAttribIcb); + UDF_LOG2_MEMBER_LONGAD(pFileEntry, StreamDirIcb); + UDF_LOG2_MEMBER_ENTITY_ID(pFileEntry, idImplementation); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", INodeId); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbExtAttribs); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbAllocDescs); + if (pFileEntry->cbExtAttribs > 0) + Log2((pFileEntry->cbExtAttribs <= 16 ? "ISO/UDF: %-32s %.*Rhxs\n" : "ISO/UDF: %-32s\n%.*RhxD\n", + "abExtAttribs:", pFileEntry->cbExtAttribs, pFileEntry->abExtAttribs)); + if (pFileEntry->cbAllocDescs > 0) + switch (pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK) + { + case UDF_ICB_FLAGS_AD_TYPE_SHORT: + { + PCUDFSHORTAD paDescs = (PCUDFSHORTAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]; + uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]); + for (uint32_t i = 0; i < cDescs; i++) + Log2(("ISO/UDF: ShortAD[%u]: %#010RX32 LB %#010RX32; type=%u\n", + i, paDescs[i].off, paDescs[i].cb, paDescs[i].uType)); + break; + } + case UDF_ICB_FLAGS_AD_TYPE_LONG: + { + PCUDFLONGAD paDescs = (PCUDFLONGAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]; + uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]); + for (uint32_t i = 0; i < cDescs; i++) + Log2(("ISO/UDF: LongAD[%u]: %#06RX16:%#010RX32 LB %#010RX32; type=%u iu=%.6Rhxs\n", + i, paDescs[i].Location.uPartitionNo, paDescs[i].Location.off, + paDescs[i].cb, paDescs[i].uType, &paDescs[i].ImplementationUse)); + break; + } + default: + Log2(("ISO/UDF: %-32s Type=%u\n%.*RhxD\n", + "abExtAttribs:", pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK, + pFileEntry->cbAllocDescs, &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs])); + break; + } + } +#endif + + /* + * Basic sanity checking of what we use. + */ + if ( RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs + > pVol->Udf.VolInfo.cbBlock + || (pFileEntry->cbExtAttribs & 3) != 0 + || pFileEntry->cbExtAttribs >= pVol->Udf.VolInfo.cbBlock + || (pFileEntry->cbAllocDescs & 3) != 0 + || pFileEntry->cbAllocDescs >= pVol->Udf.VolInfo.cbBlock) + { + LogRelMax(45, ("ISO/UDF: Extended file entry (ICB) is bad size values: cbAllocDesc=%#x cbExtAttribs=%#x (cbBlock=%#x)\n", + pFileEntry->cbAllocDescs, pFileEntry->cbExtAttribs, pVol->Udf.VolInfo.cbBlock)); + return VERR_ISOFS_BAD_FILE_ENTRY; + } + + //pCore->uid = pFileEntry->uid; + //pCore->gid = pFileEntry->gid; + //pCore->cHardlinks = RT_MIN(pFileEntry->cHardlinks, 1); + pCore->cbObject = pFileEntry->cbData; + //pCore->cbAllocated = pFileEntry->cLogicalBlocks << pVol->Udf.VolInfo.cShiftBlock; + pCore->idINode = pFileEntry->INodeId; + + rtFsIsoUdfTimestamp2TimeSpec(&pCore->AccessTime, &pFileEntry->AccessTime); + rtFsIsoUdfTimestamp2TimeSpec(&pCore->ModificationTime, &pFileEntry->ModificationTime); + rtFsIsoUdfTimestamp2TimeSpec(&pCore->BirthTime, &pFileEntry->BirthTime); + rtFsIsoUdfTimestamp2TimeSpec(&pCore->ChangeTime, &pFileEntry->ChangeTime); + + if ( pFileEntry->uRecordFormat + || pFileEntry->fRecordDisplayAttribs + || pFileEntry->cbRecord) + LogRelMax(45, ("ISO/UDF: uRecordFormat=%#x fRecordDisplayAttribs=%#x cbRecord=%#x\n", + pFileEntry->uRecordFormat, pFileEntry->fRecordDisplayAttribs, pFileEntry->cbRecord)); + + /* + * Conver the file mode. + */ + int rc = rtFsIsoCore_UdfStuffToFileMode(pFileEntry->IcbTag.fFlags, pFileEntry->IcbTag.bFileType, + pFileEntry->fPermissions, &pCore->fAttrib); + if (RT_SUCCESS(rc)) + { + /* + * Convert extent info. + */ + rc = rtFsIsoCore_InitExtentsUdfIcbEntry(pCore, + &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs], + pFileEntry->cbAllocDescs, + pFileEntry->IcbTag.fFlags, + idxDefaultPart, + ((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock) + + RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs, + pVol); + if (RT_SUCCESS(rc)) + { + /* + * We're good. + */ + *pcProcessed += 1; + return VINF_SUCCESS; + } + + /* Just in case. */ + if (pCore->paExtents) + { + RTMemFree(pCore->paExtents); + pCore->paExtents = NULL; + } + pCore->cExtents = 0; + } + return rc; +} + + +/** + * Initialize/update a core object structure from an UDF file entry. + * + * @returns IPRT status code + * @param pCore The core object structure to initialize. + * @param pFileEntry The file entry. + * @param idxDefaultPart The default data partition. + * @param pcProcessed Variable to increment on success. + * @param pVol The volume instance. + */ +static int rtFsIsoCore_InitFromUdfIcbFileEntry(PRTFSISOCORE pCore, PCUDFFILEENTRY pFileEntry, uint32_t idxDefaultPart, + uint32_t *pcProcessed, PRTFSISOVOL pVol) +{ +#ifdef LOG_ENABLED + /* + * Log it. + */ + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", IcbTag.cEntiresBeforeThis); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.uStrategyType); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[0]); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.abStrategyParams[1]); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.cMaxEntries); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bReserved); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", IcbTag.bFileType); + UDF_LOG2_MEMBER_LBADDR(pFileEntry, IcbTag.ParentIcb); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", IcbTag.fFlags); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uid); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", gid); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", fPermissions); + UDF_LOG2_MEMBER(pFileEntry, "#06RX16", cHardlinks); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", uRecordFormat); + UDF_LOG2_MEMBER(pFileEntry, "#04RX8", fRecordDisplayAttribs); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbRecord); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cbData); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", cLogicalBlocks); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, AccessTime); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ModificationTime); + UDF_LOG2_MEMBER_TIMESTAMP(pFileEntry, ChangeTime); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", uCheckpoint); + UDF_LOG2_MEMBER_LONGAD(pFileEntry, ExtAttribIcb); + UDF_LOG2_MEMBER_ENTITY_ID(pFileEntry, idImplementation); + UDF_LOG2_MEMBER(pFileEntry, "#018RX64", INodeId); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbExtAttribs); + UDF_LOG2_MEMBER(pFileEntry, "#010RX32", cbAllocDescs); + if (pFileEntry->cbExtAttribs > 0) + Log2((pFileEntry->cbExtAttribs <= 16 ? "ISO/UDF: %-32s %.*Rhxs\n" : "ISO/UDF: %-32s\n%.*RhxD\n", + "abExtAttribs:", pFileEntry->cbExtAttribs, pFileEntry->abExtAttribs)); + if (pFileEntry->cbAllocDescs > 0) + switch (pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK) + { + case UDF_ICB_FLAGS_AD_TYPE_SHORT: + { + PCUDFSHORTAD paDescs = (PCUDFSHORTAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]; + uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]); + for (uint32_t i = 0; i < cDescs; i++) + Log2(("ISO/UDF: ShortAD[%u]: %#010RX32 LB %#010RX32; type=%u\n", + i, paDescs[i].off, paDescs[i].cb, paDescs[i].uType)); + break; + } + case UDF_ICB_FLAGS_AD_TYPE_LONG: + { + PCUDFLONGAD paDescs = (PCUDFLONGAD)&pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs]; + uint32_t cDescs = pFileEntry->cbAllocDescs / sizeof(paDescs[0]); + for (uint32_t i = 0; i < cDescs; i++) + Log2(("ISO/UDF: LongAD[%u]: %#06RX16:%#010RX32 LB %#010RX32; type=%u iu=%.6Rhxs\n", + i, paDescs[i].Location.uPartitionNo, paDescs[i].Location.off, + paDescs[i].cb, paDescs[i].uType, &paDescs[i].ImplementationUse)); + break; + } + default: + Log2(("ISO/UDF: %-32s Type=%u\n%.*RhxD\n", + "abExtAttribs:", pFileEntry->IcbTag.fFlags & UDF_ICB_FLAGS_AD_TYPE_MASK, + pFileEntry->cbAllocDescs, &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs])); + break; + } + } +#endif + + /* + * Basic sanity checking of what we use. + */ + if ( RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs + pFileEntry->cbAllocDescs + > pVol->Udf.VolInfo.cbBlock + || (pFileEntry->cbExtAttribs & 3) != 0 + || pFileEntry->cbExtAttribs >= pVol->Udf.VolInfo.cbBlock + || (pFileEntry->cbAllocDescs & 3) != 0 + || pFileEntry->cbAllocDescs >= pVol->Udf.VolInfo.cbBlock) + { + LogRelMax(45, ("ISO/UDF: File entry (ICB) is bad size values: cbAllocDesc=%#x cbExtAttribs=%#x (cbBlock=%#x)\n", + pFileEntry->cbAllocDescs, pFileEntry->cbExtAttribs, pVol->Udf.VolInfo.cbBlock)); + return VERR_ISOFS_BAD_FILE_ENTRY; + } + + //pCore->uid = pFileEntry->uid; + //pCore->gid = pFileEntry->gid; + //pCore->cHardlinks = RT_MIN(pFileEntry->cHardlinks, 1); + pCore->cbObject = pFileEntry->cbData; + //pCore->cbAllocated = pFileEntry->cLogicalBlocks << pVol->Udf.VolInfo.cShiftBlock; + pCore->idINode = pFileEntry->INodeId; + + rtFsIsoUdfTimestamp2TimeSpec(&pCore->AccessTime, &pFileEntry->AccessTime); + rtFsIsoUdfTimestamp2TimeSpec(&pCore->ModificationTime, &pFileEntry->ModificationTime); + rtFsIsoUdfTimestamp2TimeSpec(&pCore->ChangeTime, &pFileEntry->ChangeTime); + pCore->BirthTime = pCore->ModificationTime; + if (RTTimeSpecCompare(&pCore->BirthTime, &pCore->ChangeTime) > 0) + pCore->BirthTime = pCore->ChangeTime; + if (RTTimeSpecCompare(&pCore->BirthTime, &pCore->AccessTime) > 0) + pCore->BirthTime = pCore->AccessTime; + + if ( pFileEntry->uRecordFormat + || pFileEntry->fRecordDisplayAttribs + || pFileEntry->cbRecord) + LogRelMax(45, ("ISO/UDF: uRecordFormat=%#x fRecordDisplayAttribs=%#x cbRecord=%#x\n", + pFileEntry->uRecordFormat, pFileEntry->fRecordDisplayAttribs, pFileEntry->cbRecord)); + + /* + * Conver the file mode. + */ + int rc = rtFsIsoCore_UdfStuffToFileMode(pFileEntry->IcbTag.fFlags, pFileEntry->IcbTag.bFileType, + pFileEntry->fPermissions, &pCore->fAttrib); + if (RT_SUCCESS(rc)) + { + /* + * Convert extent info. + */ + rc = rtFsIsoCore_InitExtentsUdfIcbEntry(pCore, + &pFileEntry->abExtAttribs[pFileEntry->cbExtAttribs], + pFileEntry->cbAllocDescs, + pFileEntry->IcbTag.fFlags, + idxDefaultPart, + ((uint64_t)pFileEntry->Tag.offTag << pVol->Udf.VolInfo.cShiftBlock) + + RT_UOFFSETOF(UDFFILEENTRY, abExtAttribs) + pFileEntry->cbExtAttribs, + pVol); + if (RT_SUCCESS(rc)) + { + /* + * We're good. + */ + *pcProcessed += 1; + return VINF_SUCCESS; + } + + /* Just in case. */ + if (pCore->paExtents) + { + RTMemFree(pCore->paExtents); + pCore->paExtents = NULL; + } + pCore->cExtents = 0; + } + return rc; +} + + +/** + * Recursive helper for rtFsIsoCore_InitFromUdfIcbAndFileIdDesc. + * + * @returns IRPT status code. + * @param pCore The core structure to initialize. + * @param AllocDesc The ICB allocation descriptor. + * @param pbBuf The buffer, one logical block in size. + * @param cNestings The number of recursive nestings (should be zero). + * @param pcProcessed Variable to update when we've processed something + * useful. + * @param pcIndirections Variable tracing the number of indirections we've + * taken during the processing. This is used to + * prevent us from looping forever on a bad chain + * @param pVol The volue instance data. + */ +static int rtFsIsoCore_InitFromUdfIcbRecursive(PRTFSISOCORE pCore, UDFLONGAD AllocDesc, uint8_t *pbBuf, uint32_t cNestings, + uint32_t *pcProcessed, uint32_t *pcIndirections, PRTFSISOVOL pVol) +{ + if (cNestings >= 8) + return VERR_ISOFS_TOO_DEEP_ICB_RECURSION; + + for (;;) + { + if (*pcIndirections >= 32) + return VERR_ISOFS_TOO_MANY_ICB_INDIRECTIONS; + + /* + * Check the basic validity of the allocation descriptor. + */ + if ( AllocDesc.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED + && AllocDesc.cb >= sizeof(UDFICBTAG) ) + { /* likely */ } + else if (AllocDesc.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED) + { + Log(("ISO/UDF: ICB has alloc type %d!\n", AllocDesc.uType)); + return VINF_SUCCESS; + } + else + { + LogRelMax(45, ("ISO/UDF: ICB is too small: %u bytes\n", AllocDesc.cb)); + return AllocDesc.cb == 0 ? VINF_SUCCESS : VERR_ISOFS_ICB_ENTRY_TOO_SMALL; + } + + /* + * Process it block by block. + */ + uint32_t cBlocks = (AllocDesc.cb + pVol->Udf.VolInfo.cbBlock - 1) >> pVol->Udf.VolInfo.cShiftBlock; + for (uint32_t idxBlock = 0; ; idxBlock++) + { + /* + * Read a block + */ + size_t cbToRead = RT_MIN(pVol->Udf.VolInfo.cbBlock, AllocDesc.cb); + int rc = rtFsIsoVolUdfVpRead(pVol, AllocDesc.Location.uPartitionNo, AllocDesc.Location.off + idxBlock, 0, + pbBuf, cbToRead); + if (RT_FAILURE(rc)) + return rc; + if (cbToRead < pVol->Udf.VolInfo.cbBlock) + RT_BZERO(&pbBuf[cbToRead], pVol->Udf.VolInfo.cbBlock - cbToRead); + + /* + * Verify the TAG. + */ + PUDFICBHDR pHdr = (PUDFICBHDR)pbBuf; + rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pHdr->Tag, pVol->Udf.VolInfo.cbBlock, UINT16_MAX, + AllocDesc.Location.off + idxBlock, NULL); + if (RT_FAILURE(rc)) + return rc; + + /* + * Do specific processing. + */ + if (pHdr->Tag.idTag == UDF_TAG_ID_FILE_ENTRY) + rc = rtFsIsoCore_InitFromUdfIcbFileEntry(pCore, (PCUDFFILEENTRY)pHdr, AllocDesc.Location.uPartitionNo, + pcProcessed, pVol); + else if (pHdr->Tag.idTag == UDF_TAG_ID_EXTENDED_FILE_ENTRY) + rc = rtFsIsoCore_InitFromUdfIcbExFileEntry(pCore, (PCUDFEXFILEENTRY)pHdr, AllocDesc.Location.uPartitionNo, + pcProcessed, pVol); + else if (pHdr->Tag.idTag == UDF_TAG_ID_INDIRECT_ENTRY) + { + PUDFINDIRECTENTRY pIndir = (PUDFINDIRECTENTRY)pHdr; + *pcIndirections += 1; + if (pIndir->IndirectIcb.cb != 0) + { + if (idxBlock + 1 == cBlocks) + { + AllocDesc = pIndir->IndirectIcb; + Log2(("ISO/UDF: ICB: Indirect entry - looping: %x:%#010RX32 LB %#x; uType=%d\n", + AllocDesc.Location.uPartitionNo, AllocDesc.Location.off, AllocDesc.cb, AllocDesc.uType)); + break; + } + Log2(("ISO/UDF: ICB: Indirect entry - recursing: %x:%#010RX32 LB %#x; uType=%d\n", + pIndir->IndirectIcb.Location.uPartitionNo, pIndir->IndirectIcb.Location.off, + pIndir->IndirectIcb.cb, pIndir->IndirectIcb.uType)); + rc = rtFsIsoCore_InitFromUdfIcbRecursive(pCore, pIndir->IndirectIcb, pbBuf, cNestings, + pcProcessed, pcIndirections, pVol); + } + else + Log(("ISO/UDF: zero length indirect entry\n")); + } + else if (pHdr->Tag.idTag == UDF_TAG_ID_TERMINAL_ENTRY) + { + Log2(("ISO/UDF: Terminal ICB entry\n")); + return VINF_SUCCESS; + } + else if (pHdr->Tag.idTag == UDF_TAG_ID_UNALLOCATED_SPACE_ENTRY) + { + Log2(("ISO/UDF: Unallocated space entry: skipping\n")); + /* Ignore since we don't do writing (UDFUNALLOCATEDSPACEENTRY) */ + } + else + { + LogRelMax(90, ("ISO/UDF: Unknown ICB type %#x\n", pHdr->Tag.idTag)); + return VERR_ISOFS_UNSUPPORTED_ICB; + } + if (RT_FAILURE(rc)) + return rc; + + /* + * Advance. + */ + if (idxBlock + 1 >= cBlocks) + return VINF_SUCCESS; + } + + /* If we get here, we've jumped thru an indirect entry. */ + } + /* never reached */ +} + + + +/** + * Initialize a core structure from an UDF ICB range and optionally a file ID. + * + * @returns IPRT status code. + * @param pCore The core structure to initialize. + * Caller must've ZEROed this structure! + * @param pAllocDesc The ICB allocation descriptor. + * @param pFid The file ID descriptor. Optional. + * @param offInDir The offset of the file ID descriptor in the + * parent directory. This is used when looking up + * shared directory objects. (Pass 0 for root.) + * @param pVol The instance. + * + * @note Caller must check for UDF_FILE_FLAGS_DELETED before calling if the + * object is supposed to be used for real stuff. + */ +static int rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(PRTFSISOCORE pCore, PCUDFLONGAD pAllocDesc, + PCUDFFILEIDDESC pFid, uintptr_t offInDir, PRTFSISOVOL pVol) +{ + Assert(pCore->cRefs == 0); + Assert(pCore->cExtents == 0); + Assert(pCore->paExtents == NULL); + Assert(pCore->pVol == NULL); + + /* + * Some size sanity checking. + */ + if (pAllocDesc->cb <= _64K) + { + if (pAllocDesc->cb >= sizeof(UDFICBHDR)) + { /* likely */ } + else + { + Log(("rtFsIsoCore_InitFromUdfIcbAndFileIdDesc: ICB too small: %#04x:%010RX32 LB %#x\n", + pAllocDesc->Location.uPartitionNo, pAllocDesc->Location.off, pAllocDesc->cb)); + return VERR_ISOFS_ICB_TOO_SMALL; + } + } + else + { + Log(("rtFsIsoCore_InitFromUdfIcbAndFileIdDesc: ICB too big: %#04x:%010RX32 LB %#x\n", + pAllocDesc->Location.uPartitionNo, pAllocDesc->Location.off, pAllocDesc->cb)); + return VERR_ISOFS_ICB_TOO_BIG; + } + + /* + * Allocate a temporary buffer, one logical block in size. + */ + uint8_t * const pbBuf = (uint8_t *)RTMemTmpAlloc(pVol->Udf.VolInfo.cbBlock); + if (pbBuf) + { + uint32_t cProcessed = 0; + uint32_t cIndirections = 0; + int rc = rtFsIsoCore_InitFromUdfIcbRecursive(pCore, *pAllocDesc, pbBuf, 0, &cProcessed, &cIndirections, pVol); + RTMemTmpFree(pbBuf); + if (RT_SUCCESS(rc)) + { + if (cProcessed > 0) + { + if (pFid) + { + if (pFid->fFlags & UDF_FILE_FLAGS_HIDDEN) + pCore->fAttrib |= RTFS_DOS_HIDDEN; + if (pFid->fFlags & UDF_FILE_FLAGS_DELETED) + pCore->fAttrib = (pCore->fAttrib & ~RTFS_TYPE_MASK) | RTFS_TYPE_WHITEOUT; + } + + pCore->cRefs = 1; + pCore->pVol = pVol; + pCore->offDirRec = offInDir; + return VINF_SUCCESS; + } + rc = VERR_ISOFS_NO_DIRECT_ICB_ENTRIES; + } + + /* White-out fix. Caller must be checking for UDF_FILE_FLAGS_DELETED */ + if ( pFid + && (pFid->fFlags & UDF_FILE_FLAGS_DELETED)) + { + pCore->fAttrib = (pCore->fAttrib & ~RTFS_TYPE_MASK) | RTFS_TYPE_WHITEOUT; + return VINF_SUCCESS; + } + return rc; + } + + pCore->pVol = NULL; + return VERR_NO_TMP_MEMORY; +} + + +/** + * Simple UDF read function. + * + * This deals with extent mappings as well as virtual partition related block + * mapping and such. + * + * @returns VBox status code. + * @param pCore The core object to read data from. + * @param offRead The offset to start reading at. + * @param pvBuf The output buffer. + * @param cbToRead The number of bytes to read. + * @param pcbRead Where to return the number of bytes read. + * @param poffPosMov Where to return the number of bytes to move the read + * position. Optional. (Essentially same as pcbRead + * except without the behavior change.) + */ +static int rtFsIsoCore_ReadWorker(PRTFSISOCORE pCore, uint64_t offRead, void *pvBuf, size_t cbToRead, + size_t *pcbRead, size_t *poffPosMov) +{ + /* + * Check for EOF. + */ + if (offRead >= pCore->cbObject) + { + if (poffPosMov) + *poffPosMov = 0; + if (pcbRead) + { + *pcbRead = 0; + return VINF_EOF; + } + return VERR_EOF; + } + int rcRet = VINF_SUCCESS; + if ( cbToRead > pCore->cbObject + || offRead + cbToRead > pCore->cbObject) + { + if (!pcbRead) + { + if (poffPosMov) + *poffPosMov = 0; + return VERR_EOF; + } + cbToRead = pCore->cbObject - offRead; + rcRet = VINF_EOF; + } + + uint64_t cbActual = 0; + + /* + * Don't bother looking up the extent if we're not going to + * read anything from it. + */ + if (cbToRead > 0) + { + /* + * Locate the first extent. + */ + uint64_t offExtent = 0; + uint32_t iExtent = 0; + PCRTFSISOEXTENT pCurExtent = &pCore->FirstExtent; + if (offRead < pCurExtent->cbExtent) + { /* likely */ } + else + do + { + offExtent += pCurExtent->cbExtent; + pCurExtent = &pCore->paExtents[iExtent++]; + if (iExtent >= pCore->cExtents) + { + memset(pvBuf, 0, cbToRead); + + if (pcbRead) + *pcbRead = cbToRead; + if (poffPosMov) + *poffPosMov = cbToRead; + return rcRet; + } + } while (offExtent < offRead); + Assert(offRead - offExtent < pCurExtent->cbExtent); + + /* + * Do the reading part. + */ + PRTFSISOVOL pVol = pCore->pVol; + for (;;) + { + uint64_t offIntoExtent = offRead - offExtent; + size_t cbThisRead = pCurExtent->cbExtent - offIntoExtent; + if (cbThisRead > cbToRead) + cbThisRead = cbToRead; + + if (pCurExtent->off == UINT64_MAX) + RT_BZERO(pvBuf, cbThisRead); + else + { + int rc2; + if (pCurExtent->idxPart == UINT32_MAX) + rc2 = RTVfsFileReadAt(pVol->hVfsBacking, pCurExtent->off + offIntoExtent, pvBuf, cbThisRead, NULL); + else + { + Assert(pVol->enmType == RTFSISOVOLTYPE_UDF); + if (pCurExtent->idxPart < pVol->Udf.VolInfo.cPartitions) + { + PRTFSISOVOLUDFPMAP pPart = &pVol->Udf.VolInfo.paPartitions[pCurExtent->idxPart]; + switch (pPart->bType) + { + case RTFSISO_UDF_PMAP_T_PLAIN: + rc2 = RTVfsFileReadAt(pVol->hVfsBacking, pPart->offByteLocation + pCurExtent->off + offIntoExtent, + pvBuf, cbThisRead, NULL); + break; + + default: + AssertFailed(); + rc2 = VERR_ISOFS_IPE_1; + break; + } + } + else + { + Log(("ISO/UDF: Invalid partition index %#x (offset %#RX64), max partitions %#x; iExtent=%#x\n", + pCurExtent->idxPart, pCurExtent->off + offIntoExtent, pVol->Udf.VolInfo.cPartitions, iExtent)); + rc2 = VERR_ISOFS_INVALID_PARTITION_INDEX; + } + } + if (RT_FAILURE(rc2)) + { + rcRet = rc2; + break; + } + } + + /* + * Advance the buffer position and check if we're done (probable). + */ + cbActual += cbThisRead; + cbToRead -= cbThisRead; + if (!cbToRead) + break; + pvBuf = (uint8_t *)pvBuf + cbThisRead; + + /* + * Advance to the next extent. + */ + offExtent += pCurExtent->cbExtent; + pCurExtent = &pCore->paExtents[iExtent++]; + if (iExtent >= pCore->cExtents) + { + memset(pvBuf, 0, cbToRead); + cbActual += cbToRead; + break; + } + } + } + else + Assert(rcRet == VINF_SUCCESS); + + if (poffPosMov) + *poffPosMov = cbActual; + if (pcbRead) + *pcbRead = cbActual; + return rcRet; +} + + +/** + * Worker for rtFsIsoFile_QueryInfo and rtFsIsoDir_QueryInfo. + */ +static int rtFsIsoCore_QueryInfo(PRTFSISOCORE pCore, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + pObjInfo->cbObject = pCore->cbObject; + pObjInfo->cbAllocated = RT_ALIGN_64(pCore->cbObject, pCore->pVol->cbBlock); + pObjInfo->AccessTime = pCore->AccessTime; + pObjInfo->ModificationTime = pCore->ModificationTime; + pObjInfo->ChangeTime = pCore->ChangeTime; + pObjInfo->BirthTime = pCore->BirthTime; + pObjInfo->Attr.fMode = pCore->fAttrib; + pObjInfo->Attr.enmAdditional = enmAddAttr; + + switch (enmAddAttr) + { + case RTFSOBJATTRADD_NOTHING: RT_FALL_THRU(); + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.u.Unix.uid = NIL_RTUID; + pObjInfo->Attr.u.Unix.gid = NIL_RTGID; + pObjInfo->Attr.u.Unix.cHardlinks = 1; + pObjInfo->Attr.u.Unix.INodeIdDevice = 0; + pObjInfo->Attr.u.Unix.INodeId = pCore->idINode; + pObjInfo->Attr.u.Unix.fFlags = 0; + pObjInfo->Attr.u.Unix.GenerationId = pCore->uVersion; + pObjInfo->Attr.u.Unix.Device = 0; + break; + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = 0; + pObjInfo->Attr.u.UnixOwner.szName[0] = '\0'; + break; + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = 0; + pObjInfo->Attr.u.UnixGroup.szName[0] = '\0'; + break; + case RTFSOBJATTRADD_EASIZE: + pObjInfo->Attr.u.EASize.cb = 0; + break; + default: + return VERR_INVALID_PARAMETER; + } + return VINF_SUCCESS; +} + + +/** + * Worker for rtFsIsoFile_Close and rtFsIsoDir_Close that does common work. + * + * @param pCore The common shared structure. + */ +static void rtFsIsoCore_Destroy(PRTFSISOCORE pCore) +{ + if (pCore->pParentDir) + rtFsIsoDirShrd_RemoveOpenChild(pCore->pParentDir, pCore); + if (pCore->paExtents) + { + RTMemFree(pCore->paExtents); + pCore->paExtents = NULL; + } +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsIsoFile_Close(void *pvThis) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + LogFlow(("rtFsIsoFile_Close(%p/%p)\n", pThis, pThis->pShared)); + + PRTFSISOFILESHRD pShared = pThis->pShared; + pThis->pShared = NULL; + if (pShared) + { + if (ASMAtomicDecU32(&pShared->Core.cRefs) == 0) + { + LogFlow(("rtFsIsoFile_Close: Destroying shared structure %p\n", pShared)); + rtFsIsoCore_Destroy(&pShared->Core); + RTMemFree(pShared); + } + } + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsIsoFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + return rtFsIsoCore_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsIsoFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + PRTFSISOFILESHRD pShared = pThis->pShared; + AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + +#if 1 + /* Apply default offset. */ + if (off == -1) + off = pThis->offFile; + else + AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3); + + /* Do the read. */ + size_t offDelta = 0; + int rc = rtFsIsoCore_ReadWorker(&pShared->Core, off, (uint8_t *)pSgBuf->paSegs[0].pvSeg, + pSgBuf->paSegs[0].cbSeg, pcbRead, &offDelta); + + /* Update the file position and return. */ + pThis->offFile = off + offDelta; + return rc; +#else + + + /* + * Check for EOF. + */ + if (off == -1) + off = pThis->offFile; + if ((uint64_t)off >= pShared->Core.cbObject) + { + if (pcbRead) + { + *pcbRead = 0; + return VINF_EOF; + } + return VERR_EOF; + } + + if (pShared->Core.pVol->enmType == RTFSISOVOLTYPE_UDF) + { + return VERR_ISOFS_UDF_NOT_IMPLEMENTED; + } + + /* + * Simple case: File has a single extent. + */ + int rc = VINF_SUCCESS; + size_t cbRead = 0; + uint64_t cbFileLeft = pShared->Core.cbObject - (uint64_t)off; + size_t cbLeft = pSgBuf->paSegs[0].cbSeg; + uint8_t *pbDst = (uint8_t *)pSgBuf->paSegs[0].pvSeg; + if (pShared->Core.cExtents == 1) + { + if (cbLeft > 0) + { + size_t cbToRead = cbLeft; + if (cbToRead > cbFileLeft) + cbToRead = (size_t)cbFileLeft; + rc = RTVfsFileReadAt(pShared->Core.pVol->hVfsBacking, pShared->Core.FirstExtent.off + off, pbDst, cbToRead, NULL); + if (RT_SUCCESS(rc)) + { + off += cbToRead; + pbDst += cbToRead; + cbRead += cbToRead; + cbFileLeft -= cbToRead; + cbLeft -= cbToRead; + } + } + } + /* + * Complicated case: Work the file content extent by extent. + */ + else + { + return VERR_NOT_IMPLEMENTED; /** @todo multi-extent stuff . */ + } + + /* Update the offset and return. */ + pThis->offFile = off; + if (pcbRead) + *pcbRead = cbRead; + return VINF_SUCCESS; +#endif +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsIsoFile_Flush(void *pvThis) +{ + RT_NOREF(pvThis); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnPollOne} + */ +static DECLCALLBACK(int) rtFsIsoFile_PollOne(void *pvThis, uint32_t fEvents, RTMSINTERVAL cMillies, bool fIntr, + uint32_t *pfRetEvents) +{ + NOREF(pvThis); + int rc; + if (fEvents != RTPOLL_EVT_ERROR) + { + *pfRetEvents = fEvents & ~RTPOLL_EVT_ERROR; + rc = VINF_SUCCESS; + } + else if (fIntr) + rc = RTThreadSleep(cMillies); + else + { + uint64_t uMsStart = RTTimeMilliTS(); + do + rc = RTThreadSleep(cMillies); + while ( rc == VERR_INTERRUPTED + && !fIntr + && RTTimeMilliTS() - uMsStart < cMillies); + if (rc == VERR_INTERRUPTED) + rc = VERR_TIMEOUT; + } + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsIsoFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + *poffActual = pThis->offFile; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsIsoFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + RTFOFF offNew; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offNew = offSeek; + break; + case RTFILE_SEEK_END: + offNew = (RTFOFF)pThis->pShared->Core.cbObject + offSeek; + break; + case RTFILE_SEEK_CURRENT: + offNew = (RTFOFF)pThis->offFile + offSeek; + break; + default: + return VERR_INVALID_PARAMETER; + } + if (offNew >= 0) + { + if (offNew <= _4G) + { + pThis->offFile = offNew; + *poffActual = offNew; + return VINF_SUCCESS; + } + return VERR_OUT_OF_RANGE; + } + return VERR_NEGATIVE_SEEK; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsIsoFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSISOFILEOBJ pThis = (PRTFSISOFILEOBJ)pvThis; + *pcbFile = pThis->pShared->Core.cbObject; + return VINF_SUCCESS; +} + + +/** + * ISO FS file operations. + */ +DECL_HIDDEN_CONST(const RTVFSFILEOPS) g_rtFsIsoFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "FatFile", + rtFsIsoFile_Close, + rtFsIsoFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsIsoFile_Read, + NULL /*Write*/, + rtFsIsoFile_Flush, + rtFsIsoFile_PollOne, + rtFsIsoFile_Tell, + NULL /*pfnSkip*/, + NULL /*pfnZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + NULL /*SetMode*/, + NULL /*SetTimes*/, + NULL /*SetOwner*/, + RTVFSOBJSETOPS_VERSION + }, + rtFsIsoFile_Seek, + rtFsIsoFile_QuerySize, + NULL /*SetSize*/, + NULL /*QueryMaxSize*/, + RTVFSFILEOPS_VERSION +}; + + +/** + * Instantiates a new file, from ISO 9660 info. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory (shared part). + * @param pDirRec The directory record. + * @param cDirRecs Number of directory records if more than one. + * @param offDirRec The byte offset of the directory record. + * @param offEntryInDir The byte offset of the directory entry in the parent + * directory. + * @param fOpen RTFILE_O_XXX flags. + * @param uVersion The file version number (since the caller already + * parsed the filename, we don't want to repeat the + * effort here). + * @param phVfsFile Where to return the file handle. + */ +static int rtFsIsoFile_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec, uint32_t cDirRecs, + uint64_t offDirRec, uint64_t fOpen, uint32_t uVersion, PRTVFSFILE phVfsFile) +{ + AssertPtr(pParentDir); + + /* + * Create a VFS object. + */ + PRTFSISOFILEOBJ pNewFile; + int rc = RTVfsNewFile(&g_rtFsIsoFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + /* + * Look for existing shared object, create a new one if necessary. + */ + PRTFSISOFILESHRD pShared = (PRTFSISOFILESHRD)rtFsIsoDir_LookupShared(pParentDir, offDirRec); + if (pShared) + { + LogFlow(("rtFsIsoFile_New9660: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n", + pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent)); + pNewFile->offFile = 0; + pNewFile->pShared = pShared; + return VINF_SUCCESS; + } + + pShared = (PRTFSISOFILESHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + rc = rtFsIsoCore_InitFrom9660DirRec(&pShared->Core, pDirRec, cDirRecs, offDirRec, uVersion, pThis); + if (RT_SUCCESS(rc)) + { + rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core); + LogFlow(("rtFsIsoFile_New9660: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n", + pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent)); + pNewFile->offFile = 0; + pNewFile->pShared = pShared; + return VINF_SUCCESS; + } + RTMemFree(pShared); + } + else + rc = VERR_NO_MEMORY; + + /* Destroy the file object. */ + pNewFile->offFile = 0; + pNewFile->pShared = NULL; + RTVfsFileRelease(*phVfsFile); + } + *phVfsFile = NIL_RTVFSFILE; + return rc; +} + + +/** + * Instantiates a new file, from UDF info. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory (shared part). + * @param pFid The file ID descriptor. (Points to parent directory + * content.) + * @param fOpen RTFILE_O_XXX flags. + * @param phVfsFile Where to return the file handle. + */ +static int rtFsIsoFile_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid, + uint64_t fOpen, PRTVFSFILE phVfsFile) +{ + AssertPtr(pParentDir); + uintptr_t const offInDir = (uintptr_t)pFid - (uintptr_t)pParentDir->pbDir; + Assert(offInDir < pParentDir->cbDir); + Assert(!(pFid->fFlags & UDF_FILE_FLAGS_DELETED)); + Assert(!(pFid->fFlags & UDF_FILE_FLAGS_DIRECTORY)); + + /* + * Create a VFS object. + */ + PRTFSISOFILEOBJ pNewFile; + int rc = RTVfsNewFile(&g_rtFsIsoFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK /*use volume lock*/, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + /* + * Look for existing shared object. Make sure it's a file. + */ + PRTFSISOFILESHRD pShared = (PRTFSISOFILESHRD)rtFsIsoDir_LookupShared(pParentDir, offInDir); + if (pShared) + { + if (!RTFS_IS_FILE(pShared->Core.fAttrib)) + { + LogFlow(("rtFsIsoFile_NewUdf: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n", + pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent)); + pNewFile->offFile = 0; + pNewFile->pShared = pShared; + return VINF_SUCCESS; + } + } + /* + * Create a shared object for this alleged file. + */ + else + { + pShared = (PRTFSISOFILESHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&pShared->Core, &pFid->Icb, pFid, offInDir, pThis); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_FILE(pShared->Core.fAttrib)) + { + rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core); + + LogFlow(("rtFsIsoFile_NewUdf: cbObject=%#RX64 First Extent: off=%#RX64 cb=%#RX64\n", + pShared->Core.cbObject, pShared->Core.FirstExtent.off, pShared->Core.FirstExtent.cbExtent)); + pNewFile->offFile = 0; + pNewFile->pShared = pShared; + return VINF_SUCCESS; + } + rtFsIsoCore_Destroy(&pShared->Core); + } + RTMemFree(pShared); + } + else + rc = VERR_NO_MEMORY; + } + + /* Destroy the file object. */ + pNewFile->offFile = 0; + pNewFile->pShared = NULL; + RTVfsFileRelease(*phVfsFile); + } + *phVfsFile = NIL_RTVFSFILE; + return rc; +} + + +/** + * Looks up the shared structure for a child. + * + * @returns Referenced pointer to the shared structure, NULL if not found. + * @param pThis The directory. + * @param offDirRec The directory record offset of the child. + */ +static PRTFSISOCORE rtFsIsoDir_LookupShared(PRTFSISODIRSHRD pThis, uint64_t offDirRec) +{ + PRTFSISOCORE pCur; + RTListForEach(&pThis->OpenChildren, pCur, RTFSISOCORE, Entry) + { + if (pCur->offDirRec == offDirRec) + { + uint32_t cRefs = ASMAtomicIncU32(&pCur->cRefs); + Assert(cRefs > 1); RT_NOREF(cRefs); + return pCur; + } + } + return NULL; +} + + +#ifdef RT_STRICT +/** + * Checks if @a pNext is an extent of @a pFirst. + * + * @returns true if @a pNext is the next extent, false if not + * @param pFirst The directory record describing the first or the + * previous extent. + * @param pNext The directory record alleged to be the next extent. + */ +DECLINLINE(bool) rtFsIsoDir_Is9660DirRecNextExtent(PCISO9660DIRREC pFirst, PCISO9660DIRREC pNext) +{ + if (RT_LIKELY(pNext->bFileIdLength == pFirst->bFileIdLength)) + { + if (RT_LIKELY((pNext->fFileFlags | ISO9660_FILE_FLAGS_MULTI_EXTENT) == pFirst->fFileFlags)) + { + if (RT_LIKELY(memcmp(pNext->achFileId, pFirst->achFileId, pNext->bFileIdLength) == 0)) + return true; + } + } + return false; +} +#endif /* RT_STRICT */ + + +/** + * Worker for rtFsIsoDir_FindEntry9660 that compares a UTF-16BE name with a + * directory record. + * + * @returns true if equal, false if not. + * @param pDirRec The directory record. + * @param pwszEntry The UTF-16BE string to compare with. + * @param cbEntry The compare string length in bytes (sans zero + * terminator). + * @param cwcEntry The compare string length in RTUTF16 units. + * @param puVersion Where to return any file version number. + */ +DECL_FORCE_INLINE(bool) rtFsIsoDir_IsEntryEqualUtf16Big(PCISO9660DIRREC pDirRec, PCRTUTF16 pwszEntry, size_t cbEntry, + size_t cwcEntry, uint32_t *puVersion) +{ + /* ASSUME directories cannot have any version tags. */ + if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + { + if (RT_LIKELY(pDirRec->bFileIdLength != cbEntry)) + return false; + if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0)) + return false; + } + else + { + size_t cbNameDelta = (size_t)pDirRec->bFileIdLength - cbEntry; + if (RT_LIKELY(cbNameDelta > (size_t)12 /* ;12345 */)) + return false; + if (cbNameDelta == 0) + { + if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0)) + return false; + *puVersion = 1; + } + else + { + if (RT_LIKELY(RT_MAKE_U16(pDirRec->achFileId[cbEntry + 1], pDirRec->achFileId[cbEntry]) != ';')) + return false; + if (RT_LIKELY(RTUtf16BigNICmp((PCRTUTF16)pDirRec->achFileId, pwszEntry, cwcEntry) != 0)) + return false; + uint32_t uVersion; + size_t cwcVersion = rtFsIso9660GetVersionLengthUtf16Big((PCRTUTF16)pDirRec->achFileId, + pDirRec->bFileIdLength, &uVersion); + if (RT_LIKELY(cwcVersion * sizeof(RTUTF16) == cbNameDelta)) + *puVersion = uVersion; + else + return false; + } + } + + /* (No need to check for dot and dot-dot here, because cbEntry must be a + multiple of two.) */ + Assert(!(cbEntry & 1)); + return true; +} + + +/** + * Worker for rtFsIsoDir_FindEntry9660 that compares an ASCII name with a + * directory record. + * + * @returns true if equal, false if not. + * @param pDirRec The directory record. + * @param pszEntry The uppercased ASCII string to compare with. + * @param cchEntry The length of the compare string. + * @param puVersion Where to return any file version number. + */ +DECL_FORCE_INLINE(bool) rtFsIsoDir_IsEntryEqualAscii(PCISO9660DIRREC pDirRec, const char *pszEntry, size_t cchEntry, + uint32_t *puVersion) +{ + /* ASSUME directories cannot have any version tags. */ + if (pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + { + if (RT_LIKELY(pDirRec->bFileIdLength != cchEntry)) + return false; + if (RT_LIKELY(memcmp(pDirRec->achFileId, pszEntry, cchEntry) != 0)) + return false; + } + else + { + size_t cchNameDelta = (size_t)pDirRec->bFileIdLength - cchEntry; + if (RT_LIKELY(cchNameDelta > (size_t)6 /* ;12345 */)) + return false; + if (cchNameDelta == 0) + { + if (RT_LIKELY(memcmp(pDirRec->achFileId, pszEntry, cchEntry) != 0)) + return false; + *puVersion = 1; + } + else + { + if (RT_LIKELY(pDirRec->achFileId[cchEntry] != ';')) + return false; + if (RT_LIKELY(memcmp(pDirRec->achFileId, pszEntry, cchEntry) != 0)) + return false; + uint32_t uVersion; + size_t cchVersion = rtFsIso9660GetVersionLengthAscii(pDirRec->achFileId, pDirRec->bFileIdLength, &uVersion); + if (RT_LIKELY(cchVersion == cchNameDelta)) + *puVersion = uVersion; + else + return false; + } + } + + /* Don't match the 'dot' and 'dot-dot' directory records. */ + if (RT_LIKELY( pDirRec->bFileIdLength != 1 + || (uint8_t)pDirRec->achFileId[0] > (uint8_t)0x01)) + return true; + return false; +} + + +/** + * Locates a directory entry in a directory. + * + * @returns IPRT status code. + * @retval VERR_FILE_NOT_FOUND if not found. + * @param pThis The directory to search. + * @param pszEntry The entry to look for. + * @param poffDirRec Where to return the offset of the directory record + * on the disk. + * @param ppDirRec Where to return the pointer to the directory record + * (the whole directory is buffered). + * @param pcDirRecs Where to return the number of directory records + * related to this entry. + * @param pfMode Where to return the file type, rock ridge adjusted. + * @param puVersion Where to return the file version number. + */ +static int rtFsIsoDir_FindEntry9660(PRTFSISODIRSHRD pThis, const char *pszEntry, uint64_t *poffDirRec, + PCISO9660DIRREC *ppDirRec, uint32_t *pcDirRecs, PRTFMODE pfMode, uint32_t *puVersion) +{ + Assert(pThis->Core.pVol->enmType != RTFSISOVOLTYPE_UDF); + + /* Set return values. */ + *poffDirRec = UINT64_MAX; + *ppDirRec = NULL; + *pcDirRecs = 1; + *pfMode = UINT32_MAX; + *puVersion = 0; + + /* + * If we're in UTF-16BE mode, convert the input name to UTF-16BE. Otherwise try + * uppercase it into a ISO 9660 compliant name. + */ + int rc; + bool const fIsUtf16 = pThis->Core.pVol->fIsUtf16; + size_t cwcEntry = 0; + size_t cbEntry = 0; + size_t cchUpper = ~(size_t)0; + union + { + RTUTF16 wszEntry[260 + 1]; + struct + { + char szUpper[255 + 1]; + char szRock[260 + 1]; + } s; + } uBuf; + if (fIsUtf16) + { + PRTUTF16 pwszEntry = uBuf.wszEntry; + rc = RTStrToUtf16BigEx(pszEntry, RTSTR_MAX, &pwszEntry, RT_ELEMENTS(uBuf.wszEntry), &cwcEntry); + if (RT_FAILURE(rc)) + return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc; + cbEntry = cwcEntry * 2; + } + else + { + rc = RTStrCopy(uBuf.s.szUpper, sizeof(uBuf.s.szUpper), pszEntry); + if (RT_FAILURE(rc)) + return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc; + RTStrToUpper(uBuf.s.szUpper); + cchUpper = strlen(uBuf.s.szUpper); + } + + /* + * Scan the directory buffer by buffer. + */ + uint32_t offEntryInDir = 0; + uint32_t const cbDir = pThis->Core.cbObject; + while (offEntryInDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= cbDir) + { + PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pThis->pbDir[offEntryInDir]; + + /* If null length, skip to the next sector. */ + if (pDirRec->cbDirRec == 0) + offEntryInDir = (offEntryInDir + pThis->Core.pVol->cbSector) & ~(pThis->Core.pVol->cbSector - 1U); + else + { + /* Try match the filename. */ + if (fIsUtf16) + { + if (RT_LIKELY(!rtFsIsoDir_IsEntryEqualUtf16Big(pDirRec, uBuf.wszEntry, cbEntry, cwcEntry, puVersion))) + { + /* Advance */ + offEntryInDir += pDirRec->cbDirRec; + continue; + } + } + else + { + if (RT_LIKELY(!rtFsIsoDir_IsEntryEqualAscii(pDirRec, uBuf.s.szUpper, cchUpper, puVersion))) + { + /** @todo check rock. */ + if (1) + { + /* Advance */ + offEntryInDir += pDirRec->cbDirRec; + continue; + } + } + } + + *poffDirRec = pThis->Core.FirstExtent.off + offEntryInDir; + *ppDirRec = pDirRec; + *pfMode = pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY + ? 0755 | RTFS_TYPE_DIRECTORY | RTFS_DOS_DIRECTORY + : 0644 | RTFS_TYPE_FILE; + + /* + * Deal with the unlikely scenario of multi extent records. + */ + if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)) + *pcDirRecs = 1; + else + { + offEntryInDir += pDirRec->cbDirRec; + + uint32_t cDirRecs = 1; + while (offEntryInDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= cbDir) + { + PCISO9660DIRREC pDirRec2 = (PCISO9660DIRREC)&pThis->pbDir[offEntryInDir]; + if (pDirRec2->cbDirRec != 0) + { + Assert(rtFsIsoDir_Is9660DirRecNextExtent(pDirRec, pDirRec2)); + cDirRecs++; + if (!(pDirRec2->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)) + break; + offEntryInDir += pDirRec2->cbDirRec; + } + else + offEntryInDir = (offEntryInDir + pThis->Core.pVol->cbSector) & ~(pThis->Core.pVol->cbSector - 1U); + } + + *pcDirRecs = cDirRecs; + } + return VINF_SUCCESS; + } + } + + return VERR_FILE_NOT_FOUND; +} + + +/** + * Locates a directory entry in a directory. + * + * @returns IPRT status code. + * @retval VERR_FILE_NOT_FOUND if not found. + * @param pThis The directory to search. + * @param pszEntry The entry to look for. + * @param ppFid Where to return the pointer to the file ID entry. + * (Points to the directory content.) + */ +static int rtFsIsoDir_FindEntryUdf(PRTFSISODIRSHRD pThis, const char *pszEntry, PCUDFFILEIDDESC *ppFid) +{ + Assert(pThis->Core.pVol->enmType == RTFSISOVOLTYPE_UDF); + *ppFid = NULL; + + /* + * Recode the entry name as 8-bit (if possible) and 16-bit strings. + * This also disposes of entries that definitely are too long. + */ + size_t cb8Bit; + bool fSimple; + size_t cb16Bit; + size_t cwc16Bit; + uint8_t ab8Bit[255]; + RTUTF16 wsz16Bit[255]; + + /* 16-bit */ + PRTUTF16 pwsz16Bit = wsz16Bit; + int rc = RTStrToUtf16BigEx(pszEntry, RTSTR_MAX, &pwsz16Bit, RT_ELEMENTS(wsz16Bit), &cwc16Bit); + if (RT_SUCCESS(rc)) + cb16Bit = 1 + cwc16Bit * sizeof(RTUTF16); + else + return rc == VERR_BUFFER_OVERFLOW ? VERR_FILENAME_TOO_LONG : rc; + + /* 8-bit (can't possibly overflow) */ + fSimple = true; + cb8Bit = 0; + const char *pszSrc = pszEntry; + for (;;) + { + RTUNICP uc; + int rc2 = RTStrGetCpEx(&pszSrc, &uc); + AssertRCReturn(rc2, rc2); + if (uc <= 0x7f) + { + if (uc) + ab8Bit[cb8Bit++] = (uint8_t)uc; + else + break; + } + else if (uc <= 0xff) + { + ab8Bit[cb8Bit++] = (uint8_t)uc; + fSimple = false; + } + else + { + cb8Bit = UINT32_MAX / 2; + break; + } + } + Assert(cb8Bit <= sizeof(ab8Bit) || cb8Bit == UINT32_MAX / 2); + cb8Bit++; + + /* + * Scan the directory content. + */ + uint32_t offDesc = 0; + uint32_t const cbDir = pThis->Core.cbObject; + while (offDesc + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) <= cbDir) + { + PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pThis->pbDir[offDesc]; + uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid); + if ( offDesc + cbFid <= cbDir + && pFid->Tag.idTag == UDF_TAG_ID_FILE_ID_DESC) + { /* likely */ } + else + break; + + uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid); + if (*pbName == 16) + { + if (cb16Bit == pFid->cbName) + { + if (RTUtf16BigNICmp((PCRTUTF16)(&pbName[1]), wsz16Bit, cwc16Bit) == 0) + { + *ppFid = pFid; + return VINF_SUCCESS; + } + } + } + else if (*pbName == 8) + { + if ( cb8Bit == pFid->cbName + && cb8Bit != UINT16_MAX) + { + if (fSimple) + { + if (RTStrNICmp((const char *)&pbName[1], (const char *)ab8Bit, cb8Bit - 1) == 0) + { + *ppFid = pFid; + return VINF_SUCCESS; + } + } + else + { + size_t cch = cb8Bit - 1; + size_t off; + for (off = 0; off < cch; off++) + { + RTUNICP uc1 = ab8Bit[off]; + RTUNICP uc2 = pbName[off + 1]; + if ( uc1 == uc2 + || RTUniCpToLower(uc1) == RTUniCpToLower(uc2) + || RTUniCpToUpper(uc1) == RTUniCpToUpper(uc2)) + { /* matches */ } + else + break; + } + if (off == cch) + { + *ppFid = pFid; + return VINF_SUCCESS; + } + } + } + } + + /* advance */ + offDesc += cbFid; + } + + return VERR_FILE_NOT_FOUND; +} + + +/** + * Releases a reference to a shared directory structure. + * + * @param pShared The shared directory structure. + */ +static void rtFsIsoDirShrd_Release(PRTFSISODIRSHRD pShared) +{ + uint32_t cRefs = ASMAtomicDecU32(&pShared->Core.cRefs); + Assert(cRefs < UINT32_MAX / 2); + if (cRefs == 0) + { + LogFlow(("rtFsIsoDirShrd_Release: Destroying shared structure %p\n", pShared)); + Assert(pShared->Core.cRefs == 0); + if (pShared->pbDir) + { + RTMemFree(pShared->pbDir); + pShared->pbDir = NULL; + } + rtFsIsoCore_Destroy(&pShared->Core); + RTMemFree(pShared); + } +} + + +/** + * Retains a reference to a shared directory structure. + * + * @param pShared The shared directory structure. + */ +static void rtFsIsoDirShrd_Retain(PRTFSISODIRSHRD pShared) +{ + uint32_t cRefs = ASMAtomicIncU32(&pShared->Core.cRefs); + Assert(cRefs > 1); NOREF(cRefs); +} + + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsIsoDir_Close(void *pvThis) +{ + PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis; + LogFlow(("rtFsIsoDir_Close(%p/%p)\n", pThis, pThis->pShared)); + + PRTFSISODIRSHRD pShared = pThis->pShared; + pThis->pShared = NULL; + if (pShared) + rtFsIsoDirShrd_Release(pShared); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsIsoDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis; + return rtFsIsoCore_QueryInfo(&pThis->pShared->Core, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpen} + */ +static DECLCALLBACK(int) rtFsIsoDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen, + uint32_t fFlags, PRTVFSOBJ phVfsObj) +{ + PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis; + PRTFSISODIRSHRD pShared = pThis->pShared; + int rc; + + /* + * We cannot create or replace anything, just open stuff. + */ + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { /* likely */ } + else + return VERR_WRITE_PROTECT; + + /* + * Special cases '.' and '..' + */ + if (pszEntry[0] == '.') + { + PRTFSISODIRSHRD pSharedToOpen; + if (pszEntry[1] == '\0') + pSharedToOpen = pShared; + else if (pszEntry[1] == '.' && pszEntry[2] == '\0') + { + pSharedToOpen = pShared->Core.pParentDir; + if (!pSharedToOpen) + pSharedToOpen = pShared; + } + else + pSharedToOpen = NULL; + if (pSharedToOpen) + { + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + rtFsIsoDirShrd_Retain(pSharedToOpen); + RTVFSDIR hVfsDir; + rc = rtFsIsoDir_NewWithShared(pShared->Core.pVol, pSharedToOpen, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_DIRECTORY; + return rc; + } + } + + /* + * Try open whatever it is. + */ + if (pShared->Core.pVol->enmType != RTFSISOVOLTYPE_UDF) + { + + /* + * ISO 9660 + */ + PCISO9660DIRREC pDirRec; + uint64_t offDirRec; + uint32_t cDirRecs; + RTFMODE fMode; + uint32_t uVersion; + rc = rtFsIsoDir_FindEntry9660(pShared, pszEntry, &offDirRec, &pDirRec, &cDirRecs, &fMode, &uVersion); + Log2(("rtFsIsoDir_Open: FindEntry9660(,%s,) -> %Rrc\n", pszEntry, rc)); + if (RT_SUCCESS(rc)) + { + switch (fMode & RTFS_TYPE_MASK) + { + case RTFS_TYPE_FILE: + if (fFlags & RTVFSOBJ_F_OPEN_FILE) + { + RTVFSFILE hVfsFile; + rc = rtFsIsoFile_New9660(pShared->Core.pVol, pShared, pDirRec, cDirRecs, + offDirRec, fOpen, uVersion, &hVfsFile); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_FILE; + break; + + case RTFS_TYPE_DIRECTORY: + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + RTVFSDIR hVfsDir; + rc = rtFsIsoDir_New9660(pShared->Core.pVol, pShared, pDirRec, cDirRecs, offDirRec, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_DIRECTORY; + break; + + case RTFS_TYPE_SYMLINK: + case RTFS_TYPE_DEV_BLOCK: + case RTFS_TYPE_DEV_CHAR: + case RTFS_TYPE_FIFO: + case RTFS_TYPE_SOCKET: + case RTFS_TYPE_WHITEOUT: + rc = VERR_NOT_IMPLEMENTED; + break; + + default: + rc = VERR_PATH_NOT_FOUND; + break; + } + } + } + else + { + /* + * UDF + */ + PCUDFFILEIDDESC pFid; + rc = rtFsIsoDir_FindEntryUdf(pShared, pszEntry, &pFid); + Log2(("rtFsIsoDir_Open: FindEntryUdf(,%s,) -> %Rrc\n", pszEntry, rc)); + if (RT_SUCCESS(rc)) + { + if (!(pFid->fFlags & UDF_FILE_FLAGS_DELETED)) + { + if (!(pFid->fFlags & UDF_FILE_FLAGS_DIRECTORY)) + { + if (fFlags & RTVFSOBJ_F_OPEN_FILE) + { + RTVFSFILE hVfsFile; + rc = rtFsIsoFile_NewUdf(pShared->Core.pVol, pShared, pFid, fOpen, &hVfsFile); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_FILE; + } + else + { + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + RTVFSDIR hVfsDir; + rc = rtFsIsoDir_NewUdf(pShared->Core.pVol, pShared, pFid, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_DIRECTORY; + } + } + /* We treat UDF_FILE_FLAGS_DELETED like RTFS_TYPE_WHITEOUT for now. */ + else + rc = VERR_PATH_NOT_FOUND; + } + } + return rc; + +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateDir} + */ +static DECLCALLBACK(int) rtFsIsoDir_CreateDir(void *pvThis, const char *pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir) +{ + RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink} + */ +static DECLCALLBACK(int) rtFsIsoDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, phVfsSymlink); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink} + */ +static DECLCALLBACK(int) rtFsIsoDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget, + RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry} + */ +static DECLCALLBACK(int) rtFsIsoDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType) +{ + RT_NOREF(pvThis, pszEntry, fType); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry} + */ +static DECLCALLBACK(int) rtFsIsoDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName) +{ + RT_NOREF(pvThis, pszEntry, fType, pszNewName); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRewindDir} + */ +static DECLCALLBACK(int) rtFsIsoDir_RewindDir(void *pvThis) +{ + PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis; + pThis->offDir = 0; + return VINF_SUCCESS; +} + + +/** + * The ISO 9660 worker for rtFsIsoDir_ReadDir + */ +static int rtFsIsoDir_ReadDir9660(PRTFSISODIROBJ pThis, PRTFSISODIRSHRD pShared, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + while (pThis->offDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= pShared->cbDir) + { + PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pShared->pbDir[pThis->offDir]; + + /* If null length, skip to the next sector. */ + if (pDirRec->cbDirRec == 0) + pThis->offDir = (pThis->offDir + pShared->Core.pVol->cbSector) & ~(pShared->Core.pVol->cbSector - 1U); + else + { + /* + * Do names first as they may cause overflows. + */ + uint32_t uVersion = 0; + if ( pDirRec->bFileIdLength == 1 + && pDirRec->achFileId[0] == '\0') + { + if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2) + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2; + Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW (dot)\n")); + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = 1; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[1] = '\0'; + } + else if ( pDirRec->bFileIdLength == 1 + && pDirRec->achFileId[0] == '\1') + { + if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 3) + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 3; + Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW (dot-dot)\n")); + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = 2; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[1] = '.'; + pDirEntry->szName[2] = '\0'; + } + else if (pShared->Core.pVol->fIsUtf16) + { + PCRTUTF16 pawcSrc = (PCRTUTF16)&pDirRec->achFileId[0]; + size_t cwcSrc = pDirRec->bFileIdLength / sizeof(RTUTF16); + size_t cwcVer = !(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + ? rtFsIso9660GetVersionLengthUtf16Big(pawcSrc, cwcSrc, &uVersion) : 0; + size_t cchNeeded = 0; + size_t cbDst = *pcbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName); + char *pszDst = pDirEntry->szName; + + int rc = RTUtf16BigToUtf8Ex(pawcSrc, cwcSrc - cwcVer, &pszDst, cbDst, &cchNeeded); + if (RT_SUCCESS(rc)) + pDirEntry->cbName = (uint16_t)cchNeeded; + else if (rc == VERR_BUFFER_OVERFLOW) + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchNeeded + 1; + Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW - cbDst=%zu cchNeeded=%zu (UTF-16BE)\n", cbDst, cchNeeded)); + return VERR_BUFFER_OVERFLOW; + } + else + { + ssize_t cchNeeded2 = RTStrPrintf2(pszDst, cbDst, "bad-name-%#x", pThis->offDir); + if (cchNeeded2 >= 0) + pDirEntry->cbName = (uint16_t)cchNeeded2; + else + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + (size_t)-cchNeeded2; + return VERR_BUFFER_OVERFLOW; + } + } + } + else + { + /* This is supposed to be upper case ASCII, however, purge the encoding anyway. */ + size_t cchVer = !(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY) + ? rtFsIso9660GetVersionLengthAscii(pDirRec->achFileId, pDirRec->bFileIdLength, &uVersion) : 0; + size_t cchName = pDirRec->bFileIdLength - cchVer; + size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchName + 1; + if (*pcbDirEntry < cbNeeded) + { + Log3(("rtFsIsoDir_ReadDir9660: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (ASCII)\n", *pcbDirEntry, cbNeeded)); + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = (uint16_t)cchName; + memcpy(pDirEntry->szName, pDirRec->achFileId, cchName); + pDirEntry->szName[cchName] = '\0'; + RTStrPurgeEncoding(pDirEntry->szName); + + /** @todo check for rock ridge names here. */ + } + pDirEntry->cwcShortName = 0; + pDirEntry->wszShortName[0] = '\0'; + + /* + * To avoid duplicating code in rtFsIsoCore_InitFrom9660DirRec and + * rtFsIsoCore_QueryInfo, we create a dummy RTFSISOCORE on the stack. + */ + RTFSISOCORE TmpObj; + RT_ZERO(TmpObj); + rtFsIsoCore_InitFrom9660DirRec(&TmpObj, pDirRec, 1 /* cDirRecs - see below why 1 */, + pThis->offDir + pShared->Core.FirstExtent.off, uVersion, pShared->Core.pVol); + int rc = rtFsIsoCore_QueryInfo(&TmpObj, &pDirEntry->Info, enmAddAttr); + + /* + * Update the directory location and handle multi extent records. + * + * Multi extent records only affect the file size and the directory location, + * so we deal with it here instead of involving * rtFsIsoCore_InitFrom9660DirRec + * which would potentially require freeing memory and such. + */ + if (!(pDirRec->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)) + { + Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc)); + pThis->offDir += pDirRec->cbDirRec; + } + else + { + uint32_t cExtents = 1; + uint32_t offDir = pThis->offDir + pDirRec->cbDirRec; + while (offDir + RT_UOFFSETOF(ISO9660DIRREC, achFileId) <= pShared->cbDir) + { + PCISO9660DIRREC pDirRec2 = (PCISO9660DIRREC)&pShared->pbDir[offDir]; + if (pDirRec2->cbDirRec != 0) + { + pDirEntry->Info.cbObject += ISO9660_GET_ENDIAN(&pDirRec2->cbData); + offDir += pDirRec2->cbDirRec; + cExtents++; + if (!(pDirRec2->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT)) + break; + } + else + offDir = (offDir + pShared->Core.pVol->cbSector) & ~(pShared->Core.pVol->cbSector - 1U); + } + Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x, %u extents ending at %#07x: %s (rc=%Rrc)\n", + pThis->offDir, cExtents, offDir, pDirEntry->szName, rc)); + pThis->offDir = offDir; + } + + return rc; + } + } + + Log3(("rtFsIsoDir_ReadDir9660: offDir=%#07x: VERR_NO_MORE_FILES\n", pThis->offDir)); + return VERR_NO_MORE_FILES; +} + + +/** + * The UDF worker for rtFsIsoDir_ReadDir + */ +static int rtFsIsoDir_ReadDirUdf(PRTFSISODIROBJ pThis, PRTFSISODIRSHRD pShared, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + /* + * At offset zero we've got the '.' entry. This has to be generated + * manually as it's not part of the directory content. The directory + * offset has to be faked for this too, so offDir == 0 indicates the '.' + * entry whereas offDir == 1 is the first file id descriptor. + */ + if (pThis->offDir == 0) + { + if (*pcbDirEntry < RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2) + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2; + Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW (dot)\n")); + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = 1; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[1] = '\0'; + pDirEntry->cwcShortName = 0; + pDirEntry->wszShortName[0] = '\0'; + + int rc = rtFsIsoCore_QueryInfo(&pShared->Core, &pDirEntry->Info, enmAddAttr); + + Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc)); + pThis->offDir = 1; + return rc; + } + + /* + * Do the directory content. + */ + while (pThis->offDir + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) <= pShared->cbDir + 1) + { + PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pShared->pbDir[pThis->offDir - 1]; + uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid); + + if (pThis->offDir + cbFid <= pShared->cbDir + 1) + { /* likely */ } + else + break; + + /* + * Do names first as they may cause overflows. + */ + if (pFid->cbName > 1) + { + uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid); + uint32_t cbSrc = pFid->cbName; + if (*pbName == 8) + { + /* Figure out the UTF-8 length first. */ + bool fSimple = true; + uint32_t cchDst = 0; + for (uint32_t offSrc = 1; offSrc < cbSrc; offSrc++) + if (!(pbName[offSrc] & 0x80)) + cchDst++; + else + { + cchDst += 2; + fSimple = false; + } + + size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchDst + 1; + if (*pcbDirEntry >= cbNeeded) + { + if (fSimple) + { + Assert(cbSrc - 1 == cchDst); + memcpy(pDirEntry->szName, &pbName[1], cchDst); + pDirEntry->szName[cchDst] = '\0'; + } + else + { + char *pszDst = pDirEntry->szName; + for (uint32_t offSrc = 1; offSrc < cbSrc; offSrc++) + pszDst = RTStrPutCp(pszDst, pbName[offSrc]); + *pszDst = '\0'; + Assert((size_t)(pszDst - &pDirEntry->szName[0]) == cchDst); + } + } + else + { + Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (8-bit)\n", *pcbDirEntry, cbNeeded)); + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + } + else + { + /* Let RTUtf16BigToUtf8Ex do the bounds checking. */ + char *pszDst = pDirEntry->szName; + size_t cbDst = *pcbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName); + size_t cchNeeded = 0; + int rc; + if (*pbName == 16) + rc = RTUtf16BigToUtf8Ex((PCRTUTF16)(pbName + 1), (cbSrc - 1) / sizeof(RTUTF16), &pszDst, cbDst, &cchNeeded); + else + rc = VERR_INVALID_NAME; + if (RT_SUCCESS(rc)) + pDirEntry->cbName = (uint16_t)cchNeeded; + else if (rc == VERR_BUFFER_OVERFLOW) + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + cchNeeded + 1; + Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cchNeeded=%zu (16-bit)\n", cbDst, cchNeeded)); + return VERR_BUFFER_OVERFLOW; + } + else + { + LogRelMax(90, ("ISO/UDF: Malformed directory entry name at %#x: %.*Rhxs\n", pThis->offDir - 1, cbSrc, pbName)); + ssize_t cchNeeded2 = RTStrPrintf2(pszDst, cbDst, "bad-name-%#x", pThis->offDir - 1); + if (cchNeeded2 >= 0) + pDirEntry->cbName = (uint16_t)cchNeeded2; + else + { + *pcbDirEntry = RT_UOFFSETOF(RTDIRENTRYEX, szName) + (size_t)-cchNeeded2; + return VERR_BUFFER_OVERFLOW; + } + } + } + } + else if (pFid->fFlags & UDF_FILE_FLAGS_PARENT) + { + size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 2 + 1; + if (*pcbDirEntry < cbNeeded) + { + Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (dot-dot)\n", *pcbDirEntry, cbNeeded)); + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = 2; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[1] = '.'; + pDirEntry->szName[2] = '\0'; + } + else + { + size_t cbNeeded = RT_UOFFSETOF(RTDIRENTRYEX, szName) + 1; + if (*pcbDirEntry < cbNeeded) + { + Log3(("rtFsIsoDir_ReadDirUdf: VERR_BUFFER_OVERFLOW - cbDst=%zu cbNeeded=%zu (empty)\n", *pcbDirEntry, cbNeeded)); + *pcbDirEntry = cbNeeded; + return VERR_BUFFER_OVERFLOW; + } + pDirEntry->cbName = 0; + pDirEntry->szName[0] = '\0'; + } + + pDirEntry->cwcShortName = 0; + pDirEntry->wszShortName[0] = '\0'; + + /* + * To avoid duplicating code in rtFsIsoCore_InitUdf and + * rtFsIsoCore_QueryInfo, we create a dummy RTFSISOCORE on the stack. + */ + RTFSISOCORE TmpObj; + RT_ZERO(TmpObj); + int rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&TmpObj, &pFid->Icb, pFid, pThis->offDir - 1, pShared->Core.pVol); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoCore_QueryInfo(&TmpObj, &pDirEntry->Info, enmAddAttr); + rtFsIsoCore_Destroy(&TmpObj); + } + + /* + * Update. + */ + Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: %s (rc=%Rrc)\n", pThis->offDir, pDirEntry->szName, rc)); + pThis->offDir += cbFid; + + return rc; + } + + Log3(("rtFsIsoDir_ReadDirUdf: offDir=%#07x: VERR_NO_MORE_FILES\n", pThis->offDir)); + return VERR_NO_MORE_FILES; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnReadDir} + */ +static DECLCALLBACK(int) rtFsIsoDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + PRTFSISODIROBJ pThis = (PRTFSISODIROBJ)pvThis; + PRTFSISODIRSHRD pShared = pThis->pShared; + int rc; + if (pShared->Core.pVol->enmType != RTFSISOVOLTYPE_UDF) + rc = rtFsIsoDir_ReadDir9660(pThis, pShared, pDirEntry, pcbDirEntry, enmAddAttr); + else + rc = rtFsIsoDir_ReadDirUdf(pThis, pShared, pDirEntry, pcbDirEntry, enmAddAttr); + return rc; +} + + +/** + * ISO file operations. + */ +static const RTVFSDIROPS g_rtFsIsoDirOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_DIR, + "ISO 9660 Dir", + rtFsIsoDir_Close, + rtFsIsoDir_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSDIROPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj), + NULL /*SetMode*/, + NULL /*SetTimes*/, + NULL /*SetOwner*/, + RTVFSOBJSETOPS_VERSION + }, + rtFsIsoDir_Open, + NULL /* pfnFollowAbsoluteSymlink */, + NULL /* pfnOpenFile */, + NULL /* pfnOpenDir */, + rtFsIsoDir_CreateDir, + rtFsIsoDir_OpenSymlink, + rtFsIsoDir_CreateSymlink, + NULL /* pfnQueryEntryInfo */, + rtFsIsoDir_UnlinkEntry, + rtFsIsoDir_RenameEntry, + rtFsIsoDir_RewindDir, + rtFsIsoDir_ReadDir, + RTVFSDIROPS_VERSION, +}; + + +/** + * Adds an open child to the parent directory's shared structure. + * + * Maintains an additional reference to the parent dir to prevent it from going + * away. If @a pDir is the root directory, it also ensures the volume is + * referenced and sticks around until the last open object is gone. + * + * @param pDir The directory. + * @param pChild The child being opened. + * @sa rtFsIsoDirShrd_RemoveOpenChild + */ +static void rtFsIsoDirShrd_AddOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild) +{ + rtFsIsoDirShrd_Retain(pDir); + + RTListAppend(&pDir->OpenChildren, &pChild->Entry); + pChild->pParentDir = pDir; +} + + +/** + * Removes an open child to the parent directory. + * + * @param pDir The directory. + * @param pChild The child being removed. + * + * @remarks This is the very last thing you do as it may cause a few other + * objects to be released recursively (parent dir and the volume). + * + * @sa rtFsIsoDirShrd_AddOpenChild + */ +static void rtFsIsoDirShrd_RemoveOpenChild(PRTFSISODIRSHRD pDir, PRTFSISOCORE pChild) +{ + AssertReturnVoid(pChild->pParentDir == pDir); + RTListNodeRemove(&pChild->Entry); + pChild->pParentDir = NULL; + + rtFsIsoDirShrd_Release(pDir); +} + + +#ifdef LOG_ENABLED +/** + * Logs the content of a directory. + */ +static void rtFsIsoDirShrd_Log9660Content(PRTFSISODIRSHRD pThis) +{ + if (LogIs2Enabled()) + { + uint32_t offRec = 0; + while (offRec < pThis->cbDir) + { + PCISO9660DIRREC pDirRec = (PCISO9660DIRREC)&pThis->pbDir[offRec]; + if (pDirRec->cbDirRec == 0) + break; + + RTUTF16 wszName[128]; + if (pThis->Core.pVol->fIsUtf16) + { + PRTUTF16 pwszDst = &wszName[pDirRec->bFileIdLength / sizeof(RTUTF16)]; + PCRTUTF16 pwszSrc = (PCRTUTF16)&pDirRec->achFileId[pDirRec->bFileIdLength]; + pwszSrc--; + *pwszDst-- = '\0'; + while ((uintptr_t)pwszDst >= (uintptr_t)&wszName[0]) + { + *pwszDst = RT_BE2H_U16(*pwszSrc); + pwszDst--; + pwszSrc--; + } + } + else + { + PRTUTF16 pwszDst = wszName; + for (uint32_t off = 0; off < pDirRec->bFileIdLength; off++) + *pwszDst++ = pDirRec->achFileId[off]; + *pwszDst = '\0'; + } + + Log2(("ISO9660: %04x: rec=%#x ea=%#x cb=%#010RX32 off=%#010RX32 fl=%#04x %04u-%02u-%02u %02u:%02u:%02u%+03d unit=%#x igap=%#x idVol=%#x '%ls'\n", + offRec, + pDirRec->cbDirRec, + pDirRec->cExtAttrBlocks, + ISO9660_GET_ENDIAN(&pDirRec->cbData), + ISO9660_GET_ENDIAN(&pDirRec->offExtent), + pDirRec->fFileFlags, + pDirRec->RecTime.bYear + 1900, + pDirRec->RecTime.bMonth, + pDirRec->RecTime.bDay, + pDirRec->RecTime.bHour, + pDirRec->RecTime.bMinute, + pDirRec->RecTime.bSecond, + pDirRec->RecTime.offUtc*4/60, + pDirRec->bFileUnitSize, + pDirRec->bInterleaveGapSize, + ISO9660_GET_ENDIAN(&pDirRec->VolumeSeqNo), + wszName)); + + uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pDirRec->bFileIdLength]) + + !(pDirRec->bFileIdLength & 1); + if (offSysUse < pDirRec->cbDirRec) + { + Log2(("ISO9660: system use (%#x bytes):\n%.*RhxD\n", pDirRec->cbDirRec - offSysUse, + pDirRec->cbDirRec - offSysUse, (uint8_t *)pDirRec + offSysUse)); + } + + /* advance */ + offRec += pDirRec->cbDirRec; + } + } +} +#endif /* LOG_ENABLED */ + + +/** + * Instantiates a new shared directory structure, given 9660 records. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory. This is NULL for the root + * directory. + * @param pDirRec The directory record. Will access @a cDirRecs + * records. + * @param cDirRecs Number of directory records if more than one. + * @param offDirRec The byte offset of the directory record. + * @param ppShared Where to return the shared directory structure. + */ +static int rtFsIsoDirShrd_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec, + uint32_t cDirRecs, uint64_t offDirRec, PRTFSISODIRSHRD *ppShared) +{ + /* + * Allocate a new structure and initialize it. + */ + int rc = VERR_NO_MEMORY; + PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + rc = rtFsIsoCore_InitFrom9660DirRec(&pShared->Core, pDirRec, cDirRecs, offDirRec, 0 /*uVersion*/, pThis); + if (RT_SUCCESS(rc)) + { + RTListInit(&pShared->OpenChildren); + pShared->cbDir = ISO9660_GET_ENDIAN(&pDirRec->cbData); + pShared->pbDir = (uint8_t *)RTMemAllocZ(pShared->cbDir + 256); + if (pShared->pbDir) + { + rc = RTVfsFileReadAt(pThis->hVfsBacking, pShared->Core.FirstExtent.off, pShared->pbDir, pShared->cbDir, NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsIsoDirShrd_Log9660Content(pShared); +#endif + + /* + * Link into parent directory so we can use it to update + * our directory entry. + */ + if (pParentDir) + rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core); + *ppShared = pShared; + return VINF_SUCCESS; + } + } + else + rc = VERR_NO_MEMORY; + } + RTMemFree(pShared); + } + *ppShared = NULL; + return rc; +} + + +#ifdef LOG_ENABLED +/** + * Logs the content of a directory. + */ +static void rtFsIsoDirShrd_LogUdfContent(PRTFSISODIRSHRD pThis) +{ + if (LogIs2Enabled()) + { + uint32_t offDesc = 0; + while (offDesc + RT_UOFFSETOF(UDFFILEIDDESC, abImplementationUse) < pThis->cbDir) + { + PCUDFFILEIDDESC pFid = (PCUDFFILEIDDESC)&pThis->pbDir[offDesc]; + uint32_t const cbFid = UDFFILEIDDESC_GET_SIZE(pFid); + if (offDesc + cbFid > pThis->cbDir) + break; + + uint32_t cwcName = 0; + RTUTF16 wszName[260]; + if (pFid->cbName > 0) + { + uint8_t const *pbName = UDFFILEIDDESC_2_NAME(pFid); + uint32_t offSrc = 1; + if (*pbName == 8) + while (offSrc < pFid->cbName) + { + wszName[cwcName] = pbName[offSrc]; + cwcName++; + offSrc++; + } + else if (*pbName == 16) + while (offSrc + 1 <= pFid->cbName) + { + wszName[cwcName] = RT_MAKE_U16(pbName[offSrc + 1], pbName[offSrc]); + cwcName++; + offSrc += 2; + } + else + { + RTUtf16CopyAscii(wszName, RT_ELEMENTS(wszName), "<bad type>"); + cwcName = 10; + } + } + else if (pFid->fFlags & UDF_FILE_FLAGS_PARENT) + { + wszName[0] = '.'; + wszName[1] = '.'; + cwcName = 2; + } + else + { + RTUtf16CopyAscii(wszName, RT_ELEMENTS(wszName), "<empty>"); + cwcName = 7; + } + wszName[cwcName] = '\0'; + + Log2(("ISO/UDF: %04x: fFlags=%#x uVer=%u Icb={%#04x:%#010RX32 LB %#06x t=%u} cbName=%#04x cbIU=%#x '%ls'\n", + offDesc, + pFid->fFlags, + pFid->uVersion, + pFid->Icb.Location.uPartitionNo, + pFid->Icb.Location.off, + pFid->Icb.cb, + pFid->Icb.uType, + pFid->cbName, + pFid->cbImplementationUse, + wszName)); + int rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pFid->Tag, pThis->cbDir - offDesc, + UDF_TAG_ID_FILE_ID_DESC, pFid->Tag.offTag, NULL); + if (RT_FAILURE(rc)) + Log2(("ISO/UDF: Bad Tag: %Rrc - idTag=%#x\n", rc, pFid->Tag.idTag)); + if (pFid->cbImplementationUse > 32) + Log2(("ISO/UDF: impl use (%#x bytes):\n%.*RhxD\n", + pFid->cbImplementationUse, pFid->cbImplementationUse, pFid->abImplementationUse)); + else if (pFid->cbImplementationUse > 0) + Log2(("ISO/UDF: impl use (%#x bytes): %.*Rhxs\n", + pFid->cbImplementationUse, pFid->cbImplementationUse, pFid->abImplementationUse)); + + /* advance */ + offDesc += cbFid; + } + + if (offDesc < pThis->cbDir) + Log2(("ISO/UDF: warning! %#x trailing bytes in directory:\n%.*RhxD\n", + pThis->cbDir - offDesc, pThis->cbDir - offDesc, &pThis->pbDir[offDesc])); + } +} +#endif /* LOG_ENABLED */ + + +/** + * Instantiates a new shared directory structure, given UDF descriptors. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory. This is NULL for the root + * directory. + * @param pAllocDesc The allocation descriptor for the directory ICB. + * @param pFileIdDesc The file ID descriptor. This is NULL for the root. + * @param offInDir The offset of the file ID descriptor in the parent + * directory. This is used when looking up shared + * directory objects. (Pass 0 for root.) + * @param ppShared Where to return the shared directory structure. + */ +static int rtFsIsoDirShrd_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFLONGAD pAllocDesc, + PCUDFFILEIDDESC pFileIdDesc, uintptr_t offInDir, PRTFSISODIRSHRD *ppShared) +{ + /* + * Allocate a new structure and initialize it. + */ + int rc = VERR_NO_MEMORY; + PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + rc = rtFsIsoCore_InitFromUdfIcbAndFileIdDesc(&pShared->Core, pAllocDesc, pFileIdDesc, offInDir, pThis); + if (RT_SUCCESS(rc)) + { + RTListInit(&pShared->OpenChildren); + + if (pShared->Core.cbObject < RTFSISO_MAX_DIR_SIZE) + { + pShared->cbDir = (uint32_t)pShared->Core.cbObject; + pShared->pbDir = (uint8_t *)RTMemAllocZ(RT_MAX(RT_ALIGN_32(pShared->cbDir, 512), 512)); + if (pShared->pbDir) + { + rc = rtFsIsoCore_ReadWorker(&pShared->Core, 0, pShared->pbDir, pShared->cbDir, NULL, NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsIsoDirShrd_LogUdfContent(pShared); +#endif + + /* + * Link into parent directory so we can use it to update + * our directory entry. + */ + if (pParentDir) + rtFsIsoDirShrd_AddOpenChild(pParentDir, &pShared->Core); + *ppShared = pShared; + return VINF_SUCCESS; + } + } + else + rc = VERR_NO_MEMORY; + } + } + RTMemFree(pShared); + } + + *ppShared = NULL; + return rc; +} + + +/** + * Instantiates a new directory with a shared structure presupplied. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pShared Referenced pointer to the shared structure. The + * reference is always CONSUMED. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsIsoDir_NewWithShared(PRTFSISOVOL pThis, PRTFSISODIRSHRD pShared, PRTVFSDIR phVfsDir) +{ + /* + * Create VFS object around the shared structure. + */ + PRTFSISODIROBJ pNewDir; + int rc = RTVfsNewDir(&g_rtFsIsoDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, + NIL_RTVFSLOCK /*use volume lock*/, phVfsDir, (void **)&pNewDir); + if (RT_SUCCESS(rc)) + { + /* + * Look for existing shared object, create a new one if necessary. + * We CONSUME a reference to pShared here. + */ + pNewDir->offDir = 0; + pNewDir->pShared = pShared; + return VINF_SUCCESS; + } + + rtFsIsoDirShrd_Release(pShared); + *phVfsDir = NIL_RTVFSDIR; + return rc; +} + + + +/** + * Instantiates a new directory VFS instance for ISO 9660, creating the shared + * structure as necessary. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory. This is NULL for the root + * directory. + * @param pDirRec The directory record. + * @param cDirRecs Number of directory records if more than one. + * @param offDirRec The byte offset of the directory record. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsIsoDir_New9660(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCISO9660DIRREC pDirRec, + uint32_t cDirRecs, uint64_t offDirRec, PRTVFSDIR phVfsDir) +{ + /* + * Look for existing shared object, create a new one if necessary. + */ + PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)rtFsIsoDir_LookupShared(pParentDir, offDirRec); + if (!pShared) + { + int rc = rtFsIsoDirShrd_New9660(pThis, pParentDir, pDirRec, cDirRecs, offDirRec, &pShared); + if (RT_FAILURE(rc)) + { + *phVfsDir = NIL_RTVFSDIR; + return rc; + } + } + return rtFsIsoDir_NewWithShared(pThis, pShared, phVfsDir); +} + + +/** + * Instantiates a new directory VFS instance for UDF, creating the shared + * structure as necessary. + * + * @returns IPRT status code. + * @param pThis The ISO volume instance. + * @param pParentDir The parent directory. + * @param pFid The file ID descriptor for the directory. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsIsoDir_NewUdf(PRTFSISOVOL pThis, PRTFSISODIRSHRD pParentDir, PCUDFFILEIDDESC pFid, PRTVFSDIR phVfsDir) +{ + Assert(pFid); + Assert(pParentDir); + uintptr_t const offInDir = (uintptr_t)pFid - (uintptr_t)pParentDir->pbDir; + Assert(offInDir < pParentDir->cbDir); + + /* + * Look for existing shared object, create a new one if necessary. + */ + PRTFSISODIRSHRD pShared = (PRTFSISODIRSHRD)rtFsIsoDir_LookupShared(pParentDir, offInDir); + if (!pShared) + { + int rc = rtFsIsoDirShrd_NewUdf(pThis, pParentDir, &pFid->Icb, pFid, offInDir, &pShared); + if (RT_FAILURE(rc)) + { + *phVfsDir = NIL_RTVFSDIR; + return rc; + } + } + return rtFsIsoDir_NewWithShared(pThis, pShared, phVfsDir); +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose} + */ +static DECLCALLBACK(int) rtFsIsoVol_Close(void *pvThis) +{ + PRTFSISOVOL pThis = (PRTFSISOVOL)pvThis; + Log(("rtFsIsoVol_Close(%p)\n", pThis)); + + if (pThis->pRootDir) + { + Assert(RTListIsEmpty(&pThis->pRootDir->OpenChildren)); + Assert(pThis->pRootDir->Core.cRefs == 1); + rtFsIsoDirShrd_Release(pThis->pRootDir); + pThis->pRootDir = NULL; + } + + RTVfsFileRelease(pThis->hVfsBacking); + pThis->hVfsBacking = NIL_RTVFSFILE; + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsIsoVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_NOREF(pvThis, pObjInfo, enmAddAttr); + return VERR_WRONG_TYPE; +} + + +/** + * @interface_method_impl{RTVFSOPS,pfnOpenRoot} + */ +static DECLCALLBACK(int) rtFsIsoVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir) +{ + PRTFSISOVOL pThis = (PRTFSISOVOL)pvThis; + + rtFsIsoDirShrd_Retain(pThis->pRootDir); /* consumed by the next call */ + return rtFsIsoDir_NewWithShared(pThis, pThis->pRootDir, phVfsDir); +} + + +/** + * @interface_method_impl{RTVFSOPS,pfnQueryRangeState} + */ +static DECLCALLBACK(int) rtFsIsoVol_QueryRangeState(void *pvThis, uint64_t off, size_t cb, bool *pfUsed) +{ + RT_NOREF(pvThis, off, cb, pfUsed); + return VERR_NOT_IMPLEMENTED; +} + + +DECL_HIDDEN_CONST(const RTVFSOPS) g_rtFsIsoVolOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_VFS, + "ISO 9660/UDF", + rtFsIsoVol_Close, + rtFsIsoVol_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSOPS_VERSION, + 0 /* fFeatures */, + rtFsIsoVol_OpenRoot, + rtFsIsoVol_QueryRangeState, + RTVFSOPS_VERSION +}; + + +/** + * Checks the descriptor tag and CRC. + * + * @retval IPRT status code. + * @retval VERR_ISOFS_TAG_IS_ALL_ZEROS + * @retval VERR_MISMATCH + * @retval VERR_ISOFS_UNSUPPORTED_TAG_VERSION + * @retval VERR_ISOFS_TAG_SECTOR_MISMATCH + * @retval VERR_ISOFS_BAD_TAG_CHECKSUM + * + * @param pTag The tag to check. + * @param idTag The expected descriptor tag ID, UINT16_MAX matches any + * tag ID. + * @param offTag The sector offset of the tag. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolValidateUdfDescTag(PCUDFTAG pTag, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo) +{ + /* + * Checksum the tag first. + */ + const uint8_t *pbTag = (const uint8_t *)pTag; + uint8_t const bChecksum = pbTag[0] + + pbTag[1] + + pbTag[2] + + pbTag[3] + + pbTag[5] /* skipping byte 4 as that's the checksum. */ + + pbTag[6] + + pbTag[7] + + pbTag[8] + + pbTag[9] + + pbTag[10] + + pbTag[11] + + pbTag[12] + + pbTag[13] + + pbTag[14] + + pbTag[15]; + if (pTag->uChecksum == bChecksum) + { + /* + * Do the matching. + */ + if ( pTag->uVersion == 3 + || pTag->uVersion == 2) + { + if ( pTag->idTag == idTag + || idTag == UINT16_MAX) + { + if (pTag->offTag == offTag) + { + //Log3(("ISO/UDF: Valid descriptor %#06x at %#010RX32; cbDescriptorCrc=%#06RX32 uTagSerialNo=%#x\n", + // pTag->idTag, offTag, pTag->cbDescriptorCrc, pTag->uTagSerialNo)); + return VINF_SUCCESS; + } + + Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Sector mismatch: %#RX32 (%.*Rhxs)\n", + idTag, offTag, pTag->offTag, sizeof(*pTag), pTag)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TAG_SECTOR_MISMATCH, + "Descriptor tag sector number mismatch: %#x, expected %#x (%.*Rhxs)", + pTag->offTag, offTag, sizeof(*pTag), pTag); + } + Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Tag ID mismatch: %#x (%.*Rhxs)\n", + idTag, offTag, pTag->idTag, sizeof(*pTag), pTag)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_MISMATCH, "Descriptor tag ID mismatch: %#x, expected %#x (%.*Rhxs)", + pTag->idTag, idTag, sizeof(*pTag), pTag); + } + if (ASMMemIsZero(pTag, sizeof(*pTag))) + { + Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): All zeros\n", idTag, offTag)); + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TAG_IS_ALL_ZEROS, "Descriptor is all zeros"); + } + + Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): Unsupported version: %#x (%.*Rhxs)\n", + idTag, offTag, pTag->uVersion, sizeof(*pTag), pTag)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNSUPPORTED_TAG_VERSION, "Unsupported descriptor tag version: %#x, expected 2 or 3 (%.*Rhxs)", + pTag->uVersion, sizeof(*pTag), pTag); + } + Log(("rtFsIsoVolValidateUdfDescTag(,%#x,%#010RX32,): checksum error: %#x, calc %#x (%.*Rhxs)\n", + idTag, offTag, pTag->uChecksum, bChecksum, sizeof(*pTag), pTag)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_TAG_CHECKSUM, + "Descriptor tag checksum error: %#x, calculated %#x (%.*Rhxs)", + pTag->uChecksum, bChecksum, sizeof(*pTag), pTag); +} + + +/** + * Checks the descriptor CRC. + * + * @retval VINF_SUCCESS + * @retval VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC + * @retval VERR_ISOFS_DESC_CRC_MISMATCH + * + * @param pTag The descriptor buffer to checksum. + * @param cbDesc The size of the descriptor buffer. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolValidateUdfDescCrc(PCUDFTAG pTag, size_t cbDesc, PRTERRINFO pErrInfo) +{ + if (pTag->cbDescriptorCrc + sizeof(*pTag) <= cbDesc) + { + uint16_t uCrc = RTCrc16Ccitt(pTag + 1, pTag->cbDescriptorCrc); + if (pTag->uDescriptorCrc == uCrc) + return VINF_SUCCESS; + + Log(("rtFsIsoVolValidateUdfDescCrc(,%#x,%#010RX32,): Descriptor CRC mismatch: expected %#x, calculated %#x (cbDescriptorCrc=%#x)\n", + pTag->idTag, pTag->offTag, pTag->uDescriptorCrc, uCrc, pTag->cbDescriptorCrc)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_DESC_CRC_MISMATCH, + "Descriptor CRC mismatch: exepcted %#x, calculated %#x (cbDescriptor=%#x, idTag=%#x, offTag=%#010RX32)", + pTag->uDescriptorCrc, uCrc, pTag->cbDescriptorCrc, pTag->idTag, pTag->offTag); + } + + Log(("rtFsIsoVolValidateUdfDescCrc(,%#x,%#010RX32,): Insufficient data to CRC: cbDescriptorCrc=%#x cbDesc=%#zx\n", + pTag->idTag, pTag->offTag, pTag->cbDescriptorCrc, cbDesc)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC, + "Insufficient data to CRC: cbDescriptorCrc=%#x cbDesc=%#zx (idTag=%#x, offTag=%#010RX32)", + pTag->cbDescriptorCrc, cbDesc, pTag->idTag, pTag->offTag); +} + + +/** + * Checks the descriptor tag and CRC. + * + * @retval VINF_SUCCESS + * @retval VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC + * @retval VERR_ISOFS_TAG_IS_ALL_ZEROS + * @retval VERR_MISMATCH + * @retval VERR_ISOFS_UNSUPPORTED_TAG_VERSION + * @retval VERR_ISOFS_TAG_SECTOR_MISMATCH + * @retval VERR_ISOFS_BAD_TAG_CHECKSUM + * @retval VERR_ISOFS_DESC_CRC_MISMATCH + * + * @param pTag The descriptor buffer to check the tag of and to + * checksum. + * @param cbDesc The size of the descriptor buffer. + * @param idTag The expected descriptor tag ID, UINT16_MAX + * matches any tag ID. + * @param offTag The sector offset of the tag. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolValidateUdfDescTagAndCrc(PCUDFTAG pTag, size_t cbDesc, uint16_t idTag, uint32_t offTag, PRTERRINFO pErrInfo) +{ + int rc = rtFsIsoVolValidateUdfDescTag(pTag, idTag, offTag, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsIsoVolValidateUdfDescCrc(pTag, cbDesc, pErrInfo); + return rc; +} + + + + +static int rtFsIsoVolProcessUdfFileSetDescs(PRTFSISOVOL pThis, uint8_t *pbBuf, size_t cbBuf, PRTERRINFO pErrInfo) +{ + + /* + * We assume there is a single file descriptor and don't bother checking what comes next. + */ + PUDFFILESETDESC pFsd = (PUDFFILESETDESC)pbBuf; + Assert(cbBuf > sizeof(*pFsd)); NOREF(cbBuf); + RT_ZERO(*pFsd); + size_t cbToRead = RT_MAX(pThis->Udf.VolInfo.FileSetDescriptor.cb, sizeof(*pFsd)); + int rc = rtFsIsoVolUdfVpRead(pThis, pThis->Udf.VolInfo.FileSetDescriptor.Location.uPartitionNo, + pThis->Udf.VolInfo.FileSetDescriptor.Location.off, 0, pFsd, cbToRead); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoVolValidateUdfDescTagAndCrc(&pFsd->Tag, cbToRead, UDF_TAG_ID_FILE_SET_DESC, + pThis->Udf.VolInfo.FileSetDescriptor.Location.off, pErrInfo); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + Log(("ISO/UDF: File set descriptor at %#RX32 (%#RX32:%#RX32)\n", pFsd->Tag.offTag, + pThis->Udf.VolInfo.FileSetDescriptor.Location.uPartitionNo, + pThis->Udf.VolInfo.FileSetDescriptor.Location.off)); + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER_TIMESTAMP(pFsd, RecordingTimestamp); + UDF_LOG2_MEMBER(pFsd, "#06RX16", uInterchangeLevel); + UDF_LOG2_MEMBER(pFsd, "#06RX16", uMaxInterchangeLevel); + UDF_LOG2_MEMBER(pFsd, "#010RX32", fCharacterSets); + UDF_LOG2_MEMBER(pFsd, "#010RX32", fMaxCharacterSets); + UDF_LOG2_MEMBER(pFsd, "#010RX32", uFileSetNo); + UDF_LOG2_MEMBER(pFsd, "#010RX32", uFileSetDescNo); + UDF_LOG2_MEMBER_CHARSPEC(pFsd, LogicalVolumeIDCharSet); + UDF_LOG2_MEMBER_DSTRING(pFsd, achLogicalVolumeID); + UDF_LOG2_MEMBER_CHARSPEC(pFsd, FileSetCharSet); + UDF_LOG2_MEMBER_DSTRING(pFsd, achFileSetID); + UDF_LOG2_MEMBER_DSTRING(pFsd, achCopyrightFile); + UDF_LOG2_MEMBER_DSTRING(pFsd, achAbstractFile); + UDF_LOG2_MEMBER_LONGAD(pFsd, RootDirIcb); + UDF_LOG2_MEMBER_ENTITY_ID(pFsd, idDomain); + UDF_LOG2_MEMBER_LONGAD(pFsd, NextExtent); + UDF_LOG2_MEMBER_LONGAD(pFsd, SystemStreamDirIcb); + if (!ASMMemIsZero(&pFsd->abReserved[0], sizeof(pFsd->abReserved))) + UDF_LOG2_MEMBER(pFsd, ".32Rhxs", abReserved); + } +#endif + + /* + * Do some basic sanity checking. + */ + if (!UDF_IS_CHAR_SET_OSTA(&pFsd->FileSetCharSet)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_UNSUPPORTED_CHAR_SET, + "Invalid file set charset %.64Rhxs", &pFsd->FileSetCharSet); + if ( pFsd->RootDirIcb.cb == 0 + || pFsd->RootDirIcb.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_ZERO_ROOT_DIR, + "Root Dir ICB location is zero or malformed: uType=%#x cb=%#x loc=%#x:%#RX32", + pFsd->RootDirIcb.uType, pFsd->RootDirIcb.cb, + pFsd->RootDirIcb.Location.uPartitionNo, pFsd->RootDirIcb.Location.off); + if ( pFsd->NextExtent.cb != 0 + && pFsd->NextExtent.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_FSD_NEXT_EXTENT, + "NextExtent isn't zero: uType=%#x cb=%#x loc=%#x:%#RX32", + pFsd->NextExtent.uType, pFsd->NextExtent.cb, + pFsd->NextExtent.Location.uPartitionNo, pFsd->NextExtent.Location.off); + + /* + * Copy the information we need. + */ + pThis->Udf.VolInfo.RootDirIcb = pFsd->RootDirIcb; + if ( pFsd->SystemStreamDirIcb.cb > 0 + && pFsd->SystemStreamDirIcb.uType == UDF_AD_TYPE_RECORDED_AND_ALLOCATED) + pThis->Udf.VolInfo.SystemStreamDirIcb = pFsd->SystemStreamDirIcb; + else + RT_ZERO(pThis->Udf.VolInfo.SystemStreamDirIcb); + return VINF_SUCCESS; + } + return rc; + } + return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading file set descriptor"); +} + + +/** + * Check validatity and extract information from the descriptors in the VDS seq. + * + * @returns IPRT status code + * @param pThis The instance. + * @param pInfo The VDS sequence info. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolProcessUdfVdsSeqInfo(PRTFSISOVOL pThis, PRTFSISOVDSINFO pInfo, PRTERRINFO pErrInfo) +{ + /* + * Check the basic descriptor counts. + */ + PUDFPRIMARYVOLUMEDESC pPvd; + if (pInfo->cPrimaryVols == 1) + pPvd = pInfo->apPrimaryVols[0]; + else + { + if (pInfo->cPrimaryVols == 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_PVD, "No primary volume descriptor was found"); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MULTIPLE_PVDS, + "More than one primary volume descriptor was found: %u", pInfo->cPrimaryVols); + } + + PUDFLOGICALVOLUMEDESC pLvd; + if (pInfo->cLogicalVols == 1) + pLvd = pInfo->apLogicalVols[0]; + else + { + if (pInfo->cLogicalVols == 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_LVD, "No logical volume descriptor was found"); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MULTIPLE_LVDS, + "More than one logical volume descriptor was found: %u", pInfo->cLogicalVols); + } + +#if 0 + if (pInfo->cPartitions == 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_NO_PD, "No partition descriptors was found"); +#endif + + /* + * Check out the partition map in the logical volume descriptor. + * Produce the mapping table while going about that. + */ + if (pLvd->cPartitionMaps > 64) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TOO_MANY_PART_MAPS, + "Too many partition maps: %u (max 64)", pLvd->cPartitionMaps); + + PRTFSISOVOLUDFPMAP paPartMaps = NULL; + if (pLvd->cPartitionMaps > 0) + { + pInfo->paPartMaps = paPartMaps = (PRTFSISOVOLUDFPMAP)RTMemAllocZ(sizeof(paPartMaps[0]) * pLvd->cPartitionMaps); + if (!paPartMaps) + return VERR_NO_MEMORY; + } + uint32_t cPartMaps = 0; + + if (pLvd->cbMapTable) + { + uint32_t off = 0; + while (off + sizeof(UDFPARTMAPHDR) <= pLvd->cbMapTable) + { + PCUDFPARTMAPHDR pHdr = (PCUDFPARTMAPHDR)&pLvd->abPartitionMaps[off]; + + /* + * Bounds checking. + */ + if (off + pHdr->cb > pLvd->cbMapTable) + { + if (cPartMaps < pLvd->cbMapTable) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MALFORMED_PART_MAP_TABLE, + "Incomplete partition map entry at offset %#x: cb=%#x -> offEnd=%#x cbMapTable=%#x (type=%#x)", + off, pHdr->cb, off + pHdr->cb, pLvd->cbMapTable, pHdr->bType); + LogRel(("ISO/UDF: Warning: Incomplete partition map entry at offset %#x: cb=%#x -> offEnd=%#x cbMapTable=%#x (type=%#x)\n", + off, pHdr->cb, off + pHdr->cb, pLvd->cbMapTable, pHdr->bType)); + break; + } + if (cPartMaps >= pLvd->cPartitionMaps) + { + LogRel(("ISO/UDF: Warning: LVD::cPartitionMaps is %u but there are more bytes in the table. (off=%#x cb=%#x cbMapTable=%#x bType=%#x)\n", + cPartMaps - pLvd->cPartitionMaps, off, pHdr->cb, pLvd->cbMapTable, pHdr->bType)); + break; + } + + /* + * Extract relevant info out of the entry. + */ + paPartMaps[cPartMaps].offMapTable = (uint16_t)off; + uint16_t uPartitionNo; + if (pHdr->bType == 1) + { + PCUDFPARTMAPTYPE1 pType1 = (PCUDFPARTMAPTYPE1)pHdr; + paPartMaps[cPartMaps].uVolumeSeqNo = pType1->uVolumeSeqNo; + paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_PLAIN; + uPartitionNo = pType1->uPartitionNo; + } + else if (pHdr->bType == 2) + { + PCUDFPARTMAPTYPE2 pType2 = (PCUDFPARTMAPTYPE2)pHdr; + if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_VPM_PARTITION_TYPE)) + { + paPartMaps[cPartMaps].bType = pType2->idPartitionType.Suffix.Udf.uUdfRevision >= 0x200 + ? RTFSISO_UDF_PMAP_T_VPM_20 : RTFSISO_UDF_PMAP_T_VPM_15; + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_VPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported", + pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision); + } + else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_SPM_PARTITION_TYPE)) + { + paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_SPM; + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_SPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported", + pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision); + } + else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_MPM_PARTITION_TYPE)) + { + paPartMaps[cPartMaps].bType = RTFSISO_UDF_PMAP_T_MPM; + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_MPM_NOT_SUPPORTED, "Partition type '%.23s' (%#x) not supported", + pType2->idPartitionType.achIdentifier, pType2->idPartitionType.Suffix.Udf.uUdfRevision); + } + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNKNOWN_PART_MAP_TYPE_ID, + "Unknown partition map ID for #%u @ %#x: %.23s", + cPartMaps, off, pType2->idPartitionType.achIdentifier); +#if 0 /* unreachable code */ + paPartMaps[cPartMaps].uVolumeSeqNo = pType2->uVolumeSeqNo; + uPartitionNo = pType2->uPartitionNo; +#endif + } + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNKNOWN_PART_MAP_ENTRY_TYPE, + "Unknown partition map entry type #%u @ %#x: %u", cPartMaps, off, pHdr->bType); + paPartMaps[cPartMaps].uPartitionNo = uPartitionNo; + + /* + * Lookup the partition number and retrieve the relevant info from the partition descriptor. + */ + uint32_t i = pInfo->cPartitions; + while (i-- > 0) + { + PUDFPARTITIONDESC pPd = pInfo->apPartitions[i]; + if (paPartMaps[cPartMaps].uPartitionNo == pPd->uPartitionNo) + { + paPartMaps[cPartMaps].idxPartDesc = (uint16_t)i; + paPartMaps[cPartMaps].cSectors = pPd->cSectors; + paPartMaps[cPartMaps].offLocation = pPd->offLocation; + paPartMaps[cPartMaps].offByteLocation = (uint64_t)pPd->offLocation * pThis->cbSector; + paPartMaps[cPartMaps].fFlags = pPd->fFlags; + paPartMaps[cPartMaps].uAccessType = pPd->uAccessType; + if (!UDF_ENTITY_ID_EQUALS(&pPd->PartitionContents, UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF)) + paPartMaps[cPartMaps].fHaveHdr = false; + else + { + paPartMaps[cPartMaps].fHaveHdr = true; + paPartMaps[cPartMaps].Hdr = pPd->ContentsUse.Hdr; + } + break; + } + } + if (i > pInfo->cPartitions) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_PARTITION_NOT_FOUND, + "Partition #%u (%#x) specified by mapping entry #%u (@ %#x) was not found! (int-type %u)", + uPartitionNo, uPartitionNo, cPartMaps, off, paPartMaps[cPartMaps].bType); + + /* + * Advance. + */ + cPartMaps++; + off += pHdr->cb; + } + + if (cPartMaps < pLvd->cPartitionMaps) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_INCOMPLETE_PART_MAP_TABLE, + "Only found %u of the %u announced partition mapping table entries", + cPartMaps, pLvd->cPartitionMaps); + } + + /* It might be theoretically possible to not use virtual partitions for + accessing data, so just warn if there aren't any. */ + if (cPartMaps == 0) + LogRel(("ISO/UDF: Warning: No partition maps!\n")); + + /* + * Check out the logical volume descriptor. + */ + if ( pLvd->cbLogicalBlock < pThis->cbSector + || pLvd->cbLogicalBlock > RTFSISO_MAX_LOGICAL_BLOCK_SIZE + || (pLvd->cbLogicalBlock % pThis->cbSector) != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNSUPPORTED_LOGICAL_BLOCK_SIZE, + "Logical block size of %#x is not supported with a sector size of %#x", + pLvd->cbLogicalBlock, pThis->cbSector); + + if (!UDF_ENTITY_ID_EQUALS(&pLvd->idDomain, UDF_ENTITY_ID_LVD_DOMAIN)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_DOMAIN_ID, + "Unsupported domain ID in logical volume descriptor: '%.23s'", pLvd->idDomain.achIdentifier); + + if ( pLvd->ContentsUse.FileSetDescriptor.uType != UDF_AD_TYPE_RECORDED_AND_ALLOCATED + || pLvd->ContentsUse.FileSetDescriptor.cb == 0 + || pLvd->ContentsUse.FileSetDescriptor.Location.uPartitionNo >= cPartMaps) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_FILE_SET_DESC_LOCATION, + "Malformed file set descriptor location (type=%u cb=%#x part=%#x)", + pLvd->ContentsUse.FileSetDescriptor.uType, + pLvd->ContentsUse.FileSetDescriptor.cb, + pLvd->ContentsUse.FileSetDescriptor.Location.uPartitionNo); + + bool fLvdHaveVolId = !ASMMemIsZero(pLvd->achLogicalVolumeID, sizeof(pLvd->achLogicalVolumeID)); + if ( fLvdHaveVolId + && !UDF_IS_CHAR_SET_OSTA(&pLvd->DescCharSet)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_BAD_LVD_DESC_CHAR_SET, + "Logical volume ID is not using OSTA compressed unicode"); + + /* + * We can ignore much, if not all of the primary volume descriptor. + */ + + /* + * We're good. So copy over the data. + */ + pThis->Udf.VolInfo.FileSetDescriptor = pLvd->ContentsUse.FileSetDescriptor; + pThis->Udf.VolInfo.cbBlock = pLvd->cbLogicalBlock; + pThis->Udf.VolInfo.cShiftBlock = 9; + while (pThis->Udf.VolInfo.cbBlock != RT_BIT_32(pThis->Udf.VolInfo.cShiftBlock)) + pThis->Udf.VolInfo.cShiftBlock++; + pThis->Udf.VolInfo.fFlags = pPvd->fFlags; + pThis->Udf.VolInfo.cPartitions = cPartMaps; + pThis->Udf.VolInfo.paPartitions = paPartMaps; + pInfo->paPartMaps = NULL; + if (fLvdHaveVolId) + memcpy(pThis->Udf.VolInfo.achLogicalVolumeID, pLvd->achLogicalVolumeID, sizeof(pThis->Udf.VolInfo.achLogicalVolumeID)); + else + RT_ZERO(pThis->Udf.VolInfo.achLogicalVolumeID); + + return VINF_SUCCESS; +} + + +/** + * Processes a primary volume descriptor in the VDS (UDF). + * + * @returns IPRT status code. + * @param pInfo Where we gather descriptor information. + * @param pDesc The descriptor. + * @param pErrInfo Where to return extended error information. + */ +//cmd: kmk VBoxRT && kmk_redirect -E VBOX_LOG_DEST="nofile stderr" -E VBOX_LOG="rt_fs=~0" -E VBOX_LOG_FLAGS="unbuffered enabled" -- e:\vbox\svn\trunk\out\win.amd64\debug\bin\tools\RTLs.exe :iprtvfs:file(open,d:\Downloads\en_windows_10_enterprise_version_1703_updated_march_2017_x64_dvd_10189290.iso,r):vfs(isofs):/ -la +static int rtFsIsoVolProcessUdfPrimaryVolDesc(PRTFSISOVDSINFO pInfo, PCUDFPRIMARYVOLUMEDESC pDesc, PRTERRINFO pErrInfo) +{ +#ifdef LOG_ENABLED + Log(("ISO/UDF: Primary volume descriptor at sector %#RX32\n", pDesc->Tag.offTag)); + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo); + UDF_LOG2_MEMBER(pDesc, "#010RX32", uPrimaryVolumeDescNo); + UDF_LOG2_MEMBER_DSTRING(pDesc, achVolumeID); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uVolumeSeqNo); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uVolumeSeqNo); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uMaxVolumeSeqNo); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uInterchangeLevel); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uMaxInterchangeLevel); + UDF_LOG2_MEMBER(pDesc, "#010RX32", fCharacterSets); + UDF_LOG2_MEMBER(pDesc, "#010RX32", fMaxCharacterSets); + UDF_LOG2_MEMBER_DSTRING(pDesc, achVolumeSetID); + UDF_LOG2_MEMBER_CHARSPEC(pDesc, DescCharSet); + UDF_LOG2_MEMBER_CHARSPEC(pDesc, ExplanatoryCharSet); + UDF_LOG2_MEMBER_EXTENTAD(pDesc, VolumeAbstract); + UDF_LOG2_MEMBER_EXTENTAD(pDesc, VolumeCopyrightNotice); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idApplication); + UDF_LOG2_MEMBER_TIMESTAMP(pDesc, RecordingTimestamp); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation); + if (!ASMMemIsZero(&pDesc->abImplementationUse, sizeof(pDesc->abImplementationUse))) + Log2(("ISO/UDF: %-32s %.64Rhxs\n", "abReserved[64]:", &pDesc->abImplementationUse[0])); + UDF_LOG2_MEMBER(pDesc, "#010RX32", offPredecessorVolDescSeq); + UDF_LOG2_MEMBER(pDesc, "#06RX16", fFlags); + if (!ASMMemIsZero(&pDesc->abReserved, sizeof(pDesc->abReserved))) + Log2(("ISO/UDF: %-32s %.22Rhxs\n", "abReserved[22]:", &pDesc->abReserved[0])); + } +#endif + + /* + * Check if this is a new revision of an existing primary volume descriptor. + */ + PUDFPRIMARYVOLUMEDESC pEndianConvert = NULL; + uint32_t i = pInfo->cPrimaryVols; + while (i--> 0) + { + if ( memcmp(pDesc->achVolumeID, pInfo->apPrimaryVols[i]->achVolumeID, sizeof(pDesc->achVolumeID)) == 0 + && memcmp(&pDesc->DescCharSet, &pInfo->apPrimaryVols[i]->DescCharSet, sizeof(pDesc->DescCharSet)) == 0) + { + if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apPrimaryVols[i]->uVolumeDescSeqNo) + { + Log(("ISO/UDF: Primary descriptor prevails over previous! (%u >= %u)\n", + RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo)); + pEndianConvert = pInfo->apPrimaryVols[i]; + memcpy(pEndianConvert, pDesc, sizeof(*pDesc)); + } + else + Log(("ISO/UDF: Primary descriptor has lower sequence number than the previous! (%u < %u)\n", + RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo)); + break; + } + } + if (i >= pInfo->cPrimaryVols) + { + /* + * It wasn't. Append it. + */ + i = pInfo->cPrimaryVols; + if (i < RT_ELEMENTS(pInfo->apPrimaryVols)) + { + pInfo->apPrimaryVols[i] = pEndianConvert = (PUDFPRIMARYVOLUMEDESC)RTMemDup(pDesc, sizeof(*pDesc)); + if (pEndianConvert) + pInfo->cPrimaryVols = i + 1; + else + return VERR_NO_MEMORY; + Log2(("ISO/UDF: ++New primary descriptor.\n")); + } + else + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_PVDS, "Encountered too many primary volume descriptors"); + } + +#ifdef RT_BIG_ENDIAN + /* + * Do endian conversion of the descriptor. + */ + if (pEndianConvert) + { + AssertFailed(); + } +#else + RT_NOREF(pEndianConvert); +#endif + return VINF_SUCCESS; +} + + +/** + * Processes an logical volume descriptor in the VDS (UDF). + * + * @returns IPRT status code. + * @param pInfo Where we gather descriptor information. + * @param pDesc The descriptor. + * @param cbSector The sector size (UDF defines the logical and physical + * sector size to be the same). + * @param pErrInfo Where to return extended error information. + */ +static int rtFsIsoVolProcessUdfLogicalVolumeDesc(PRTFSISOVDSINFO pInfo, PCUDFLOGICALVOLUMEDESC pDesc, + uint32_t cbSector, PRTERRINFO pErrInfo) +{ +#ifdef LOG_ENABLED + Log(("ISO/UDF: Logical volume descriptor at sector %#RX32\n", pDesc->Tag.offTag)); + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo); + UDF_LOG2_MEMBER_CHARSPEC(pDesc, DescCharSet); + UDF_LOG2_MEMBER_DSTRING(pDesc, achLogicalVolumeID); + UDF_LOG2_MEMBER(pDesc, "#010RX32", cbLogicalBlock); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idDomain); + if (UDF_ENTITY_ID_EQUALS(&pDesc->idDomain, UDF_ENTITY_ID_LVD_DOMAIN)) + UDF_LOG2_MEMBER_LONGAD(pDesc, ContentsUse.FileSetDescriptor); + else if (!ASMMemIsZero(&pDesc->ContentsUse.ab[0], sizeof(pDesc->ContentsUse.ab))) + Log2(("ISO/UDF: %-32s %.16Rhxs\n", "ContentsUse.ab[16]:", &pDesc->ContentsUse.ab[0])); + UDF_LOG2_MEMBER(pDesc, "#010RX32", cbMapTable); + UDF_LOG2_MEMBER(pDesc, "#010RX32", cPartitionMaps); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation); + if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab))) + Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ImplementationUse.ab[128]:", &pDesc->ImplementationUse.ab[0])); + UDF_LOG2_MEMBER_EXTENTAD(pDesc, IntegritySeqExtent); + if (pDesc->cbMapTable) + { + Log2(("ISO/UDF: %-32s\n", "abPartitionMaps")); + uint32_t iMap = 0; + uint32_t off = 0; + while (off + sizeof(UDFPARTMAPHDR) <= pDesc->cbMapTable) + { + PCUDFPARTMAPHDR pHdr = (PCUDFPARTMAPHDR)&pDesc->abPartitionMaps[off]; + Log2(("ISO/UDF: %02u @ %#05x: type %u, length %u\n", iMap, off, pHdr->bType, pHdr->cb)); + if (off + pHdr->cb > pDesc->cbMapTable) + { + Log2(("ISO/UDF: BAD! Entry is %d bytes too long!\n", off + pHdr->cb - pDesc->cbMapTable)); + break; + } + if (pHdr->bType == 1) + { + PCUDFPARTMAPTYPE1 pType1 = (PCUDFPARTMAPTYPE1)pHdr; + UDF_LOG2_MEMBER_EX(pType1, "#06RX16", uVolumeSeqNo, 5); + UDF_LOG2_MEMBER_EX(pType1, "#06RX16", uPartitionNo, 5); + } + else if (pHdr->bType == 2) + { + PCUDFPARTMAPTYPE2 pType2 = (PCUDFPARTMAPTYPE2)pHdr; + UDF_LOG2_MEMBER_ENTITY_ID_EX(pType2, idPartitionType, 5); + UDF_LOG2_MEMBER_EX(pType2, "#06RX16", uVolumeSeqNo, 5); + UDF_LOG2_MEMBER_EX(pType2, "#06RX16", uPartitionNo, 5); + if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_SPM_PARTITION_TYPE)) + { + UDF_LOG2_MEMBER_EX(&pType2->u, "#06RX16", Spm.cBlocksPerPacket, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Spm.cSparingTables, 5); + if (pType2->u.Spm.bReserved2) + UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Spm.bReserved2, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.cbSparingTable, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[0], 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[1], 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[2], 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Spm.aoffSparingTables[3], 5); + } + else if (UDF_ENTITY_ID_EQUALS(&pType2->idPartitionType, UDF_ENTITY_ID_MPM_PARTITION_TYPE)) + { + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataFile, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataMirrorFile, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.offMetadataBitmapFile, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#010RX32", Mpm.cBlocksAllocationUnit, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#06RX16", Mpm.cBlocksAlignmentUnit, 5); + UDF_LOG2_MEMBER_EX(&pType2->u, "#04RX8", Mpm.fFlags, 5); + if (!ASMMemIsZero(pType2->u.Mpm.abReserved2, sizeof(pType2->u.Mpm.abReserved2))) + UDF_LOG2_MEMBER_EX(&pType2->u, ".5Rhxs", Mpm.abReserved2, 5); + } + } + else + Log2(("ISO/UDF: BAD! Unknown type!\n")); + + /* advance */ + off += pHdr->cb; + iMap++; + } + } + } +#endif + + /* + * Check if this is a newer revision of an existing primary volume descriptor. + */ + size_t cbDesc = (size_t)pDesc->cbMapTable + RT_UOFFSETOF(UDFLOGICALVOLUMEDESC, abPartitionMaps); + if ( pDesc->cbMapTable >= (UINT32_MAX >> 1) + || cbDesc > cbSector) + { + Log(("ISO/UDF: Logical volume descriptor is too big: %#zx (cbSector=%#x)\n", cbDesc, cbSector)); + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_TOO_BIT_PARTMAP_IN_LVD, + "Logical volume descriptor is too big: %#zx (cbSector=%#x)\n", cbDesc, cbSector); + } + + PUDFLOGICALVOLUMEDESC pEndianConvert = NULL; + uint32_t i = pInfo->cLogicalVols; + while (i--> 0) + if ( memcmp(pDesc->achLogicalVolumeID, pInfo->apLogicalVols[i]->achLogicalVolumeID, + sizeof(pDesc->achLogicalVolumeID)) == 0 + && memcmp(&pDesc->DescCharSet, &pInfo->apLogicalVols[i]->DescCharSet, + sizeof(pDesc->DescCharSet)) == 0) + { + if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apLogicalVols[i]->uVolumeDescSeqNo) + { + Log(("ISO/UDF: Logical descriptor prevails over previous! (%u >= %u)\n", + RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apLogicalVols[i]->uVolumeDescSeqNo)); + pEndianConvert = (PUDFLOGICALVOLUMEDESC)RTMemDup(pDesc, cbDesc); + if (!pEndianConvert) + return VERR_NO_MEMORY; + RTMemFree(pInfo->apLogicalVols[i]); + pInfo->apLogicalVols[i] = pEndianConvert; + } + else + Log(("ISO/UDF: Logical descriptor has lower sequence number than the previous! (%u >= %u)\n", + RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apLogicalVols[i]->uVolumeDescSeqNo)); + break; + } + if (i >= pInfo->cLogicalVols) + { + /* + * It wasn't. Append it. + */ + i = pInfo->cLogicalVols; + if (i < RT_ELEMENTS(pInfo->apLogicalVols)) + { + pInfo->apLogicalVols[i] = pEndianConvert = (PUDFLOGICALVOLUMEDESC)RTMemDup(pDesc, cbDesc); + if (pEndianConvert) + pInfo->cLogicalVols = i + 1; + else + return VERR_NO_MEMORY; + Log2(("ISO/UDF: ++New logical volume descriptor.\n")); + } + else + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_LVDS, "Too many logical volume descriptors"); + } + +#ifdef RT_BIG_ENDIAN + /* + * Do endian conversion of the descriptor. + */ + if (pEndianConvert) + { + AssertFailed(); + } +#else + RT_NOREF(pEndianConvert); +#endif + return VINF_SUCCESS; +} + + +/** + * Processes an partition descriptor in the VDS (UDF). + * + * @returns IPRT status code. + * @param pInfo Where we gather descriptor information. + * @param pDesc The descriptor. + * @param pErrInfo Where to return extended error information. + */ +static int rtFsIsoVolProcessUdfPartitionDesc(PRTFSISOVDSINFO pInfo, PCUDFPARTITIONDESC pDesc, PRTERRINFO pErrInfo) +{ +#ifdef LOG_ENABLED + Log(("ISO/UDF: Partition descriptor at sector %#RX32\n", pDesc->Tag.offTag)); + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo); + UDF_LOG2_MEMBER(pDesc, "#06RX16", fFlags); + UDF_LOG2_MEMBER(pDesc, "#06RX16", uPartitionNo); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, PartitionContents); + if (UDF_ENTITY_ID_EQUALS(&pDesc->PartitionContents, UDF_ENTITY_ID_PD_PARTITION_CONTENTS_UDF)) + { + UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.UnallocatedSpaceTable); + UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.UnallocatedSpaceBitmap); + UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.PartitionIntegrityTable); + UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.FreedSpaceTable); + UDF_LOG2_MEMBER_SHORTAD(&pDesc->ContentsUse, Hdr.FreedSpaceBitmap); + if (!ASMMemIsZero(&pDesc->ContentsUse.Hdr.abReserved[0], sizeof(pDesc->ContentsUse.Hdr.abReserved))) + Log2(("ISO/UDF: %-32s\n%.88RhxD\n", "Hdr.abReserved[88]:", &pDesc->ContentsUse.Hdr.abReserved[0])); + } + else if (!ASMMemIsZero(&pDesc->ContentsUse.ab[0], sizeof(pDesc->ContentsUse.ab))) + Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ContentsUse.ab[128]:", &pDesc->ContentsUse.ab[0])); + UDF_LOG2_MEMBER(pDesc, "#010RX32", uAccessType); + UDF_LOG2_MEMBER(pDesc, "#010RX32", offLocation); + UDF_LOG2_MEMBER(pDesc, "#010RX32", cSectors); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation); + if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab))) + Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "ImplementationUse.ab[128]:", &pDesc->ImplementationUse.ab[0])); + + if (!ASMMemIsZero(&pDesc->abReserved[0], sizeof(pDesc->abReserved))) + Log2(("ISO/UDF: %-32s\n%.156RhxD\n", "ImplementationUse.ab[156]:", &pDesc->abReserved[0])); + } +#endif + + /* + * Check if this is a newer revision of an existing primary volume descriptor. + */ + PUDFPARTITIONDESC pEndianConvert = NULL; + uint32_t i = pInfo->cPartitions; + while (i--> 0) + if (pDesc->uPartitionNo == pInfo->apPartitions[i]->uPartitionNo) + { + if (RT_LE2H_U32(pDesc->uVolumeDescSeqNo) >= pInfo->apPartitions[i]->uVolumeDescSeqNo) + { + Log(("ISO/UDF: Partition descriptor for part %#u prevails over previous! (%u >= %u)\n", + pDesc->uPartitionNo, RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo)); + pEndianConvert = pInfo->apPartitions[i]; + memcpy(pEndianConvert, pDesc, sizeof(*pDesc)); + } + else + Log(("ISO/UDF: Partition descriptor for part %#u has a lower sequence number than the previous! (%u < %u)\n", + pDesc->uPartitionNo, RT_LE2H_U32(pDesc->uVolumeDescSeqNo), pInfo->apPartitions[i]->uVolumeDescSeqNo)); + break; + } + if (i >= pInfo->cPartitions) + { + /* + * It wasn't. Append it. + */ + i = pInfo->cPartitions; + if (i < RT_ELEMENTS(pInfo->apPartitions)) + { + pInfo->apPartitions[i] = pEndianConvert = (PUDFPARTITIONDESC)RTMemDup(pDesc, sizeof(*pDesc)); + if (pEndianConvert) + pInfo->cPartitions = i + 1; + else + return VERR_NO_MEMORY; + Log2(("ISO/UDF: ++New partition descriptor.\n")); + } + else + return RTERRINFO_LOG_SET(pErrInfo, VERR_ISOFS_TOO_MANY_PDS, "Too many physical volume descriptors"); + } + +#ifdef RT_BIG_ENDIAN + /* + * Do endian conversion of the descriptor. + */ + if (pEndianConvert) + { + AssertFailed(); + } +#else + RT_NOREF(pEndianConvert); +#endif + return VINF_SUCCESS; +} + + +/** + * Processes an implementation use descriptor in the VDS (UDF). + * + * @returns IPRT status code. + * @param pInfo Where we gather descriptor information. + * @param pDesc The descriptor. + * @param pErrInfo Where to return extended error information. + */ +static int rtFsIsoVolProcessUdfImplUseVolDesc(PRTFSISOVDSINFO pInfo, PCUDFIMPLEMENTATIONUSEVOLUMEDESC pDesc, PRTERRINFO pErrInfo) +{ +#ifdef LOG_ENABLED + Log(("ISO/UDF: Implementation use volume descriptor at sector %#RX32\n", pDesc->Tag.offTag)); + if (LogIs2Enabled()) + { + UDF_LOG2_MEMBER(pDesc, "#010RX32", uVolumeDescSeqNo); + UDF_LOG2_MEMBER_ENTITY_ID(pDesc, idImplementation); + if (UDF_ENTITY_ID_EQUALS(&pDesc->idImplementation, UDF_ENTITY_ID_IUVD_IMPLEMENTATION)) + { + UDF_LOG2_MEMBER_CHARSPEC(&pDesc->ImplementationUse, Lvi.Charset); + UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achVolumeID); + UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo1); + UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo2); + UDF_LOG2_MEMBER_DSTRING(&pDesc->ImplementationUse, Lvi.achInfo3); + UDF_LOG2_MEMBER_ENTITY_ID(&pDesc->ImplementationUse, Lvi.idImplementation); + if (!ASMMemIsZero(&pDesc->ImplementationUse.Lvi.abUse[0], sizeof(pDesc->ImplementationUse.Lvi.abUse))) + Log2(("ISO/UDF: %-32s\n%.128RhxD\n", "Lvi.abUse[128]:", &pDesc->ImplementationUse.Lvi.abUse[0])); + } + else if (!ASMMemIsZero(&pDesc->ImplementationUse.ab[0], sizeof(pDesc->ImplementationUse.ab))) + Log2(("ISO/UDF: %-32s\n%.460RhxD\n", "ImplementationUse.ab[460]:", &pDesc->ImplementationUse.ab[0])); + } +#endif + + RT_NOREF(pInfo, pDesc, pErrInfo); + return VINF_SUCCESS; +} + + + +typedef struct RTFSISOSEENSEQENCES +{ + /** Number of sequences we've seen thus far. */ + uint32_t cSequences; + /** The per sequence data. */ + struct + { + uint64_t off; /**< Byte offset of the sequence. */ + uint32_t cb; /**< Size of the sequence. */ + } aSequences[8]; +} RTFSISOSEENSEQENCES; +typedef RTFSISOSEENSEQENCES *PRTFSISOSEENSEQENCES; + + + +/** + * Process a VDS sequence, recursively dealing with volume descriptor pointers. + * + * This function only gathers information from the sequence, handling the + * prevailing descriptor fun. + * + * @returns IPRT status code. + * @param pThis The instance. + * @param pInfo Where to store info from the VDS sequence. + * @param offSeq The byte offset of the sequence. + * @param cbSeq The length of the sequence. + * @param pbBuf Read buffer. + * @param cbBuf Size of the read buffer. This is at least one + * sector big. + * @param cNestings The VDS nesting depth. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolReadAndProcessUdfVdsSeq(PRTFSISOVOL pThis, PRTFSISOVDSINFO pInfo, uint64_t offSeq, uint32_t cbSeq, + uint8_t *pbBuf, size_t cbBuf, uint32_t cNestings, PRTERRINFO pErrInfo) +{ + AssertReturn(cbBuf >= pThis->cbSector, VERR_INTERNAL_ERROR); + + /* + * Check nesting depth. + */ + if (cNestings > 5) + return RTERRINFO_LOG_SET(pErrInfo, VERR_TOO_MUCH_DATA, "The volume descriptor sequence (VDS) is nested too deeply."); + + + /* + * Do the processing sector by sector to keep things simple. + */ + uint32_t offInSeq = 0; + while (offInSeq < cbSeq) + { + int rc; + + /* + * Read the next sector. Zero pad if less that a sector. + */ + Assert((offInSeq & (pThis->cbSector - 1)) == 0); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offSeq + offInSeq, pbBuf, pThis->cbSector, NULL); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Error reading VDS content at %RX64 (LB %#x): %Rrc", + offSeq + offInSeq, pThis->cbSector, rc); + if (cbSeq - offInSeq < pThis->cbSector) + memset(&pbBuf[cbSeq - offInSeq], 0, pThis->cbSector - (cbSeq - offInSeq)); + + /* + * Check tag. + */ + PCUDFTAG pTag = (PCUDFTAG)pbBuf; + rc = rtFsIsoVolValidateUdfDescTagAndCrc(pTag, pThis->cbSector, UINT16_MAX, (offSeq + offInSeq) / pThis->cbSector, pErrInfo); + if ( RT_SUCCESS(rc) + || ( rc == VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC + && ( pTag->idTag == UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC + || pTag->idTag == UDF_TAG_ID_LOGICAL_VOLUME_DESC + || pTag->idTag == UDF_TAG_ID_UNALLOCATED_SPACE_DESC + ) + ) + ) + { + switch (pTag->idTag) + { + case UDF_TAG_ID_PRIMARY_VOL_DESC: + rc = rtFsIsoVolProcessUdfPrimaryVolDesc(pInfo, (PCUDFPRIMARYVOLUMEDESC)pTag, pErrInfo); + break; + + case UDF_TAG_ID_IMPLEMENTATION_USE_VOLUME_DESC: + rc = rtFsIsoVolProcessUdfImplUseVolDesc(pInfo, (PCUDFIMPLEMENTATIONUSEVOLUMEDESC)pTag, pErrInfo); + break; + + case UDF_TAG_ID_PARTITION_DESC: + rc = rtFsIsoVolProcessUdfPartitionDesc(pInfo, (PCUDFPARTITIONDESC)pTag, pErrInfo); + break; + + case UDF_TAG_ID_LOGICAL_VOLUME_DESC: + if (rc != VERR_ISOFS_INSUFFICIENT_DATA_FOR_DESC_CRC) + rc = rtFsIsoVolProcessUdfLogicalVolumeDesc(pInfo, (PCUDFLOGICALVOLUMEDESC)pTag, + pThis->cbSector, pErrInfo); + else + rc = VERR_ISOFS_TOO_BIT_PARTMAP_IN_LVD; + break; + + case UDF_TAG_ID_LOGICAL_VOLUME_INTEGRITY_DESC: + Log(("ISO/UDF: Ignoring logical volume integrity descriptor at offset %#RX64.\n", offSeq + offInSeq)); + rc = VINF_SUCCESS; + break; + + case UDF_TAG_ID_UNALLOCATED_SPACE_DESC: + Log(("ISO/UDF: Ignoring unallocated space descriptor at offset %#RX64.\n", offSeq + offInSeq)); + rc = VINF_SUCCESS; + break; + + case UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR: + Log(("ISO/UDF: Ignoring AVDP in VDS (at offset %#RX64).\n", offSeq + offInSeq)); + rc = VINF_SUCCESS; + break; + + case UDF_TAG_ID_VOLUME_DESC_PTR: + { + PCUDFVOLUMEDESCPTR pVdp = (PCUDFVOLUMEDESCPTR)pTag; + Log(("ISO/UDF: Processing volume descriptor pointer at offset %#RX64: %#x LB %#x (seq %#x); cNestings=%d\n", + offSeq + offInSeq, pVdp->NextVolumeDescSeq.off, pVdp->NextVolumeDescSeq.cb, + pVdp->uVolumeDescSeqNo, cNestings)); + rc = rtFsIsoVolReadAndProcessUdfVdsSeq(pThis, pInfo, (uint64_t)pVdp->NextVolumeDescSeq.off * pThis->cbSector, + pVdp->NextVolumeDescSeq.cb, pbBuf, cbBuf, cNestings + 1, pErrInfo); + break; + } + + case UDF_TAG_ID_TERMINATING_DESC: + Log(("ISO/UDF: Terminating descriptor at offset %#RX64\n", offSeq + offInSeq)); + return VINF_SUCCESS; + + default: + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_ISOFS_UNEXPECTED_VDS_DESC, + "Unexpected/unknown VDS descriptor %#x at byte offset %#RX64", + pThis->cbSector, offSeq + offInSeq); + } + if (RT_FAILURE(rc)) + return rc; + } + /* The descriptor sequence is usually zero padded to 16 sectors. Just + ignore zero descriptors. */ + else if (rc != VERR_ISOFS_TAG_IS_ALL_ZEROS) + return rc; + + /* + * Advance. + */ + offInSeq += pThis->cbSector; + } + + return VINF_SUCCESS; +} + + + +/** + * Processes a volume descriptor sequence (VDS). + * + * @returns IPRT status code. + * @param pThis The instance. + * @param offSeq The byte offset of the sequence. + * @param cbSeq The length of the sequence. + * @param pSeenSequences Structure where to keep track of VDSes we've already + * processed, to avoid redoing one that we don't + * understand. + * @param pbBuf Read buffer. + * @param cbBuf Size of the read buffer. This is at least one + * sector big. + * @param pErrInfo Where to report extended error information. + */ +static int rtFsIsoVolReadAndProcessUdfVds(PRTFSISOVOL pThis, uint64_t offSeq, uint32_t cbSeq, + PRTFSISOSEENSEQENCES pSeenSequences, uint8_t *pbBuf, size_t cbBuf, + PRTERRINFO pErrInfo) +{ + /* + * Skip if already seen. + */ + uint32_t i = pSeenSequences->cSequences; + while (i-- > 0) + if ( pSeenSequences->aSequences[i].off == offSeq + && pSeenSequences->aSequences[i].cb == cbSeq) + return VERR_NOT_FOUND; + + /* Not seen, so add it. */ + Assert(pSeenSequences->cSequences + 1 <= RT_ELEMENTS(pSeenSequences->aSequences)); + pSeenSequences->aSequences[pSeenSequences->cSequences].cb = cbSeq; + pSeenSequences->aSequences[pSeenSequences->cSequences].off = offSeq; + pSeenSequences->cSequences++; + + LogFlow(("ISO/UDF: Processing anchor volume descriptor sequence at offset %#RX64 LB %#RX32\n", offSeq, cbSeq)); + + /* + * Gather relevant descriptor info from the VDS then process it and on + * success copy it into the instance. + * + * The processing has to be done in a different function because there may + * be links to sub-sequences that needs to be processed. We do this by + * recursing and check that we don't go to deep. + */ + RTFSISOVDSINFO Info; + RT_ZERO(Info); + int rc = rtFsIsoVolReadAndProcessUdfVdsSeq(pThis, &Info, offSeq, cbSeq, pbBuf, cbBuf, 0, pErrInfo); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoVolProcessUdfVdsSeqInfo(pThis, &Info, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsIsoVolProcessUdfFileSetDescs(pThis, pbBuf, cbBuf, pErrInfo); + } + + /* + * Clean up info. + */ + i = Info.cPrimaryVols; + while (i-- > 0) + RTMemFree(Info.apPrimaryVols[i]); + + i = Info.cLogicalVols; + while (i-- > 0) + RTMemFree(Info.apLogicalVols[i]); + + i = Info.cPartitions; + while (i-- > 0) + RTMemFree(Info.apPartitions[i]); + + RTMemFree(Info.paPartMaps); + + return rc; +} + + +static int rtFsIsoVolReadAndHandleUdfAvdp(PRTFSISOVOL pThis, uint64_t offAvdp, uint8_t *pbBuf, size_t cbBuf, + PRTFSISOSEENSEQENCES pSeenSequences, PRTERRINFO pErrInfo) +{ + /* + * Try read the descriptor and validate its tag. + */ + PUDFANCHORVOLUMEDESCPTR pAvdp = (PUDFANCHORVOLUMEDESCPTR)pbBuf; + size_t cbAvdpRead = RT_MIN(pThis->cbSector, cbBuf); + int rc = RTVfsFileReadAt(pThis->hVfsBacking, offAvdp, pAvdp, cbAvdpRead, NULL); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoVolValidateUdfDescTag(&pAvdp->Tag, UDF_TAG_ID_ANCHOR_VOLUME_DESC_PTR, offAvdp / pThis->cbSector, pErrInfo); + if (RT_SUCCESS(rc)) + { + Log2(("ISO/UDF: AVDP: MainVolumeDescSeq=%#RX32 LB %#RX32, ReserveVolumeDescSeq=%#RX32 LB %#RX32\n", + pAvdp->MainVolumeDescSeq.off, pAvdp->MainVolumeDescSeq.cb, + pAvdp->ReserveVolumeDescSeq.off, pAvdp->ReserveVolumeDescSeq.cb)); + + /* + * Try the main sequence if it looks sane. + */ + UDFEXTENTAD const ReserveVolumeDescSeq = pAvdp->ReserveVolumeDescSeq; + if ( pAvdp->MainVolumeDescSeq.off < pThis->cBackingSectors + && (uint64_t)pAvdp->MainVolumeDescSeq.off + + (pAvdp->MainVolumeDescSeq.cb + pThis->cbSector - 1) / pThis->cbSector + <= pThis->cBackingSectors) + { + rc = rtFsIsoVolReadAndProcessUdfVds(pThis, (uint64_t)pAvdp->MainVolumeDescSeq.off * pThis->cbSector, + pAvdp->MainVolumeDescSeq.cb, pSeenSequences, pbBuf, cbBuf, pErrInfo); + if (RT_SUCCESS(rc)) + return rc; + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_FOUND, + "MainVolumeDescSeq is out of bounds: sector %#RX32 LB %#RX32 bytes, image is %#RX64 sectors", + pAvdp->MainVolumeDescSeq.off, pAvdp->MainVolumeDescSeq.cb, pThis->cBackingSectors); + if (ReserveVolumeDescSeq.cb > 0) + { + if ( ReserveVolumeDescSeq.off < pThis->cBackingSectors + && (uint64_t)ReserveVolumeDescSeq.off + + (ReserveVolumeDescSeq.cb + pThis->cbSector - 1) / pThis->cbSector + <= pThis->cBackingSectors) + { + rc = rtFsIsoVolReadAndProcessUdfVds(pThis, (uint64_t)ReserveVolumeDescSeq.off * pThis->cbSector, + ReserveVolumeDescSeq.cb, pSeenSequences, pbBuf, cbBuf, pErrInfo); + if (RT_SUCCESS(rc)) + return rc; + } + else if (RT_SUCCESS(rc)) + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_FOUND, + "ReserveVolumeDescSeq is out of bounds: sector %#RX32 LB %#RX32 bytes, image is %#RX64 sectors", + ReserveVolumeDescSeq.off, ReserveVolumeDescSeq.cb, pThis->cBackingSectors); + } + } + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, rc, + "Error reading sector at offset %#RX64 (anchor volume descriptor pointer): %Rrc", offAvdp, rc); + + return rc; +} + + +/** + * Goes looking for UDF when we've seens a volume recognition sequence. + * + * @returns IPRT status code. + * @param pThis The volume instance data. + * @param puUdfLevel The UDF level indicated by the VRS. + * @param offUdfBootVolDesc The offset of the BOOT2 descriptor, UINT64_MAX + * if not encountered. + * @param pbBuf Buffer for reading into. + * @param cbBuf The size of the buffer. At least one sector. + * @param pErrInfo Where to return extended error info. + */ +static int rtFsIsoVolHandleUdfDetection(PRTFSISOVOL pThis, uint8_t *puUdfLevel, uint64_t offUdfBootVolDesc, + uint8_t *pbBuf, size_t cbBuf, PRTERRINFO pErrInfo) +{ + NOREF(offUdfBootVolDesc); + + /* + * There are up to three anchor volume descriptor pointers that can give us + * two different descriptor sequences each. Usually, the different AVDP + * structures points to the same two sequences. The idea here is that + * sectors may deteriorate and become unreadable, and we're supposed to try + * out alternative sectors to get the job done. If we really took this + * seriously, we could try read all sequences in parallel and use the + * sectors that are good. However, we'll try keep things reasonably simple + * since we'll most likely be reading from hard disks rather than optical + * media. + * + * We keep track of which sequences we've processed so we don't try to do it + * again when alternative AVDP sectors points to the same sequences. + */ + pThis->Udf.uLevel = *puUdfLevel; + RTFSISOSEENSEQENCES SeenSequences = { 0 }; + int rc1 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, 256 * pThis->cbSector, pbBuf, cbBuf, + &SeenSequences, pErrInfo); + if (RT_SUCCESS(rc1)) + return rc1; + + int rc2 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, pThis->cbBacking - 256 * pThis->cbSector, + pbBuf, cbBuf, &SeenSequences, pErrInfo); + if (RT_SUCCESS(rc2)) + return rc2; + + int rc3 = rtFsIsoVolReadAndHandleUdfAvdp(pThis, pThis->cbBacking - pThis->cbSector, + pbBuf, cbBuf, &SeenSequences, pErrInfo); + if (RT_SUCCESS(rc3)) + return rc3; + + /* + * Return failure if the alternatives have been excluded. + * + * Note! The error info won't be correct here. + */ + pThis->Udf.uLevel = *puUdfLevel = 0; + + if (RTFSISO9660_F_IS_ONLY_TYPE(pThis->fFlags, RTFSISO9660_F_NO_UDF)) + return rc1 != VERR_NOT_FOUND ? rc1 : rc2 != VERR_NOT_FOUND ? rc2 : rc3; + return VINF_SUCCESS; +} + + + +#ifdef LOG_ENABLED + +/** Logging helper. */ +static size_t rtFsIsoVolGetStrippedLength(const char *pachField, size_t cchField) +{ + while (cchField > 0 && pachField[cchField - 1] == ' ') + cchField--; + return cchField; +} + +/** Logging helper. */ +static char *rtFsIsoVolGetMaybeUtf16Be(const char *pachField, size_t cchField, char *pszDst, size_t cbDst) +{ + /* Check the format by looking for zero bytes. ISO-9660 doesn't allow zeros. + This doesn't have to be a UTF-16BE string. */ + size_t cFirstZeros = 0; + size_t cSecondZeros = 0; + for (size_t off = 0; off + 1 < cchField; off += 2) + { + cFirstZeros += pachField[off] == '\0'; + cSecondZeros += pachField[off + 1] == '\0'; + } + + int rc = VINF_SUCCESS; + char *pszTmp = &pszDst[10]; + size_t cchRet = 0; + if (cFirstZeros > cSecondZeros) + { + /* UTF-16BE / UTC-2BE: */ + if (cchField & 1) + { + if (pachField[cchField - 1] == '\0' || pachField[cchField - 1] == ' ') + cchField--; + else + rc = VERR_INVALID_UTF16_ENCODING; + } + if (RT_SUCCESS(rc)) + { + while ( cchField >= 2 + && pachField[cchField - 1] == ' ' + && pachField[cchField - 2] == '\0') + cchField -= 2; + + rc = RTUtf16BigToUtf8Ex((PCRTUTF16)pachField, cchField / sizeof(RTUTF16), &pszTmp, cbDst - 10 - 1, &cchRet); + } + if (RT_SUCCESS(rc)) + { + pszDst[0] = 'U'; + pszDst[1] = 'T'; + pszDst[2] = 'F'; + pszDst[3] = '-'; + pszDst[4] = '1'; + pszDst[5] = '6'; + pszDst[6] = 'B'; + pszDst[7] = 'E'; + pszDst[8] = ':'; + pszDst[9] = '\''; + pszDst[10 + cchRet] = '\''; + pszDst[10 + cchRet + 1] = '\0'; + } + else + RTStrPrintf(pszDst, cbDst, "UTF-16BE: %.*Rhxs", cchField, pachField); + } + else if (cSecondZeros > 0) + { + /* Little endian UTF-16 / UCS-2 (ASSUMES host is little endian, sorry) */ + if (cchField & 1) + { + if (pachField[cchField - 1] == '\0' || pachField[cchField - 1] == ' ') + cchField--; + else + rc = VERR_INVALID_UTF16_ENCODING; + } + if (RT_SUCCESS(rc)) + { + while ( cchField >= 2 + && pachField[cchField - 1] == '\0' + && pachField[cchField - 2] == ' ') + cchField -= 2; + + rc = RTUtf16ToUtf8Ex((PCRTUTF16)pachField, cchField / sizeof(RTUTF16), &pszTmp, cbDst - 10 - 1, &cchRet); + } + if (RT_SUCCESS(rc)) + { + pszDst[0] = 'U'; + pszDst[1] = 'T'; + pszDst[2] = 'F'; + pszDst[3] = '-'; + pszDst[4] = '1'; + pszDst[5] = '6'; + pszDst[6] = 'L'; + pszDst[7] = 'E'; + pszDst[8] = ':'; + pszDst[9] = '\''; + pszDst[10 + cchRet] = '\''; + pszDst[10 + cchRet + 1] = '\0'; + } + else + RTStrPrintf(pszDst, cbDst, "UTF-16LE: %.*Rhxs", cchField, pachField); + } + else + { + /* ASSUME UTF-8/ASCII. */ + while ( cchField > 0 + && pachField[cchField - 1] == ' ') + cchField--; + rc = RTStrValidateEncodingEx(pachField, cchField, RTSTR_VALIDATE_ENCODING_EXACT_LENGTH); + if (RT_SUCCESS(rc)) + RTStrPrintf(pszDst, cbDst, "UTF-8: '%.*s'", cchField, pachField); + else + RTStrPrintf(pszDst, cbDst, "UNK-8: %.*Rhxs", cchField, pachField); + } + return pszDst; +} + + +/** + * Logs the primary or supplementary volume descriptor + * + * @param pVolDesc The descriptor. + */ +static void rtFsIsoVolLogPrimarySupplementaryVolDesc(PCISO9660SUPVOLDESC pVolDesc) +{ + if (LogIs2Enabled()) + { + char szTmp[384]; + Log2(("ISO9660: fVolumeFlags: %#RX8\n", pVolDesc->fVolumeFlags)); + Log2(("ISO9660: achSystemId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achSystemId, sizeof(pVolDesc->achSystemId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achVolumeId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achVolumeId, sizeof(pVolDesc->achVolumeId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: Unused73: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->Unused73.be), RT_LE2H_U32(pVolDesc->Unused73.le))); + Log2(("ISO9660: VolumeSpaceSize: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le))); + Log2(("ISO9660: abEscapeSequences: '%.*s'\n", rtFsIsoVolGetStrippedLength((char *)pVolDesc->abEscapeSequences, sizeof(pVolDesc->abEscapeSequences)), pVolDesc->abEscapeSequences)); + Log2(("ISO9660: cVolumesInSet: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le))); + Log2(("ISO9660: VolumeSeqNo: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le))); + Log2(("ISO9660: cbLogicalBlock: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le))); + Log2(("ISO9660: cbPathTable: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->cbPathTable.be), RT_LE2H_U32(pVolDesc->cbPathTable.le))); + Log2(("ISO9660: offTypeLPathTable: %#RX32\n", RT_LE2H_U32(pVolDesc->offTypeLPathTable))); + Log2(("ISO9660: offOptionalTypeLPathTable: %#RX32\n", RT_LE2H_U32(pVolDesc->offOptionalTypeLPathTable))); + Log2(("ISO9660: offTypeMPathTable: %#RX32\n", RT_BE2H_U32(pVolDesc->offTypeMPathTable))); + Log2(("ISO9660: offOptionalTypeMPathTable: %#RX32\n", RT_BE2H_U32(pVolDesc->offOptionalTypeMPathTable))); + Log2(("ISO9660: achVolumeSetId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achVolumeSetId, sizeof(pVolDesc->achVolumeSetId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achPublisherId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achPublisherId, sizeof(pVolDesc->achPublisherId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achDataPreparerId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achDataPreparerId, sizeof(pVolDesc->achDataPreparerId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achApplicationId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achApplicationId, sizeof(pVolDesc->achApplicationId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achCopyrightFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achCopyrightFileId, sizeof(pVolDesc->achCopyrightFileId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achAbstractFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achAbstractFileId, sizeof(pVolDesc->achAbstractFileId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: achBibliographicFileId: %s\n", rtFsIsoVolGetMaybeUtf16Be(pVolDesc->achBibliographicFileId, sizeof(pVolDesc->achBibliographicFileId), szTmp, sizeof(szTmp)) )); + Log2(("ISO9660: BirthTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n", + pVolDesc->BirthTime.achYear, + pVolDesc->BirthTime.achMonth, + pVolDesc->BirthTime.achDay, + pVolDesc->BirthTime.achHour, + pVolDesc->BirthTime.achMinute, + pVolDesc->BirthTime.achSecond, + pVolDesc->BirthTime.achCentisecond, + pVolDesc->BirthTime.offUtc*4/60)); + Log2(("ISO9660: ModifyTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n", + pVolDesc->ModifyTime.achYear, + pVolDesc->ModifyTime.achMonth, + pVolDesc->ModifyTime.achDay, + pVolDesc->ModifyTime.achHour, + pVolDesc->ModifyTime.achMinute, + pVolDesc->ModifyTime.achSecond, + pVolDesc->ModifyTime.achCentisecond, + pVolDesc->ModifyTime.offUtc*4/60)); + Log2(("ISO9660: ExpireTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n", + pVolDesc->ExpireTime.achYear, + pVolDesc->ExpireTime.achMonth, + pVolDesc->ExpireTime.achDay, + pVolDesc->ExpireTime.achHour, + pVolDesc->ExpireTime.achMinute, + pVolDesc->ExpireTime.achSecond, + pVolDesc->ExpireTime.achCentisecond, + pVolDesc->ExpireTime.offUtc*4/60)); + Log2(("ISO9660: EffectiveTime: %.4s-%.2s-%.2s %.2s:%.2s:%.2s.%.2s%+03d\n", + pVolDesc->EffectiveTime.achYear, + pVolDesc->EffectiveTime.achMonth, + pVolDesc->EffectiveTime.achDay, + pVolDesc->EffectiveTime.achHour, + pVolDesc->EffectiveTime.achMinute, + pVolDesc->EffectiveTime.achSecond, + pVolDesc->EffectiveTime.achCentisecond, + pVolDesc->EffectiveTime.offUtc*4/60)); + Log2(("ISO9660: bFileStructureVersion: %#RX8\n", pVolDesc->bFileStructureVersion)); + Log2(("ISO9660: bReserved883: %#RX8\n", pVolDesc->bReserved883)); + + Log2(("ISO9660: RootDir.cbDirRec: %#RX8\n", pVolDesc->RootDir.DirRec.cbDirRec)); + Log2(("ISO9660: RootDir.cExtAttrBlocks: %#RX8\n", pVolDesc->RootDir.DirRec.cExtAttrBlocks)); + Log2(("ISO9660: RootDir.offExtent: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->RootDir.DirRec.offExtent.be), RT_LE2H_U32(pVolDesc->RootDir.DirRec.offExtent.le))); + Log2(("ISO9660: RootDir.cbData: {%#RX32,%#RX32}\n", RT_BE2H_U32(pVolDesc->RootDir.DirRec.cbData.be), RT_LE2H_U32(pVolDesc->RootDir.DirRec.cbData.le))); + Log2(("ISO9660: RootDir.RecTime: %04u-%02u-%02u %02u:%02u:%02u%+03d\n", + pVolDesc->RootDir.DirRec.RecTime.bYear + 1900, + pVolDesc->RootDir.DirRec.RecTime.bMonth, + pVolDesc->RootDir.DirRec.RecTime.bDay, + pVolDesc->RootDir.DirRec.RecTime.bHour, + pVolDesc->RootDir.DirRec.RecTime.bMinute, + pVolDesc->RootDir.DirRec.RecTime.bSecond, + pVolDesc->RootDir.DirRec.RecTime.offUtc*4/60)); + Log2(("ISO9660: RootDir.RecTime.fFileFlags: %RX8\n", pVolDesc->RootDir.DirRec.fFileFlags)); + Log2(("ISO9660: RootDir.RecTime.bFileUnitSize: %RX8\n", pVolDesc->RootDir.DirRec.bFileUnitSize)); + Log2(("ISO9660: RootDir.RecTime.bInterleaveGapSize: %RX8\n", pVolDesc->RootDir.DirRec.bInterleaveGapSize)); + Log2(("ISO9660: RootDir.RecTime.VolumeSeqNo: {%#RX16,%#RX16}\n", RT_BE2H_U16(pVolDesc->RootDir.DirRec.VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->RootDir.DirRec.VolumeSeqNo.le))); + Log2(("ISO9660: RootDir.RecTime.bFileIdLength: %RX8\n", pVolDesc->RootDir.DirRec.bFileIdLength)); + Log2(("ISO9660: RootDir.RecTime.achFileId: '%.*s'\n", pVolDesc->RootDir.DirRec.bFileIdLength, pVolDesc->RootDir.DirRec.achFileId)); + uint32_t offSysUse = RT_UOFFSETOF_DYN(ISO9660DIRREC, achFileId[pVolDesc->RootDir.DirRec.bFileIdLength]) + + !(pVolDesc->RootDir.DirRec.bFileIdLength & 1); + if (offSysUse < pVolDesc->RootDir.DirRec.cbDirRec) + { + Log2(("ISO9660: RootDir System Use:\n%.*RhxD\n", + pVolDesc->RootDir.DirRec.cbDirRec - offSysUse, &pVolDesc->RootDir.ab[offSysUse])); + } + } +} + +#endif /* LOG_ENABLED */ + +/** + * Deal with a root directory from a primary or supplemental descriptor. + * + * @returns IPRT status code. + * @param pThis The ISO 9660 instance being initialized. + * @param pRootDir The root directory record to check out. + * @param pDstRootDir Where to store a copy of the root dir record. + * @param pErrInfo Where to return additional error info. Can be NULL. + */ +static int rtFsIsoVolHandleRootDir(PRTFSISOVOL pThis, PCISO9660DIRREC pRootDir, + PISO9660DIRREC pDstRootDir, PRTERRINFO pErrInfo) +{ + if (pRootDir->cbDirRec < RT_UOFFSETOF(ISO9660DIRREC, achFileId)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Root dir record size is too small: %#x (min %#x)", + pRootDir->cbDirRec, RT_UOFFSETOF(ISO9660DIRREC, achFileId)); + + if (!(pRootDir->fFileFlags & ISO9660_FILE_FLAGS_DIRECTORY)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Root dir is not flagged as directory: %#x", pRootDir->fFileFlags); + if (pRootDir->fFileFlags & ISO9660_FILE_FLAGS_MULTI_EXTENT) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Root dir is cannot be multi-extent: %#x", pRootDir->fFileFlags); + + if (RT_LE2H_U32(pRootDir->cbData.le) != RT_BE2H_U32(pRootDir->cbData.be)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir size: {%#RX32,%#RX32}", + RT_BE2H_U32(pRootDir->cbData.be), RT_LE2H_U32(pRootDir->cbData.le)); + if (RT_LE2H_U32(pRootDir->cbData.le) == 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Zero sized root dir"); + + if (RT_LE2H_U32(pRootDir->offExtent.le) != RT_BE2H_U32(pRootDir->offExtent.be)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir extent: {%#RX32,%#RX32}", + RT_BE2H_U32(pRootDir->offExtent.be), RT_LE2H_U32(pRootDir->offExtent.le)); + + if (RT_LE2H_U16(pRootDir->VolumeSeqNo.le) != RT_BE2H_U16(pRootDir->VolumeSeqNo.be)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid root dir volume sequence ID: {%#RX16,%#RX16}", + RT_BE2H_U16(pRootDir->VolumeSeqNo.be), RT_LE2H_U16(pRootDir->VolumeSeqNo.le)); + if (RT_LE2H_U16(pRootDir->VolumeSeqNo.le) != pThis->idPrimaryVol) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Expected root dir to have same volume sequence number as primary volume: %#x, expected %#x", + RT_LE2H_U16(pRootDir->VolumeSeqNo.le), pThis->idPrimaryVol); + + /* + * Seems okay, copy it. + */ + *pDstRootDir = *pRootDir; + return VINF_SUCCESS; +} + + +/** + * Deal with a primary volume descriptor. + * + * @returns IPRT status code. + * @param pThis The ISO 9660 instance being initialized. + * @param pVolDesc The volume descriptor to handle. + * @param offVolDesc The disk offset of the volume descriptor. + * @param pRootDir Where to return a copy of the root directory record. + * @param poffRootDirRec Where to return the disk offset of the root dir. + * @param pErrInfo Where to return additional error info. Can be NULL. + */ +static int rtFsIsoVolHandlePrimaryVolDesc(PRTFSISOVOL pThis, PCISO9660PRIMARYVOLDESC pVolDesc, uint32_t offVolDesc, + PISO9660DIRREC pRootDir, uint64_t *poffRootDirRec, PRTERRINFO pErrInfo) +{ + if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion); + + /* + * We need the block size ... + */ + pThis->cbBlock = RT_LE2H_U16(pVolDesc->cbLogicalBlock.le); + if ( pThis->cbBlock != RT_BE2H_U16(pVolDesc->cbLogicalBlock.be) + || !RT_IS_POWER_OF_TWO(pThis->cbBlock) + || pThis->cbBlock / pThis->cbSector < 1) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid logical block size: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cbLogicalBlock.be), RT_LE2H_U16(pVolDesc->cbLogicalBlock.le)); + if (pThis->cbBlock / pThis->cbSector > 128) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Unsupported block size: %#x\n", pThis->cbBlock); + + /* + * ... volume space size ... + */ + pThis->cBlocksInPrimaryVolumeSpace = RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le); + if (pThis->cBlocksInPrimaryVolumeSpace != RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume space size: {%#RX32,%#RX32}", + RT_BE2H_U32(pVolDesc->VolumeSpaceSize.be), RT_LE2H_U32(pVolDesc->VolumeSpaceSize.le)); + pThis->cbPrimaryVolumeSpace = pThis->cBlocksInPrimaryVolumeSpace * (uint64_t)pThis->cbBlock; + + /* + * ... number of volumes in the set ... + */ + pThis->cVolumesInSet = RT_LE2H_U16(pVolDesc->cVolumesInSet.le); + if ( pThis->cVolumesInSet != RT_BE2H_U16(pVolDesc->cVolumesInSet.be) + || pThis->cVolumesInSet == 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume set size: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->cVolumesInSet.be), RT_LE2H_U16(pVolDesc->cVolumesInSet.le)); + if (pThis->cVolumesInSet > 32) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "Too large volume set size: %#x\n", pThis->cVolumesInSet); + + /* + * ... primary volume sequence ID ... + */ + pThis->idPrimaryVol = RT_LE2H_U16(pVolDesc->VolumeSeqNo.le); + if (pThis->idPrimaryVol != RT_BE2H_U16(pVolDesc->VolumeSeqNo.be)) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Invalid volume sequence ID: {%#RX16,%#RX16}", + RT_BE2H_U16(pVolDesc->VolumeSeqNo.be), RT_LE2H_U16(pVolDesc->VolumeSeqNo.le)); + if ( pThis->idPrimaryVol > pThis->cVolumesInSet + || pThis->idPrimaryVol < 1) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Volume sequence ID out of of bound: %#x (1..%#x)\n", pThis->idPrimaryVol, pThis->cVolumesInSet); + + /* + * ... and the root directory record. + */ + *poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660PRIMARYVOLDESC, RootDir.DirRec); + return rtFsIsoVolHandleRootDir(pThis, &pVolDesc->RootDir.DirRec, pRootDir, pErrInfo); +} + + +/** + * Deal with a supplementary volume descriptor. + * + * @returns IPRT status code. + * @param pThis The ISO 9660 instance being initialized. + * @param pVolDesc The volume descriptor to handle. + * @param offVolDesc The disk offset of the volume descriptor. + * @param pbUcs2Level Where to return the joliet level, if found. Caller + * initializes this to zero, we'll return 1, 2 or 3 if + * joliet was detected. + * @param pRootDir Where to return the root directory, if found. + * @param poffRootDirRec Where to return the disk offset of the root dir. + * @param pErrInfo Where to return additional error info. Can be NULL. + */ +static int rtFsIsoVolHandleSupplementaryVolDesc(PRTFSISOVOL pThis, PCISO9660SUPVOLDESC pVolDesc, uint32_t offVolDesc, + uint8_t *pbUcs2Level, PISO9660DIRREC pRootDir, uint64_t *poffRootDirRec, + PRTERRINFO pErrInfo) +{ + if (pVolDesc->bFileStructureVersion != ISO9660_FILE_STRUCTURE_VERSION) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unsupported file structure version: %#x", pVolDesc->bFileStructureVersion); + + /* + * Is this a joliet volume descriptor? If not, we probably don't need to + * care about it. + */ + if ( pVolDesc->abEscapeSequences[0] != ISO9660_JOLIET_ESC_SEQ_0 + || pVolDesc->abEscapeSequences[1] != ISO9660_JOLIET_ESC_SEQ_1 + || ( pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1 + && pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2 + && pVolDesc->abEscapeSequences[2] != ISO9660_JOLIET_ESC_SEQ_2_LEVEL_3)) + return VINF_SUCCESS; + + /* + * Skip if joliet is unwanted. + */ + if (pThis->fFlags & RTFSISO9660_F_NO_JOLIET) + return VINF_SUCCESS; + + /* + * Check that the joliet descriptor matches the primary one. + * Note! These are our assumptions and may be wrong. + */ + if (pThis->cbBlock == 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Supplementary joliet volume descriptor is not supported when appearing before the primary volume descriptor"); + if (ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock) != pThis->cbBlock) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Logical block size for joliet volume descriptor differs from primary: %#RX16 vs %#RX16\n", + ISO9660_GET_ENDIAN(&pVolDesc->cbLogicalBlock), pThis->cbBlock); + if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize) != pThis->cBlocksInPrimaryVolumeSpace) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Volume space size for joliet volume descriptor differs from primary: %#RX32 vs %#RX32\n", + ISO9660_GET_ENDIAN(&pVolDesc->VolumeSpaceSize), pThis->cBlocksInPrimaryVolumeSpace); + if (ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet) != pThis->cVolumesInSet) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Volume set size for joliet volume descriptor differs from primary: %#RX16 vs %#RX32\n", + ISO9660_GET_ENDIAN(&pVolDesc->cVolumesInSet), pThis->cVolumesInSet); + if (ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo) != pThis->idPrimaryVol) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Volume sequence ID for joliet volume descriptor differs from primary: %#RX16 vs %#RX32\n", + ISO9660_GET_ENDIAN(&pVolDesc->VolumeSeqNo), pThis->idPrimaryVol); + + if (*pbUcs2Level != 0) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "More than one supplementary joliet volume descriptor"); + + /* + * Switch to the joliet root dir as it has UTF-16 stuff in it. + */ + int rc = rtFsIsoVolHandleRootDir(pThis, &pVolDesc->RootDir.DirRec, pRootDir, pErrInfo); + if (RT_SUCCESS(rc)) + { + *poffRootDirRec = offVolDesc + RT_UOFFSETOF(ISO9660SUPVOLDESC, RootDir.DirRec); + *pbUcs2Level = pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_1 ? 1 + : pVolDesc->abEscapeSequences[2] == ISO9660_JOLIET_ESC_SEQ_2_LEVEL_2 ? 2 : 3; + Log(("ISO9660: Joliet with UCS-2 level %u\n", *pbUcs2Level)); + } + return rc; +} + + + +/** + * Worker for RTFsIso9660VolOpen. + * + * @returns IPRT status code. + * @param pThis The ISO VFS instance to initialize. + * @param hVfsSelf The ISO VFS handle (no reference consumed). + * @param hVfsBacking The file backing the alleged ISO file system. + * Reference is consumed (via rtFsIsoVol_Close). + * @param fFlags Flags, RTFSISO9660_F_XXX. + * @param pErrInfo Where to return additional error info. Can be NULL. + */ +static int rtFsIsoVolTryInit(PRTFSISOVOL pThis, RTVFS hVfsSelf, RTVFSFILE hVfsBacking, uint32_t fFlags, PRTERRINFO pErrInfo) +{ + uint32_t const cbSector = 2048; + + /* + * First initialize the state so that rtFsIsoVol_Destroy won't trip up. + */ + pThis->hVfsSelf = hVfsSelf; + pThis->hVfsBacking = hVfsBacking; /* Caller referenced it for us, we consume it; rtFsIsoVol_Destroy releases it. */ + pThis->cbBacking = 0; + pThis->cBackingSectors = 0; + pThis->fFlags = fFlags; + pThis->cbSector = cbSector; + pThis->cbBlock = 0; + pThis->cBlocksInPrimaryVolumeSpace = 0; + pThis->cbPrimaryVolumeSpace = 0; + pThis->cVolumesInSet = 0; + pThis->idPrimaryVol = UINT32_MAX; + pThis->fIsUtf16 = false; + pThis->pRootDir = NULL; + + /* + * Get stuff that may fail. + */ + int rc = RTVfsFileGetSize(hVfsBacking, &pThis->cbBacking); + if (RT_SUCCESS(rc)) + pThis->cBackingSectors = pThis->cbBacking / pThis->cbSector; + else + return rc; + + /* + * Read the volume descriptors starting at logical sector 16. + */ + union + { + uint8_t ab[RTFSISO_MAX_LOGICAL_BLOCK_SIZE]; + uint16_t au16[RTFSISO_MAX_LOGICAL_BLOCK_SIZE / 2]; + uint32_t au32[RTFSISO_MAX_LOGICAL_BLOCK_SIZE / 4]; + ISO9660VOLDESCHDR VolDescHdr; + ISO9660BOOTRECORD BootRecord; + ISO9660PRIMARYVOLDESC PrimaryVolDesc; + ISO9660SUPVOLDESC SupVolDesc; + ISO9660VOLPARTDESC VolPartDesc; + } Buf; + RT_ZERO(Buf); + + uint64_t offRootDirRec = UINT64_MAX; + ISO9660DIRREC RootDir; + RT_ZERO(RootDir); + + uint64_t offJolietRootDirRec = UINT64_MAX; + uint8_t bJolietUcs2Level = 0; + ISO9660DIRREC JolietRootDir; + RT_ZERO(JolietRootDir); + + uint8_t uUdfLevel = 0; + uint64_t offUdfBootVolDesc = UINT64_MAX; + + uint32_t cPrimaryVolDescs = 0; + uint32_t cSupplementaryVolDescs = 0; + uint32_t cBootRecordVolDescs = 0; + uint32_t offVolDesc = 16 * cbSector; + enum + { + kStateStart = 0, + kStateNoSeq, + kStateCdSeq, + kStateUdfSeq + } enmState = kStateStart; + for (uint32_t iVolDesc = 0; ; iVolDesc++, offVolDesc += cbSector) + { + if (iVolDesc > 32) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "More than 32 volume descriptors, doesn't seem right..."); + + /* Read the next one and check the signature. */ + rc = RTVfsFileReadAt(hVfsBacking, offVolDesc, &Buf, cbSector, NULL); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_SET_F(pErrInfo, rc, "Unable to read volume descriptor #%u", iVolDesc); + +#define MATCH_STD_ID(a_achStdId1, a_szStdId2) \ + ( (a_achStdId1)[0] == (a_szStdId2)[0] \ + && (a_achStdId1)[1] == (a_szStdId2)[1] \ + && (a_achStdId1)[2] == (a_szStdId2)[2] \ + && (a_achStdId1)[3] == (a_szStdId2)[3] \ + && (a_achStdId1)[4] == (a_szStdId2)[4] ) +#define MATCH_HDR(a_pStd, a_bType2, a_szStdId2, a_bVer2) \ + ( MATCH_STD_ID((a_pStd)->achStdId, a_szStdId2) \ + && (a_pStd)->bDescType == (a_bType2) \ + && (a_pStd)->bDescVersion == (a_bVer2) ) + + /* + * ISO 9660 ("CD001"). + */ + if ( ( enmState == kStateStart + || enmState == kStateCdSeq + || enmState == kStateNoSeq) + && MATCH_STD_ID(Buf.VolDescHdr.achStdId, ISO9660VOLDESC_STD_ID) ) + { + enmState = kStateCdSeq; + + /* Do type specific handling. */ + Log(("ISO9660: volume desc #%u: type=%#x\n", iVolDesc, Buf.VolDescHdr.bDescType)); + if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_PRIMARY) + { + cPrimaryVolDescs++; + if (Buf.VolDescHdr.bDescVersion != ISO9660PRIMARYVOLDESC_VERSION) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unsupported primary volume descriptor version: %#x", Buf.VolDescHdr.bDescVersion); +#ifdef LOG_ENABLED + rtFsIsoVolLogPrimarySupplementaryVolDesc(&Buf.SupVolDesc); +#endif + if (cPrimaryVolDescs > 1) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "More than one primary volume descriptor"); + rc = rtFsIsoVolHandlePrimaryVolDesc(pThis, &Buf.PrimaryVolDesc, offVolDesc, &RootDir, &offRootDirRec, pErrInfo); + } + else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_SUPPLEMENTARY) + { + cSupplementaryVolDescs++; + if (Buf.VolDescHdr.bDescVersion != ISO9660SUPVOLDESC_VERSION) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unsupported supplemental volume descriptor version: %#x", Buf.VolDescHdr.bDescVersion); +#ifdef LOG_ENABLED + rtFsIsoVolLogPrimarySupplementaryVolDesc(&Buf.SupVolDesc); +#endif + rc = rtFsIsoVolHandleSupplementaryVolDesc(pThis, &Buf.SupVolDesc, offVolDesc, &bJolietUcs2Level, &JolietRootDir, + &offJolietRootDirRec, pErrInfo); + } + else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_BOOT_RECORD) + { + cBootRecordVolDescs++; + } + else if (Buf.VolDescHdr.bDescType == ISO9660VOLDESC_TYPE_TERMINATOR) + { + if (!cPrimaryVolDescs) + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "No primary volume descriptor"); + enmState = kStateNoSeq; + } + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unknown volume descriptor: %#x", Buf.VolDescHdr.bDescType); + } + /* + * UDF volume recognition sequence (VRS). + */ + else if ( ( enmState == kStateNoSeq + || enmState == kStateStart) + && MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_BEGIN, UDF_EXT_VOL_DESC_VERSION) ) + { + if (uUdfLevel == 0) + enmState = kStateUdfSeq; + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Only one BEA01 sequence is supported"); + } + else if ( enmState == kStateUdfSeq + && MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_NSR_02, UDF_EXT_VOL_DESC_VERSION) ) + uUdfLevel = 2; + else if ( enmState == kStateUdfSeq + && MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_NSR_03, UDF_EXT_VOL_DESC_VERSION) ) + uUdfLevel = 3; + else if ( enmState == kStateUdfSeq + && MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_BOOT, UDF_EXT_VOL_DESC_VERSION) ) + { + if (offUdfBootVolDesc == UINT64_MAX) + offUdfBootVolDesc = iVolDesc * cbSector; + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Only one BOOT2 descriptor is supported"); + } + else if ( enmState == kStateUdfSeq + && MATCH_HDR(&Buf.VolDescHdr, UDF_EXT_VOL_DESC_TYPE, UDF_EXT_VOL_DESC_STD_ID_TERM, UDF_EXT_VOL_DESC_VERSION) ) + { + if (uUdfLevel != 0) + enmState = kStateNoSeq; + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "Found BEA01 & TEA01, but no NSR02 or NSR03 descriptors"); + } + /* + * Unknown, probably the end. + */ + else if (enmState == kStateNoSeq) + break; + else if (enmState == kStateStart) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "Not ISO? Unable to recognize volume descriptor signature: %.5Rhxs", Buf.VolDescHdr.achStdId); + else if (enmState == kStateCdSeq) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Missing ISO 9660 terminator volume descriptor? (Found %.5Rhxs)", Buf.VolDescHdr.achStdId); + else if (enmState == kStateUdfSeq) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Missing UDF terminator volume descriptor? (Found %.5Rhxs)", Buf.VolDescHdr.achStdId); + else + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "Unknown volume descriptor signature found at sector %u: %.5Rhxs", + 16 + iVolDesc, Buf.VolDescHdr.achStdId); + if (RT_FAILURE(rc)) + return rc; + } + + /* + * If we found a UDF VRS and are interested in UDF, we have more work to do here. + */ + if (uUdfLevel > 0 && !(fFlags & RTFSISO9660_F_NO_UDF) ) + { + Log(("rtFsIsoVolTryInit: uUdfLevel=%d\n", uUdfLevel)); + rc = rtFsIsoVolHandleUdfDetection(pThis, &uUdfLevel, offUdfBootVolDesc, Buf.ab, sizeof(Buf), pErrInfo); + if (RT_FAILURE(rc)) + return rc; + } + + /* + * Decide which to prefer. + * + * By default we pick UDF over any of the two ISO 9960, there is currently + * no way to override this without using the RTFSISO9660_F_NO_XXX options. + * + * If there isn't UDF, we may faced with choosing between joliet and rock + * ridge. The joliet option is generally favorable as we don't have to + * guess wrt to the file name encoding. So, we'll pick that for now. + * + * Note! Should we change this preference for joliet, there fun wrt making sure + * there really is rock ridge stuff in the primary volume as well as + * making sure there really is anything of value in the primary volume. + */ + if (uUdfLevel > 0) + { + pThis->enmType = RTFSISOVOLTYPE_UDF; + rc = rtFsIsoDirShrd_NewUdf(pThis, NULL /*pParent*/, &pThis->Udf.VolInfo.RootDirIcb, + NULL /*pFileIdDesc*/, 0 /*offInDir*/, &pThis->pRootDir); + /** @todo fall back on failure? */ + return rc; + } + if (bJolietUcs2Level != 0) + { + pThis->enmType = RTFSISOVOLTYPE_JOLIET; + pThis->fIsUtf16 = true; + return rtFsIsoDirShrd_New9660(pThis, NULL, &JolietRootDir, 1, offJolietRootDirRec, &pThis->pRootDir); + } + pThis->enmType = RTFSISOVOLTYPE_ISO9960; + return rtFsIsoDirShrd_New9660(pThis, NULL, &RootDir, 1, offRootDirRec, &pThis->pRootDir); +} + + +/** + * Opens an ISO 9660 file system volume. + * + * @returns IPRT status code. + * @param hVfsFileIn The file or device backing the volume. + * @param fFlags RTFSISO9660_F_XXX. + * @param phVfs Where to return the virtual file system handle. + * @param pErrInfo Where to return additional error information. + */ +RTDECL(int) RTFsIso9660VolOpen(RTVFSFILE hVfsFileIn, uint32_t fFlags, PRTVFS phVfs, PRTERRINFO pErrInfo) +{ + /* + * Quick input validation. + */ + AssertPtrReturn(phVfs, VERR_INVALID_POINTER); + *phVfs = NIL_RTVFS; + AssertReturn(!(fFlags & ~RTFSISO9660_F_VALID_MASK), VERR_INVALID_FLAGS); + + uint32_t cRefs = RTVfsFileRetain(hVfsFileIn); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a new ISO VFS instance and try initialize it using the given input file. + */ + RTVFS hVfs = NIL_RTVFS; + void *pvThis = NULL; + int rc = RTVfsNew(&g_rtFsIsoVolOps, sizeof(RTFSISOVOL), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, &pvThis); + if (RT_SUCCESS(rc)) + { + rc = rtFsIsoVolTryInit((PRTFSISOVOL)pvThis, hVfs, hVfsFileIn, fFlags, pErrInfo); + if (RT_SUCCESS(rc)) + *phVfs = hVfs; + else + RTVfsRelease(hVfs); + } + else + RTVfsFileRelease(hVfsFileIn); + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate} + */ +static DECLCALLBACK(int) rtVfsChainIsoFsVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec, + PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec); + + /* + * Basic checks. + */ + if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE) + return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE; + if ( pElement->enmType != RTVFSOBJTYPE_VFS + && pElement->enmType != RTVFSOBJTYPE_DIR) + return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS; + if (pElement->cArgs > 1) + return VERR_VFS_CHAIN_AT_MOST_ONE_ARG; + + /* + * Parse the flag if present, save in pElement->uProvider. + */ + uint32_t fFlags = 0; + if (pElement->cArgs > 0) + { + for (uint32_t iArg = 0; iArg < pElement->cArgs; iArg++) + { + const char *psz = pElement->paArgs[iArg].psz; + if (*psz) + { + if (!strcmp(psz, "nojoliet")) + fFlags |= RTFSISO9660_F_NO_JOLIET; + else if (!strcmp(psz, "norock")) + fFlags |= RTFSISO9660_F_NO_ROCK; + else if (!strcmp(psz, "noudf")) + fFlags |= RTFSISO9660_F_NO_UDF; + else + { + *poffError = pElement->paArgs[iArg].offSpec; + return RTERRINFO_LOG_SET(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Only knows: 'nojoliet' and 'norock'"); + } + } + } + } + + pElement->uProvider = fFlags; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate} + */ +static DECLCALLBACK(int) rtVfsChainIsoFsVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec, + PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj, + PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec, poffError); + + int rc; + RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj); + if (hVfsFileIn != NIL_RTVFSFILE) + { + RTVFS hVfs; + rc = RTFsIso9660VolOpen(hVfsFileIn, pElement->uProvider, &hVfs, pErrInfo); + RTVfsFileRelease(hVfsFileIn); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromVfs(hVfs); + RTVfsRelease(hVfs); + if (*phVfsObj != NIL_RTVFSOBJ) + return VINF_SUCCESS; + rc = VERR_VFS_CHAIN_CAST_FAILED; + } + } + else + rc = VERR_VFS_CHAIN_CAST_FAILED; + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement} + */ +static DECLCALLBACK(bool) rtVfsChainIsoFsVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg, + PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement, + PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement) +{ + RT_NOREF(pProviderReg, pSpec, pReuseSpec); + if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider + || !pReuseElement->paArgs[0].uProvider) + return true; + return false; +} + + +/** VFS chain element 'file'. */ +static RTVFSCHAINELEMENTREG g_rtVfsChainIsoFsVolReg = +{ + /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION, + /* fReserved = */ 0, + /* pszName = */ "isofs", + /* ListEntry = */ { NULL, NULL }, + /* pszHelp = */ "Open a ISO 9660 or UDF file system, requires a file object on the left side.\n" + "The 'noudf' option make it ignore any UDF.\n" + "The 'nojoliet' option make it ignore any joliet supplemental volume.\n" + "The 'norock' option make it ignore any rock ridge info.\n", + /* pfnValidate = */ rtVfsChainIsoFsVol_Validate, + /* pfnInstantiate = */ rtVfsChainIsoFsVol_Instantiate, + /* pfnCanReuseElement = */ rtVfsChainIsoFsVol_CanReuseElement, + /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION +}; + +RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainIsoFsVolReg, rtVfsChainIsoFsVolReg); + diff --git a/src/VBox/Runtime/common/fs/ntfsvfs.cpp b/src/VBox/Runtime/common/fs/ntfsvfs.cpp new file mode 100644 index 00000000..8af82602 --- /dev/null +++ b/src/VBox/Runtime/common/fs/ntfsvfs.cpp @@ -0,0 +1,5683 @@ +/* $Id: ntfsvfs.cpp $ */ +/** @file + * IPRT - NTFS Virtual Filesystem, currently only for reading allocation bitmap. + */ + +/* + * Copyright (C) 2012-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include <iprt/fsvfs.h> + +#include <iprt/asm.h> +#include <iprt/avl.h> +#include <iprt/assert.h> +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/file.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/utf16.h> +#include <iprt/formats/ntfs.h> + +#include <internal/fs.h> /* For RTFSMODE_SYMLINK_REPARSE_TAG. */ + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The maximum bitmap size to try cache in its entirity (in bytes). */ +#define RTFSNTFS_MAX_WHOLE_BITMAP_CACHE _64K +/** The maximum node cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSNTFS_MAX_CORE_CACHE_SIZE _512K +#else +# define RTFSNTFS_MAX_CORE_CACHE_SIZE _128K +#endif +/** The maximum node cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSNTFS_MAX_NODE_CACHE_SIZE _1M +#else +# define RTFSNTFS_MAX_NODE_CACHE_SIZE _256K +#endif + +/** Makes a combined NTFS version value. + * @see RTFSNTFSVOL::uNtfsVersion */ +#define RTFSNTFS_MAKE_VERSION(a_uMajor, a_uMinor) RT_MAKE_U16(a_uMinor, a_uMajor) + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to the instance data for a NTFS volume. */ +typedef struct RTFSNTFSVOL *PRTFSNTFSVOL; +/** Pointer to a NTFS MFT record. */ +typedef struct RTFSNTFSMFTREC *PRTFSNTFSMFTREC; +/** Poitner to a NTFS core object record. */ +typedef struct RTFSNTFSCORE *PRTFSNTFSCORE; +/** Pointer to an index node. */ +typedef struct RTFSNTFSIDXNODE *PRTFSNTFSIDXNODE; +/** Pointer to a shared NTFS directory object. */ +typedef struct RTFSNTFSDIRSHRD *PRTFSNTFSDIRSHRD; +/** Pointer to a shared NTFS file object. */ +typedef struct RTFSNTFSFILESHRD *PRTFSNTFSFILESHRD; + + +/** + * NTFS disk allocation extent (internal representation). + */ +typedef struct RTFSNTFSEXTENT +{ + /** The disk or partition byte offset. + * This is set to UINT64_MAX for parts of sparse files that aren't recorded. */ + uint64_t off; + /** The size of the extent in bytes. */ + uint64_t cbExtent; +} RTFSNTFSEXTENT; +/** Pointer to an NTFS 9660 extent. */ +typedef RTFSNTFSEXTENT *PRTFSNTFSEXTENT; +/** Pointer to a const NTFS 9660 extent. */ +typedef RTFSNTFSEXTENT const *PCRTFSNTFSEXTENT; + +/** + * An array of zero or more extents. + */ +typedef struct RTFSNTFSEXTENTS +{ + /** Number of bytes covered by the extents. */ + uint64_t cbData; + /** Number of allocation extents. */ + uint32_t cExtents; + /** Array of allocation extents. */ + PRTFSNTFSEXTENT paExtents; +} RTFSNTFSEXTENTS; +/** Pointer to an extent array. */ +typedef RTFSNTFSEXTENTS *PRTFSNTFSEXTENTS; +/** Pointer to a const extent array. */ +typedef RTFSNTFSEXTENTS const *PCRTFSNTFSEXTENTS; + + +/** + * NTFS MFT record. + * + * These are kept in a tree to , so + */ +typedef struct RTFSNTFSMFTREC +{ + /** MFT record number (index) as key. */ + AVLU64NODECORE TreeNode; + /** Pointer to the next MFT record if chained. Holds a reference. */ + PRTFSNTFSMFTREC pNext; + union + { + /** Generic record pointer. RTFSNTFSVOL::cbMftRecord in size. */ + uint8_t *pbRec; + /** Pointer to the file record. */ + PNTFSRECFILE pFileRec; + } RT_UNION_NM(u); + /** Pointer to the core object with the parsed data. + * This is a weak reference. Non-base MFT record all point to the base one. */ + PRTFSNTFSCORE pCore; + /** Reference counter. */ + uint32_t volatile cRefs; + /** Set if this is a base MFT record. */ + bool fIsBase; +} RTFSNTFSMFTREC; + + +/** Pointer to a attribute subrecord structure. */ +typedef struct RTFSNTFSATTRSUBREC *PRTFSNTFSATTRSUBREC; + +/** + * An attribute subrecord. + * + * This is for covering non-resident attributes that have had their allocation + * list split. + */ +typedef struct RTFSNTFSATTRSUBREC +{ + /** Pointer to the next one. */ + PRTFSNTFSATTRSUBREC pNext; + /** Pointer to the attribute header. + * The MFT is held down by RTFSNTFSCORE via pMftEntry. */ + PNTFSATTRIBHDR pAttrHdr; + /** Disk space allocation if non-resident. */ + RTFSNTFSEXTENTS Extents; +} RTFSNTFSATTRSUBREC; + +/** + * An attribute. + */ +typedef struct RTFSNTFSATTR +{ + /** List entry (head RTFSNTFSCORE::AttribHead). */ + RTLISTNODE ListEntry; + /** Pointer to the core object this attribute belongs to. */ + PRTFSNTFSCORE pCore; + /** Pointer to the attribute header. + * The MFT is held down by RTFSNTFSCORE via pMftEntry. */ + PNTFSATTRIBHDR pAttrHdr; + /** The offset of the attribute header in the MFT record. + * This is needed to validate header relative offsets. */ + uint32_t offAttrHdrInMftRec; + /** Number of resident bytes available (can be smaller than cbValue). + * Set to zero for non-resident attributes. */ + uint32_t cbResident; + /** The (uncompressed) attribute size. */ + uint64_t cbValue; + /** Disk space allocation if non-resident. */ + RTFSNTFSEXTENTS Extents; + /** Pointer to any subrecords containing further allocation extents. */ + PRTFSNTFSATTRSUBREC pSubRecHead; + /** Pointer to the VFS object for this attribute. + * This is a weak reference since it's the VFS object that is referencing us. */ + union + { + /** Pointer to a shared directory (NTFS_AT_DIRECTORY). */ + PRTFSNTFSDIRSHRD pSharedDir; + /** Pointer to a shared file (NTFS_AT_DATA). */ + PRTFSNTFSFILESHRD pSharedFile; + } uObj; +} RTFSNTFSATTR; +/** Pointer to a attribute structure. */ +typedef RTFSNTFSATTR *PRTFSNTFSATTR; + + +/** + * NTFS file system object, shared part. + */ +typedef struct RTFSNTFSCORE +{ + /** Entry in either the RTFSNTFSVOL::CoreInUseHead or CoreUnusedHead. + * Instances is moved to/from CoreUnusedHead as cRefs reaches zero and one + * respectively. */ + RTLISTNODE ListEntry; + /** Reference counter. */ + uint32_t volatile cRefs; + /** The estimated memory cost of this object. */ + uint32_t cbCost; + /** Pointer to the volume. */ + PRTFSNTFSVOL pVol; + /** Pointer to the head of the MFT record chain for this object. + * Holds a reference. */ + PRTFSNTFSMFTREC pMftRec; + /** List of attributes (RTFSNTFSATTR). */ + RTLISTANCHOR AttribHead; +} RTFSNTFSCORE; + + +/** + * Node lookup information for facilitating binary searching of node. + */ +typedef struct RTFSNTFSIDXNODEINFO +{ + /** The index header. */ + PCNTFSINDEXHDR pIndexHdr; + /** Number of entries. */ + uint32_t cEntries; + /** Set if internal node. */ + bool fInternal; + /** Array with pointers to the entries. */ + PCNTFSIDXENTRYHDR *papEntries; + /** Pointer to the index node this info is for, NULL if root node. + * This is for reducing the enumeration stack entry size. */ + PRTFSNTFSIDXNODE pNode; + /** Pointer to the NTFS volume instace. */ + PRTFSNTFSVOL pVol; +} RTFSNTFSIDXNODEINFO; +/** Pointer to index node lookup info. */ +typedef RTFSNTFSIDXNODEINFO *PRTFSNTFSIDXNODEINFO; +/** Pointer to const index node lookup info. */ +typedef RTFSNTFSIDXNODEINFO const *PCRTFSNTFSIDXNODEINFO; + +/** + * Index node, cached. + * + * These are cached to avoid reading, validating and parsing things each time a + * subnode is accessed. + */ +typedef struct RTFSNTFSIDXNODE +{ + /** Entry in RTFSNTFSVOL::IdxNodeCahceRoot, key is disk byte offset. */ + AVLU64NODECORE TreeNode; + /** List entry on the unused list. Gets removed from it when cRefs is + * increase to one, and added when it reaches zero. */ + RTLISTNODE UnusedListEntry; + /** Reference counter. */ + uint32_t volatile cRefs; + /** The estimated memory cost of this node. */ + uint32_t cbCost; + /** Pointer to the node data. */ + PNTFSATINDEXALLOC pNode; + /** Node info. */ + RTFSNTFSIDXNODEINFO NodeInfo; +} RTFSNTFSIDXNODE; + +/** + * Common index root structure. + */ +typedef struct RTFSNTFSIDXROOTINFO +{ + /** Pointer to the index root attribute value. */ + PCNTFSATINDEXROOT pRoot; + /** Pointer to the index allocation attribute, if present. + * This and the bitmap may be absent if the whole directory fits into the + * root index. */ + PRTFSNTFSATTR pAlloc; + /** End of the node addresses range (exclusive). */ + uint64_t uEndNodeAddresses; + /** Node address misalignement mask. */ + uint32_t fNodeAddressMisalign; + /** The byte shift count for node addresses. */ + uint8_t cNodeAddressByteShift; + /** Node info for the root. */ + RTFSNTFSIDXNODEINFO NodeInfo; + /** Pointer to the index root attribute. We reference the core thru this and + * use it to zero RTFSNTFSATTR::uObj::pSharedDir on destruction. */ + PRTFSNTFSATTR pRootAttr; +} RTFSNTFSIDXROOTINFO; +/** Pointer to an index root structure. */ +typedef RTFSNTFSIDXROOTINFO *PRTFSNTFSIDXROOTINFO; +/** Pointer to a const index root structure. */ +typedef RTFSNTFSIDXROOTINFO const *PCRTFSNTFSIDXROOTINFO; + +/** + * Shared NTFS directory object. + */ +typedef struct RTFSNTFSDIRSHRD +{ + /** Reference counter. */ + uint32_t volatile cRefs; + /** Index root information. */ + RTFSNTFSIDXROOTINFO RootInfo; +} RTFSNTFSDIRSHRD; + +/** + * Index stack entry for index enumeration. + */ +typedef struct RTFSNTFSIDXSTACKENTRY +{ + /** The next entry to process in this stack entry. */ + uint32_t iNext; + /** Set if we need to descend first. */ + bool fDescend; + /** Pointer to the node info for this entry. */ + PRTFSNTFSIDXNODEINFO pNodeInfo; +} RTFSNTFSIDXSTACKENTRY; +/** Pointer to an index enumeration stack entry. */ +typedef RTFSNTFSIDXSTACKENTRY *PRTFSNTFSIDXSTACKENTRY; + + +/** + * Open directory instance. + */ +typedef struct RTFSNTFSDIR +{ + /** Pointer to the shared directory instance (referenced). */ + PRTFSNTFSDIRSHRD pShared; + /** Set if we've reached the end of the directory enumeration. */ + bool fNoMoreFiles; + /** The enumeration stack size. */ + uint32_t cEnumStackEntries; + /** The allocated enumeration stack depth. */ + uint32_t cEnumStackMaxDepth; + /** The numeration stack. Allocated as needed. */ + PRTFSNTFSIDXSTACKENTRY paEnumStack; +} RTFSNTFSDIR; +/** Pointer to an open directory instance. */ +typedef RTFSNTFSDIR *PRTFSNTFSDIR; + + +/** + * Shared NTFS file object. + */ +typedef struct RTFSNTFSFILESHRD +{ + /** Reference counter. */ + uint32_t volatile cRefs; + /** Pointer to the data attribute (core is referenced thru this). */ + PRTFSNTFSATTR pData; +} RTFSNTFSFILESHRD; +/** Pointer to shared data for a file or data stream. */ +typedef RTFSNTFSFILESHRD *PRTFSNTFSFILESHRD; + + +/** + * Open NTFS file instance. + */ +typedef struct RTFSNTFSFILE +{ + /** Pointer to the shared file data (referenced). */ + PRTFSNTFSFILESHRD pShared; + /** Current file offset. */ + uint64_t offFile; +} RTFSNTFSFILE; +/** Pointer to an NTFS open file instance. */ +typedef RTFSNTFSFILE *PRTFSNTFSFILE; + +/** + * Instance data for an NTFS volume. + */ +typedef struct RTFSNTFSVOL +{ + /** Handle to itself. */ + RTVFS hVfsSelf; + /** The file, partition, or whatever backing the NTFS volume. */ + RTVFSFILE hVfsBacking; + /** The size of the backing thingy. */ + uint64_t cbBacking; + /** The formatted size of the volume. */ + uint64_t cbVolume; + /** cbVolume expressed as a cluster count. */ + uint64_t cClusters; + + /** RTVFSMNT_F_XXX. */ + uint32_t fMntFlags; + /** RTFSNTVFS_F_XXX (currently none defined). */ + uint32_t fNtfsFlags; + + /** The (logical) sector size. */ + uint32_t cbSector; + + /** The (logical) cluster size. */ + uint32_t cbCluster; + /** Max cluster count value that won't overflow a signed 64-bit when + * converted to bytes. Inclusive. */ + uint64_t iMaxVirtualCluster; + /** The shift count for converting between bytes and clusters. */ + uint8_t cClusterShift; + + /** Explicit padding. */ + uint8_t abReserved[3]; + /** The NTFS version of the volume (RTFSNTFS_MAKE_VERSION). */ + uint16_t uNtfsVersion; + /** The NTFS_VOLUME_F_XXX. */ + uint16_t fVolumeFlags; + + /** The logical cluster number of the MFT. */ + uint64_t uLcnMft; + /** The logical cluster number of the mirror MFT. */ + uint64_t uLcnMftMirror; + + /** The MFT record size. */ + uint32_t cbMftRecord; + /** The default index (B-tree) node size. */ + uint32_t cbDefaultIndexNode; + + /** The volume serial number. */ + uint64_t uSerialNo; + + /** @name MFT record and core object cache. + * @{ */ + /** The '$Mft' data attribute. */ + PRTFSNTFSATTR pMftData; + /** Root of the MFT record tree (RTFSNTFSMFTREC). */ + AVLU64TREE MftRoot; + /** List of in use core objects (RTFSNTFSCORE::cRefs > 0). (RTFSNTFSCORE) */ + RTLISTANCHOR CoreInUseHead; + /** List of unused core objects (RTFSNTFSCORE::cRefs == 0). (RTFSNTFSCORE) + * The most recently used nodes are found at the of the list. So, when + * cbCoreObjects gets to high, we remove and destroy objects from the tail. */ + RTLISTANCHOR CoreUnusedHead; + /** Total core object memory cost (sum of all RTFSNTFSCORE::cbCost). */ + size_t cbCoreObjects; + /** @} */ + + /** @name Allocation bitmap and cache. + * @{ */ + /** The '$Bitmap' data attribute. */ + PRTFSNTFSATTR pMftBitmap; + /** The first cluster currently loaded into the bitmap cache . */ + uint64_t iFirstBitmapCluster; + /** The number of clusters currently loaded into the bitmap cache */ + uint32_t cBitmapClusters; + /** The size of the pvBitmap allocation. */ + uint32_t cbBitmapAlloc; + /** Allocation bitmap cache buffer. */ + void *pvBitmap; + /** @} */ + + /** @name Directory/index related. + * @{ */ + /** Tree of index nodes, index by disk byte offset. (RTFSNTFSIDXNODE) */ + AVLU64TREE IdxNodeCacheRoot; + /** List of currently unreferenced index nodes. (RTFSNTFSIDXNODE) + * Most recently used nodes are found at the end of the list. Nodes are added + * when their reference counter reaches zero. They are removed when it + * increases to one again. + * + * The nodes are still in the index node cache tree (IdxNodeCacheRoot), but + * we'll trim this from the end when we reach a certain size. */ + RTLISTANCHOR IdxNodeUnusedHead; + /** Number of unreferenced index nodes. */ + uint32_t cUnusedIdxNodes; + /** Number of cached index nodes. */ + uint32_t cIdxNodes; + /** Total index node memory cost. */ + size_t cbIdxNodes; + /** The root directory. */ + PRTFSNTFSDIRSHRD pRootDir; + /** Lower to uppercase conversion table for this filesystem. + * This always has 64K valid entries. */ + PRTUTF16 pawcUpcase; + /** @} */ + +} RTFSNTFSVOL; + + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static uint32_t rtFsNtfsCore_Destroy(PRTFSNTFSCORE pThis); +static void rtFsNtfsIdxVol_TrimCoreObjectCache(PRTFSNTFSVOL pThis); +static uint32_t rtFsNtfsCore_Release(PRTFSNTFSCORE pThis); +static uint32_t rtFsNtfsCore_Retain(PRTFSNTFSCORE pThis); +#ifdef LOG_ENABLED +static void rtFsNtfsVol_LogIndexRoot(PCNTFSATINDEXROOT pIdxRoot, uint32_t cbIdxRoot); +#endif +static int rtFsNtfsVol_NewDirFromShared(PRTFSNTFSVOL pThis, PRTFSNTFSDIRSHRD pSharedDir, PRTVFSDIR phVfsDir); +static uint32_t rtFsNtfsDirShrd_Retain(PRTFSNTFSDIRSHRD pThis); +static void rtFsNtfsIdxVol_TrimIndexNodeCache(PRTFSNTFSVOL pThis); +static uint32_t rtFsNtfsIdxNode_Release(PRTFSNTFSIDXNODE pNode); +static uint32_t rtFsNtfsIdxNode_Retain(PRTFSNTFSIDXNODE pNode); + + + +/** + * Checks if a bit is set in an NTFS bitmap (little endian). + * + * @returns true if set, false if not. + * @param pvBitmap The bitmap buffer. + * @param iBit The bit. + */ +DECLINLINE(bool) rtFsNtfsBitmap_IsSet(void *pvBitmap, uint32_t iBit) +{ +#if 0 //def RT_LITTLE_ENDIAN + return ASMBitTest(pvBitmap, iBit); +#else + uint8_t b = ((uint8_t const *)pvBitmap)[iBit >> 3]; + return RT_BOOL(b & (1 << (iBit & 7))); +#endif +} + + + +static PRTFSNTFSMFTREC rtFsNtfsVol_NewMftRec(PRTFSNTFSVOL pVol, uint64_t idMft) +{ + PRTFSNTFSMFTREC pRec = (PRTFSNTFSMFTREC)RTMemAllocZ(sizeof(*pRec)); + if (pRec) + { + pRec->pbRec = (uint8_t *)RTMemAllocZ(pVol->cbMftRecord); + if (pRec->pbRec) + { + pRec->TreeNode.Key = idMft; + pRec->pNext = NULL; + pRec->cRefs = 1; + if (RTAvlU64Insert(&pVol->MftRoot, &pRec->TreeNode)) + return pRec; + RTMemFree(pRec); + } + } + return NULL; +} + + +static uint32_t rtFsNtfsMftRec_Destroy(PRTFSNTFSMFTREC pThis, PRTFSNTFSVOL pVol) +{ + RTMemFree(pThis->pbRec); + pThis->pbRec = NULL; + + PAVLU64NODECORE pRemoved = RTAvlU64Remove(&pVol->MftRoot, pThis->TreeNode.Key); + Assert(pRemoved == &pThis->TreeNode); NOREF(pRemoved); + + RTMemFree(pThis); + + return 0; +} + + +static uint32_t rtFsNtfsMftRec_Retain(PRTFSNTFSMFTREC pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs < 64); + return cRefs; +} + +static uint32_t rtFsNtfsMftRec_Release(PRTFSNTFSMFTREC pThis, PRTFSNTFSVOL pVol) +{ + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < 64); + if (cRefs != 0) + return cRefs; + return rtFsNtfsMftRec_Destroy(pThis, pVol); +} + + +#ifdef LOG_ENABLED +/** + * Logs the MFT record + * + * @param pRec The MFT record to log. + * @param cbMftRecord MFT record size (from RTFSNTFSVOL). + */ +static void rtfsNtfsMftRec_Log(PRTFSNTFSMFTREC pRec, uint32_t cbMftRecord) +{ + if (LogIs2Enabled()) + { + PCNTFSRECFILE pFileRec = pRec->pFileRec; + Log2(("NTFS: MFT #%#RX64\n", pRec->TreeNode.Key)); + if (pFileRec->Hdr.uMagic == NTFSREC_MAGIC_FILE) + { + size_t const cbRec = cbMftRecord; + uint8_t const * const pbRec = pRec->pbRec; + + Log2(("NTFS: FILE record: \n")); + Log2(("NTFS: UpdateSeqArray %#x L %#x\n", RT_LE2H_U16(pFileRec->Hdr.offUpdateSeqArray), RT_LE2H_U16(pFileRec->Hdr.cUpdateSeqEntries) )); + Log2(("NTFS: uLsn %#RX64\n", RT_LE2H_U64(pFileRec->uLsn))); + Log2(("NTFS: uRecReuseSeqNo %#RX16\n", RT_LE2H_U16(pFileRec->uRecReuseSeqNo))); + Log2(("NTFS: cLinks %#RX16\n", RT_LE2H_U16(pFileRec->cLinks))); + Log2(("NTFS: offFirstAttrib %#RX16\n", RT_LE2H_U16(pFileRec->offFirstAttrib))); + Log2(("NTFS: fFlags %#RX16%s%s\n", RT_LE2H_U16(pFileRec->fFlags), + RT_LE2H_U16(pFileRec->fFlags) & NTFSRECFILE_F_IN_USE ? " in-use" : "", + RT_LE2H_U16(pFileRec->fFlags) & NTFSRECFILE_F_DIRECTORY ? " directory" : "")); + Log2(("NTFS: cbRecUsed %#RX32\n", RT_LE2H_U32(pFileRec->cbRecUsed))); + Log2(("NTFS: BaseMftRec %#RX64, sqn %#x\n", + NTFSMFTREF_GET_IDX(&pFileRec->BaseMftRec), NTFSMFTREF_GET_SEQ(&pFileRec->BaseMftRec))); + Log2(("NTFS: idNextAttrib %#RX16\n", RT_LE2H_U16(pFileRec->idNextAttrib))); + if ( RT_LE2H_U16(pFileRec->offFirstAttrib) >= sizeof(*pFileRec) + && ( RT_LE2H_U16(pFileRec->Hdr.offUpdateSeqArray) >= sizeof(*pFileRec) + || pFileRec->Hdr.offUpdateSeqArray == 0)) + { + Log2(("NTFS: uPaddingOrUsa %#RX16\n", pFileRec->uPaddingOrUsa)); + Log2(("NTFS: idxMftSelf %#RX32\n", RT_LE2H_U32(pFileRec->idxMftSelf))); + } + + uint32_t offRec = pFileRec->offFirstAttrib; + size_t cbRecUsed = RT_MIN(cbRec, pFileRec->cbRecUsed); + while (offRec + NTFSATTRIBHDR_SIZE_RESIDENT <= cbRecUsed) + { + PCNTFSATTRIBHDR pHdr = (PCNTFSATTRIBHDR)&pbRec[offRec]; + uint32_t const cbAttrib = RT_LE2H_U32(pHdr->cbAttrib); + Log2(("NTFS: @%#05x: Attrib record: %#x LB %#x, instance #%#x, fFlags=%#RX16, %s\n", offRec, + RT_LE2H_U32(pHdr->uAttrType), cbAttrib, RT_LE2H_U16(pHdr->idAttrib), RT_LE2H_U16(pHdr->fFlags), + pHdr->fNonResident == 0 ? "resident" : pHdr->fNonResident == 1 ? "non-resident" : "bad-resident-flag")); + if (pHdr->offName && pHdr->cwcName) + { + if (offRec + RT_LE2H_U16(pHdr->offName) + pHdr->cwcName * sizeof(RTUTF16) <= cbRec) + Log2(("NTFS: Name %.*ls\n", pHdr->cwcName,&pbRec[offRec + RT_LE2H_U16(pHdr->offName)])); + else + Log2(("NTFS: Name <!out of bounds!> %#x L %#x\n", RT_LE2H_U16(pHdr->offName), pHdr->cwcName)); + } + switch (pHdr->uAttrType) + { + case NTFS_AT_UNUSED: Log2(("NTFS: Type: UNUSED\n")); break; + case NTFS_AT_STANDARD_INFORMATION: Log2(("NTFS: Type: STANDARD_INFORMATION\n")); break; + case NTFS_AT_ATTRIBUTE_LIST: Log2(("NTFS: Type: ATTRIBUTE_LIST\n")); break; + case NTFS_AT_FILENAME: Log2(("NTFS: Type: FILENAME\n")); break; + case NTFS_AT_OBJECT_ID: Log2(("NTFS: Type: OBJECT_ID\n")); break; + case NTFS_AT_SECURITY_DESCRIPTOR: Log2(("NTFS: Type: SECURITY_DESCRIPTOR\n")); break; + case NTFS_AT_VOLUME_NAME: Log2(("NTFS: Type: VOLUME_NAME\n")); break; + case NTFS_AT_VOLUME_INFORMATION: Log2(("NTFS: Type: VOLUME_INFORMATION\n")); break; + case NTFS_AT_DATA: Log2(("NTFS: Type: DATA\n")); break; + case NTFS_AT_INDEX_ROOT: Log2(("NTFS: Type: INDEX_ROOT\n")); break; + case NTFS_AT_INDEX_ALLOCATION: Log2(("NTFS: Type: INDEX_ALLOCATION\n")); break; + case NTFS_AT_BITMAP: Log2(("NTFS: Type: BITMAP\n")); break; + case NTFS_AT_REPARSE_POINT: Log2(("NTFS: Type: REPARSE_POINT\n")); break; + case NTFS_AT_EA_INFORMATION: Log2(("NTFS: Type: EA_INFORMATION\n")); break; + case NTFS_AT_EA: Log2(("NTFS: Type: EA\n")); break; + case NTFS_AT_PROPERTY_SET: Log2(("NTFS: Type: PROPERTY_SET\n")); break; + case NTFS_AT_LOGGED_UTILITY_STREAM: Log2(("NTFS: Type: LOGGED_UTILITY_STREAM\n")); break; + default: + if (RT_LE2H_U32(pHdr->uAttrType) >= RT_LE2H_U32_C(NTFS_AT_FIRST_USER_DEFINED)) + Log2(("NTFS: Type: unknown user defined - %#x!\n", RT_LE2H_U32(pHdr->uAttrType))); + else + Log2(("NTFS: Type: unknown - %#x!\n", RT_LE2H_U32(pHdr->uAttrType))); + break; + } + + size_t const cbMaxAttrib = cbRec - offRec; + if (!pHdr->fNonResident) + { + uint16_t const offValue = RT_LE2H_U16(pHdr->u.Res.offValue); + uint32_t const cbValue = RT_LE2H_U32(pHdr->u.Res.cbValue); + Log2(("NTFS: Value: %#x LB %#x, fFlags=%#x bReserved=%#x\n", + offValue, cbValue, pHdr->u.Res.fFlags, pHdr->u.Res.bReserved)); + if ( offValue < cbMaxAttrib + && cbValue < cbMaxAttrib + && offValue + cbValue <= cbMaxAttrib) + { + uint8_t const *pbValue = &pbRec[offRec + offValue]; + RTTIMESPEC Spec; + char sz[80]; + switch (pHdr->uAttrType) + { + case NTFS_AT_STANDARD_INFORMATION: + { + PCNTFSATSTDINFO pInfo = (PCNTFSATSTDINFO)pbValue; + if (cbValue >= NTFSATSTDINFO_SIZE_NTFS_V12) + { + Log2(("NTFS: iCreationTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iCreationTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iCreationTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastDataModTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastDataModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastDataModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastMftModTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastMftModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastMftModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastAccessTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastAccessTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastAccessTime)), sz, sizeof(sz)) )); + Log2(("NTFS: fFileAttribs %#RX32\n", RT_LE2H_U32(pInfo->fFileAttribs) )); + Log2(("NTFS: cMaxFileVersions %#RX32\n", RT_LE2H_U32(pInfo->cMaxFileVersions) )); + Log2(("NTFS: uFileVersion %#RX32\n", RT_LE2H_U32(pInfo->uFileVersion) )); + } + else + Log2(("NTFS: Error! cbValue=%#x is smaller than expected (%#x) for NTFSATSTDINFO!\n", + cbValue, NTFSATSTDINFO_SIZE_NTFS_V12)); + if (cbValue >= sizeof(*pInfo)) + { + Log2(("NTFS: idClass %#RX32\n", RT_LE2H_U32(pInfo->idClass) )); + Log2(("NTFS: idOwner %#RX32\n", RT_LE2H_U32(pInfo->idOwner) )); + Log2(("NTFS: idSecurity %#RX32\n", RT_LE2H_U32(pInfo->idSecurity) )); + Log2(("NTFS: cbQuotaChared %#RX64\n", RT_LE2H_U64(pInfo->cbQuotaChared) )); + Log2(("NTFS: idxUpdateSequence %#RX64\n", RT_LE2H_U64(pInfo->idxUpdateSequence) )); + } + if (cbValue > sizeof(*pInfo)) + Log2(("NTFS: Undefined data: %.*Rhxs\n", cbValue - sizeof(*pInfo), &pbValue[sizeof(*pInfo)])); + break; + } + + case NTFS_AT_ATTRIBUTE_LIST: + { + uint32_t iEntry = 0; + uint32_t offEntry = 0; + while (offEntry + NTFSATLISTENTRY_SIZE_MINIMAL < cbValue) + { + PCNTFSATLISTENTRY pInfo = (PCNTFSATLISTENTRY)&pbValue[offEntry]; + Log2(("NTFS: attr[%u]: %#x in %#RX64 (sqn %#x), instance %#x, VNC=%#RX64-, name %#x L %#x\n", + iEntry, RT_LE2H_U32(pInfo->uAttrType), NTFSMFTREF_GET_IDX(&pInfo->InMftRec), + NTFSMFTREF_GET_SEQ(&pInfo->InMftRec), RT_LE2H_U16(pInfo->idAttrib), + RT_LE2H_U64(pInfo->iVcnFirst), pInfo->offName, pInfo->cwcName)); + if ( pInfo->cwcName > 0 + && pInfo->offName < pInfo->cbEntry) + Log2(("NTFS: name '%.*ls'\n", pInfo->cwcName, (uint8_t *)pInfo + pInfo->offName)); + + /* next */ + if (pInfo->cbEntry < NTFSATLISTENTRY_SIZE_MINIMAL) + { + Log2(("NTFS: cbEntry is too small! cbEntry=%#x, min %#x\n", + pInfo->cbEntry, NTFSATLISTENTRY_SIZE_MINIMAL)); + break; + } + iEntry++; + offEntry += RT_ALIGN_32(pInfo->cbEntry, 8); + } + break; + } + + case NTFS_AT_FILENAME: + { + PCNTFSATFILENAME pInfo = (PCNTFSATFILENAME)pbValue; + if (cbValue >= RT_UOFFSETOF(NTFSATFILENAME, wszFilename)) + { + Log2(("NTFS: ParentDirMftRec %#RX64, sqn %#x\n", + NTFSMFTREF_GET_IDX(&pInfo->ParentDirMftRec), NTFSMFTREF_GET_SEQ(&pInfo->ParentDirMftRec) )); + Log2(("NTFS: iCreationTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iCreationTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iCreationTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastDataModTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastDataModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastDataModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastMftModTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastMftModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastMftModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastAccessTime %#RX64 %s\n", RT_LE2H_U64(pInfo->iLastAccessTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pInfo->iLastAccessTime)), sz, sizeof(sz)) )); + Log2(("NTFS: cbAllocated %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pInfo->cbAllocated), RT_LE2H_U64(pInfo->cbAllocated))); + Log2(("NTFS: cbData %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pInfo->cbData), RT_LE2H_U64(pInfo->cbData))); + Log2(("NTFS: fFileAttribs %#RX32\n", RT_LE2H_U32(pInfo->fFileAttribs) )); + if (RT_LE2H_U32(pInfo->fFileAttribs) & NTFS_FA_REPARSE_POINT) + Log2(("NTFS: uReparseTag %#RX32\n", RT_LE2H_U32(pInfo->u.uReparseTag) )); + else + Log2(("NTFS: cbPackedEas %#RX16\n", RT_LE2H_U16(pInfo->u.cbPackedEas) )); + Log2(("NTFS: cwcFilename %#x\n", pInfo->cwcFilename)); + Log2(("NTFS: fFilenameType %#x\n", pInfo->fFilenameType)); + if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pInfo->cwcFilename]) <= cbValue) + Log2(("NTFS: wszFilename '%.*ls'\n", pInfo->cwcFilename, pInfo->wszFilename )); + else + Log2(("NTFS: Error! Truncated filename!!\n")); + } + else + Log2(("NTFS: Error! cbValue=%#x is smaller than expected (%#zx) for NTFSATFILENAME!\n", + cbValue, RT_UOFFSETOF(NTFSATFILENAME, wszFilename) )); + break; + } + + //case NTFS_AT_OBJECT_ID: + //case NTFS_AT_SECURITY_DESCRIPTOR: + //case NTFS_AT_VOLUME_NAME: + //case NTFS_AT_VOLUME_INFORMATION: + //case NTFS_AT_DATA: + + case NTFS_AT_INDEX_ROOT: + rtFsNtfsVol_LogIndexRoot((PCNTFSATINDEXROOT)pbValue, cbValue); + break; + + //case NTFS_AT_INDEX_ALLOCATION: + //case NTFS_AT_BITMAP: + //case NTFS_AT_REPARSE_POINT: + //case NTFS_AT_EA_INFORMATION: + //case NTFS_AT_EA: + //case NTFS_AT_PROPERTY_SET: + //case NTFS_AT_LOGGED_UTILITY_STREAM: + + default: + if (cbValue <= 24) + Log2(("NTFS: %.*Rhxs\n", cbValue, pbValue)); + else + Log2(("%.*Rhxd\n", cbValue, pbValue)); + break; + } + + } + else + Log2(("NTFS: !Value is out of bounds!\n")); + } + else if (RT_MAX(cbAttrib, NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED) <= cbMaxAttrib) + { + Log2(("NTFS: VNC range %#RX64 .. %#RX64 (%#RX64 clusters)\n", + RT_LE2H_U64(pHdr->u.NonRes.iVcnFirst), RT_LE2H_U64(pHdr->u.NonRes.iVcnLast), + RT_LE2H_U64(pHdr->u.NonRes.iVcnLast) - RT_LE2H_U64(pHdr->u.NonRes.iVcnFirst) + 1)); + Log2(("NTFS: cbAllocated %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pHdr->u.NonRes.cbAllocated), RT_LE2H_U64(pHdr->u.NonRes.cbAllocated))); + Log2(("NTFS: cbData %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pHdr->u.NonRes.cbData), RT_LE2H_U64(pHdr->u.NonRes.cbData))); + Log2(("NTFS: cbInitialized %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pHdr->u.NonRes.cbInitialized), RT_LE2H_U64(pHdr->u.NonRes.cbInitialized))); + uint16_t const offMappingPairs = RT_LE2H_U16(pHdr->u.NonRes.offMappingPairs); + Log2(("NTFS: offMappingPairs %#RX16\n", offMappingPairs)); + if ( pHdr->u.NonRes.abReserved[0] || pHdr->u.NonRes.abReserved[1] + || pHdr->u.NonRes.abReserved[2] || pHdr->u.NonRes.abReserved[3] || pHdr->u.NonRes.abReserved[4] ) + Log2(("NTFS: abReserved %.7Rhxs\n", pHdr->u.NonRes.abReserved)); + if (pHdr->u.NonRes.uCompressionUnit != 0) + Log2(("NTFS: Compression unit 2^%u clusters\n", pHdr->u.NonRes.uCompressionUnit)); + + if ( cbMaxAttrib >= NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED + && cbAttrib >= NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED + && ( offMappingPairs >= NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED + || offMappingPairs < NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED)) + Log2(("NTFS: cbCompressed %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pHdr->u.NonRes.cbCompressed), RT_LE2H_U64(pHdr->u.NonRes.cbCompressed))); + else if ( pHdr->u.NonRes.uCompressionUnit != 0 + && pHdr->u.NonRes.uCompressionUnit != 64 + && pHdr->u.NonRes.iVcnFirst == 0) + Log2(("NTFS: !Error! Compressed attrib fields are out of bound!\n")); + + if ( offMappingPairs < cbAttrib + && offMappingPairs >= NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED) + { + uint8_t const *pbPairs = &pbRec[offRec + offMappingPairs]; + uint32_t const cbMaxPairs = cbAttrib - offMappingPairs; + int64_t iVnc = pHdr->u.NonRes.iVcnFirst; + if (cbMaxPairs < 48) + Log2(("NTFS: Mapping Pairs: cbMaxPairs=%#x %.*Rhxs\n", cbMaxPairs, cbMaxPairs, pbPairs)); + else + Log2(("NTFS: Mapping Pairs: cbMaxPairs=%#x\n%.*Rhxd\n", cbMaxPairs, cbMaxPairs, pbPairs)); + if (!iVnc && !*pbPairs) + Log2(("NTFS: [0]: Empty\n")); + else + { + if (iVnc != 0) + Log2(("NTFS: [00/0x000]: VCN=%#012RX64 L %#012RX64 - not mapped\n", 0, iVnc)); + int64_t iLnc = 0; + uint32_t iPair = 0; + uint32_t offPairs = 0; + while (offPairs < cbMaxPairs) + { + /* First byte: 4-bit length of each of the pair values */ + uint8_t const bLengths = pbPairs[offPairs]; + if (!bLengths) + break; + uint8_t const cbRun = (bLengths & 0x0f) + (bLengths >> 4); + if (offPairs + cbRun > cbMaxPairs) + { + Log2(("NTFS: [%02d/%#05x]: run overrun! cbRun=%#x bLengths=%#x offPairs=%#x cbMaxPairs=%#x\n", + iPair, offPairs, cbRun, bLengths, offPairs, cbMaxPairs)); + break; + } + //Log2(("NTFS: @%#05x: %.*Rhxs\n", offPairs, cbRun + 1, &pbPairs[offPairs])); + + /* Value 1: Number of (virtual) clusters in this run. */ + int64_t cClustersInRun; + uint8_t cbNum = (bLengths & 0xf); + if (cbNum) + { + uint8_t const *pbNum = &pbPairs[offPairs + cbNum]; /* last byte */ + cClustersInRun = (int8_t)*pbNum--; + while (cbNum-- > 1) + cClustersInRun = (cClustersInRun << 8) + *pbNum--; + } + else + cClustersInRun = -1; + + /* Value 2: The logical cluster delta to get to the first cluster in the run. */ + cbNum = bLengths >> 4; + if (cbNum) + { + uint8_t const *pbNum = &pbPairs[offPairs + cbNum + (bLengths & 0xf)]; /* last byte */ + int64_t cLcnDelta = (int8_t)*pbNum--; + while (cbNum-- > 1) + cLcnDelta = (cLcnDelta << 8) + *pbNum--; + iLnc += cLcnDelta; + Log2(("NTFS: [%02d/%#05x]: VNC=%#012RX64 L %#012RX64 => LNC=%#012RX64\n", + iPair, offPairs, iVnc, cClustersInRun, iLnc)); + } + else + Log2(("NTFS: [%02d/%#05x]: VNC=%#012RX64 L %#012RX64 => HOLE\n", + iPair, offPairs, iVnc, cClustersInRun)); + + /* Advance. */ + iVnc += cClustersInRun; + offPairs += 1 + cbRun; + iPair++; + } + } + } + else if ( cbAttrib != NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED + && cbAttrib != NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED) + { + Log2(("NTFS: Warning! Odd non-resident attribute size: %#x!\n", cbAttrib)); + if (cbAttrib >= NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED) + Log2(("NTFS: @%05x: %.*Rhxs!\n", offRec + NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED, + cbAttrib - NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED, + &pbRec[offRec + NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED])); + } + } + else + Log2(("NTFS: !Attrib header is out of bound!\n")); + + /* Advance. */ + offRec += RT_MAX(cbAttrib, NTFSATTRIBHDR_SIZE_RESIDENT); + } + + /* Anything left? */ + if (offRec < cbRecUsed) + Log2(("NTFS: @%#05x: Tail: %.*Rhxs\n", offRec, cbRecUsed - offRec, &pbRec[offRec])); + } + else + Log2(("NTFS: Unknown record type: %.4Rhxs\n", pFileRec)); + } +} +#endif /* LOG_ENABLED */ + + +static int rtFsNtfsAttr_ParseExtents(PRTFSNTFSATTR pAttrib, PRTFSNTFSEXTENTS pExtents, uint8_t cClusterShift, int64_t iVcnFirst, + uint64_t cbVolume, PRTERRINFO pErrInfo, uint64_t idxMft, uint32_t offAttrib) +{ + PCNTFSATTRIBHDR pAttrHdr = pAttrib->pAttrHdr; + Assert(pAttrHdr->fNonResident); + Assert(pExtents->cExtents == 0); + Assert(pExtents->paExtents == NULL); + + /** @todo Not entirely sure how to best detect empty mapping pair program. + * Not sure if this is a real problem as zero length stuff can be + * resident. */ + uint16_t const offMappingPairs = RT_LE2H_U16(pAttrHdr->u.NonRes.offMappingPairs); + uint32_t const cbAttrib = RT_LE2H_U32(pAttrHdr->cbAttrib); + if ( offMappingPairs != cbAttrib + && offMappingPairs != 0) + { + if (pAttrHdr->u.NonRes.iVcnFirst < iVcnFirst) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x) has a lower starting VNC than expected: %#RX64, %#RX64", + idxMft, offAttrib, pAttrHdr->u.NonRes.iVcnFirst, iVcnFirst); + + if ( offMappingPairs >= cbAttrib + || offMappingPairs < NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Mapping pair program for attribute (@%#x) is out of bounds: %#x, cbAttrib=%#x", + idxMft, offAttrib, offMappingPairs, cbAttrib); + + /* + * Count the pairs. + */ + uint8_t const * const pbPairs = (const uint8_t *)pAttrHdr + pAttrHdr->u.NonRes.offMappingPairs; + uint32_t const cbPairs = cbAttrib - offMappingPairs; + uint32_t offPairs = 0; + uint32_t cPairs = 0; + while (offPairs < cbPairs) + { + uint8_t const bLengths = pbPairs[offPairs]; + if (bLengths) + { + uint8_t const cbRunField = bLengths & 0x0f; + uint8_t const cbLcnField = bLengths >> 4; + if ( cbRunField > 0 + && cbRunField <= 8) + { + if (cbLcnField <= 8) + { + cPairs++; + + /* Advance and check for overflow/end. */ + offPairs += 1 + cbRunField + cbLcnField; + if (offPairs <= cbAttrib) + continue; + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Mapping pair #%#x for attribute (@%#x) is out of bounds", + idxMft, cPairs - 1, offAttrib); + } + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Mapping pair #%#x for attribute (@%#x): cbLcnField is out of bound: %u", + idxMft, cPairs - 1, offAttrib, cbLcnField); + + } + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Mapping pair #%#x for attribute (@%#x): cbRunField is out of bound: %u", + idxMft, cPairs - 1, offAttrib, cbRunField); + } + break; + } + + /* + * Allocate an the extent table for them. + */ + uint32_t const cExtents = cPairs + (pAttrHdr->u.NonRes.iVcnFirst != iVcnFirst); + if (cExtents) + { + PRTFSNTFSEXTENT paExtents = (PRTFSNTFSEXTENT)RTMemAllocZ(sizeof(paExtents[0]) * cExtents); + AssertReturn(paExtents, VERR_NO_MEMORY); + + /* + * Fill the table. + */ + uint32_t iExtent = 0; + + /* A sparse hole between this and the previous extent table? */ + if (pAttrHdr->u.NonRes.iVcnFirst != iVcnFirst) + { + paExtents[iExtent].off = UINT64_MAX; + paExtents[iExtent].cbExtent = (pAttrHdr->u.NonRes.iVcnFirst - iVcnFirst) << cClusterShift; + Log3((" paExtent[%#04x]: %#018RX64 LB %#010RX64\n", iExtent, paExtents[iExtent].off, paExtents[iExtent].cbExtent)); + iExtent++; + } + + /* Run the program again, now with values and without verbose error checking. */ + uint64_t cMaxClustersInRun = (INT64_MAX >> cClusterShift) - pAttrHdr->u.NonRes.iVcnFirst; + uint64_t cbData = 0; + int64_t iLcn = 0; + int rc = VINF_SUCCESS; + offPairs = 0; + for (; iExtent < cExtents; iExtent++) + { + uint8_t const bLengths = pbPairs[offPairs++]; + uint8_t const cbRunField = bLengths & 0x0f; + uint8_t const cbLcnField = bLengths >> 4; + AssertBreakStmt((unsigned)cbRunField - 1U <= 7U, rc = VERR_VFS_BOGUS_FORMAT); + AssertBreakStmt((unsigned)cbLcnField <= 8U, rc = VERR_VFS_BOGUS_FORMAT); + + AssertBreakStmt(!(pbPairs[offPairs + cbRunField - 1] & 0x80), + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Extent #%#x for attribute (@%#x): Negative runlength value", + idxMft, iExtent, offAttrib)); + uint64_t cClustersInRun = 0; + switch (cbRunField) + { + case 8: cClustersInRun |= (uint64_t)pbPairs[offPairs + 7] << 56; RT_FALL_THRU(); + case 7: cClustersInRun |= (uint64_t)pbPairs[offPairs + 6] << 48; RT_FALL_THRU(); + case 6: cClustersInRun |= (uint64_t)pbPairs[offPairs + 5] << 40; RT_FALL_THRU(); + case 5: cClustersInRun |= (uint64_t)pbPairs[offPairs + 4] << 32; RT_FALL_THRU(); + case 4: cClustersInRun |= (uint32_t)pbPairs[offPairs + 3] << 24; RT_FALL_THRU(); + case 3: cClustersInRun |= (uint32_t)pbPairs[offPairs + 2] << 16; RT_FALL_THRU(); + case 2: cClustersInRun |= (uint16_t)pbPairs[offPairs + 1] << 8; RT_FALL_THRU(); + case 1: cClustersInRun |= (uint16_t)pbPairs[offPairs + 0] << 0; RT_FALL_THRU(); + } + offPairs += cbRunField; + AssertBreakStmt(cClustersInRun <= cMaxClustersInRun, + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Extent #%#x for attribute (@%#x): too many clusters %#RX64, max %#RX64", + idxMft, iExtent, offAttrib, cClustersInRun, cMaxClustersInRun)); + cMaxClustersInRun -= cClustersInRun; + paExtents[iExtent].cbExtent = cClustersInRun << cClusterShift; + cbData += cClustersInRun << cClusterShift; + + if (cbLcnField) + { + unsigned offVncDelta = cbLcnField; + int64_t cLncDelta = (int8_t)pbPairs[--offVncDelta + offPairs]; + while (offVncDelta-- > 0) + cLncDelta = (cLncDelta << 8) | pbPairs[offVncDelta + offPairs]; + offPairs += cbLcnField; + + iLcn += cLncDelta; + if (iLcn >= 0) + { + paExtents[iExtent].off = (uint64_t)iLcn << cClusterShift; + AssertBreakStmt((paExtents[iExtent].off >> cClusterShift) == (uint64_t)iLcn, + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Extent #%#x for attribute (@%#x): iLcn %RX64 overflows when shifted by %u", + idxMft, iExtent, offAttrib, iLcn, cClusterShift)); + AssertBreakStmt( paExtents[iExtent].off < cbVolume + || paExtents[iExtent].cbExtent < cbVolume + || paExtents[iExtent].off + paExtents[iExtent].cbExtent <= cbVolume, + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Extent #%#x for attribute (@%#x) outside volume: %#RX64 LB %#RX64, cbVolume=%#RX64", + idxMft, iExtent, offAttrib, paExtents[iExtent].off, + paExtents[iExtent].cbExtent, cbVolume)); + } + else + paExtents[iExtent].off = UINT64_MAX; + } + else + paExtents[iExtent].off = UINT64_MAX; + Log3((" paExtent[%#04x]: %#018RX64 LB %#010RX64\n", iExtent, paExtents[iExtent].off, paExtents[iExtent].cbExtent)); + } + + /* Commit if everything went fine? */ + if (RT_SUCCESS(rc)) + { + pExtents->cbData = cbData; + pExtents->cExtents = cExtents; + pExtents->paExtents = paExtents; + } + else + { + RTMemFree(paExtents); + return rc; + } + } + } + return VINF_SUCCESS; +} + + +/** + * Parses the given MTF record and all related records, putting the result in + * pRec->pCore (with one reference for the caller). + * + * ASSUMES caller will insert pRec->pCore into the CoreInUseHead list on + * success, and destroy it on failure. It is better to have caller do the + * inserting/destroy, since we don't want to cache a failed parsing attempt. + * (It is also preferable to add RTFSNTFSCORE::cbCost once it's fully calculated + * and in the place as the insertion.) + * + * @returns IPRT status code. + * @param pThis The volume. + * @param pRec The MFT record to parse. + * @param pErrInfo Where to return additional error information. Optional. + */ +static int rtFsNtfsVol_ParseMft(PRTFSNTFSVOL pThis, PRTFSNTFSMFTREC pRec, PRTERRINFO pErrInfo) +{ + AssertReturn(!pRec->pCore, VERR_INTERNAL_ERROR_4); + + /* + * Check that it is a file record and that its base MFT record number is zero. + * Caller should do the base record resolving. + */ + PNTFSRECFILE pFileRec = pRec->pFileRec; + if (pFileRec->Hdr.uMagic != NTFSREC_MAGIC_FILE) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Not a FILE entry (%.4Rhxs)", + pRec->TreeNode.Key, &pFileRec->Hdr); + if (pFileRec->BaseMftRec.u64 != 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Not a base record (%#RX64, sqn %#x)", + pRec->TreeNode.Key, NTFSMFTREF_GET_IDX(&pFileRec->BaseMftRec), + NTFSMFTREF_GET_SEQ(&pFileRec->BaseMftRec) ); + + /* + * Create a core node (1 reference, returned even on error). + */ + PRTFSNTFSCORE pCore = (PRTFSNTFSCORE)RTMemAllocZ(sizeof(*pCore)); + AssertReturn(pCore, VERR_NO_MEMORY); + + pCore->cRefs = 1; + pCore->cbCost = pThis->cbMftRecord + sizeof(*pCore); + pCore->pVol = pThis; + RTListInit(&pCore->AttribHead); + pCore->pMftRec = pRec; + rtFsNtfsMftRec_Retain(pRec); + pRec->pCore = pCore; + + /* + * Parse attributes. + * We process any attribute list afterwards, skipping attributes in this MFT record. + */ + PRTFSNTFSATTR pAttrList = NULL; + uint8_t * const pbRec = pRec->pbRec; + uint32_t offRec = pFileRec->offFirstAttrib; + uint32_t const cbRecUsed = RT_MIN(pThis->cbMftRecord, pFileRec->cbRecUsed); + while (offRec + NTFSATTRIBHDR_SIZE_RESIDENT <= cbRecUsed) + { + PNTFSATTRIBHDR pAttrHdr = (PNTFSATTRIBHDR)&pbRec[offRec]; + + /* + * Validate the attribute data. + */ + uint32_t const cbAttrib = RT_LE2H_U32(pAttrHdr->cbAttrib); + uint32_t const cbMin = !pAttrHdr->fNonResident ? NTFSATTRIBHDR_SIZE_RESIDENT + : pAttrHdr->u.NonRes.uCompressionUnit == 0 ? NTFSATTRIBHDR_SIZE_NONRES_UNCOMPRESSED + : NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED; + if (cbAttrib < cbMin) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x) is too small (%#x, cbMin=%#x)", + pRec->TreeNode.Key, offRec, cbAttrib, cbMin); + if (offRec + cbAttrib > cbRecUsed) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x) is too long (%#x, cbRecUsed=%#x)", + pRec->TreeNode.Key, offRec, cbAttrib, cbRecUsed); + if (cbAttrib & 0x7) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x) size is misaligned: %#x", + pRec->TreeNode.Key, offRec, cbAttrib); + if (pAttrHdr->fNonResident) + { + int64_t const cbAllocated = RT_LE2H_U64(pAttrHdr->u.NonRes.cbAllocated); + if (cbAllocated < 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): cbAllocated (%#RX64) is negative", + pRec->TreeNode.Key, offRec, cbAllocated); + if ((uint64_t)cbAllocated & (pThis->cbCluster - 1)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): cbAllocated (%#RX64) isn't cluster aligned (cbCluster=%#x)", + pRec->TreeNode.Key, offRec, cbAllocated, pThis->cbCluster); + + int64_t const cbData = RT_LE2H_U64(pAttrHdr->u.NonRes.cbData); + if (cbData < 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): cbData (%#RX64) is negative", + pRec->TreeNode.Key, offRec, cbData); + + int64_t const cbInitialized = RT_LE2H_U64(pAttrHdr->u.NonRes.cbInitialized); + if (cbInitialized < 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): cbInitialized (%#RX64) is negative", + pRec->TreeNode.Key, offRec, cbInitialized); + + int64_t const iVcnFirst = RT_LE2H_U64(pAttrHdr->u.NonRes.iVcnFirst); + int64_t const iVcnLast = RT_LE2H_U64(pAttrHdr->u.NonRes.iVcnLast); + if ( iVcnFirst > iVcnLast + && ( iVcnLast != -1 + || cbAllocated != 0)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): iVcnFirst (%#RX64) is higher than iVcnLast (%#RX64)", + pRec->TreeNode.Key, offRec, iVcnFirst, iVcnLast); + if (iVcnFirst < 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): iVcnFirst (%#RX64) is negative", + pRec->TreeNode.Key, offRec, iVcnFirst); + if ((uint64_t)iVcnLast > pThis->iMaxVirtualCluster) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): iVcnLast (%#RX64) is too high, max %RX64 (shift %#x)", + pRec->TreeNode.Key, offRec, iVcnLast, pThis->cClusterShift, pThis->iMaxVirtualCluster); + uint16_t const offMappingPairs = RT_LE2H_U16(pAttrHdr->u.NonRes.offMappingPairs); + if ( (offMappingPairs != 0 && offMappingPairs < cbMin) + || offMappingPairs > cbAttrib) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): offMappingPairs (%#x) is out of bounds (cbAttrib=%#x, cbMin=%#x)", + pRec->TreeNode.Key, offRec, offMappingPairs, cbAttrib, cbMin); + if (pAttrHdr->u.NonRes.uCompressionUnit > 16) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): uCompressionUnit (%#x) is too high", + pRec->TreeNode.Key, offRec, pAttrHdr->u.NonRes.uCompressionUnit); + + if (cbMin >= NTFSATTRIBHDR_SIZE_NONRES_COMPRESSED) + { + int64_t const cbCompressed = RT_LE2H_U64(pAttrHdr->u.NonRes.cbCompressed); + if (cbAllocated < 0) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): cbCompressed (%#RX64) is negative", + pRec->TreeNode.Key, offRec, cbCompressed); + } + } + else + { + uint16_t const offValue = RT_LE2H_U32(pAttrHdr->u.Res.offValue); + if ( offValue > cbAttrib + || offValue < NTFSATTRIBHDR_SIZE_RESIDENT) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): offValue (%#RX16) is out of bounds (cbAttrib=%#RX32, cbValue=%#RX32)", + pRec->TreeNode.Key, offRec, offValue, cbAttrib, RT_LE2H_U32(pAttrHdr->u.Res.cbValue)); + if ((pAttrHdr->fFlags & NTFS_AF_COMPR_FMT_MASK) != NTFS_AF_COMPR_FMT_NONE) + { +#if 1 /* Seen on INDEX_ROOT of ReportQueue on w7, so turned into debug log warning. */ + Log(("NTFS: Warning! Bad MFT record %#RX64: Attribute (@%#x): fFlags (%#RX16) indicate compression of a resident attribute\n", + pRec->TreeNode.Key, offRec, RT_LE2H_U16(pAttrHdr->fFlags) )); +#else + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): fFlags (%#RX16) indicate compression of a resident attribute", + pRec->TreeNode.Key, offRec, RT_LE2H_U16(pAttrHdr->fFlags)); +#endif + } + } + + if (pAttrHdr->cwcName != 0) + { + uint16_t offName = RT_LE2H_U16(pAttrHdr->offName); + if ( offName < cbMin + || offName >= cbAttrib) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): offName (%#RX16) is out of bounds (cbAttrib=%#RX32, cbMin=%#RX32)", + pRec->TreeNode.Key, offRec, offName, cbAttrib, cbMin); + if (offName + pAttrHdr->cwcName * sizeof(RTUTF16) > cbAttrib) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Bad MFT record %#RX64: Attribute (@%#x): offName (%#RX16) + cwcName (%#x) is out of bounds (cbAttrib=%#RX32)", + pRec->TreeNode.Key, offRec, offName, pAttrHdr->cwcName, cbAttrib); + } + + /* + * Allocate and initialize a new attribute. + */ + PRTFSNTFSATTR pAttrib = (PRTFSNTFSATTR)RTMemAllocZ(sizeof(*pAttrib)); + AssertReturn(pAttrib, VERR_NO_MEMORY); + pAttrib->pAttrHdr = pAttrHdr; + pAttrib->offAttrHdrInMftRec = offRec; + pAttrib->pCore = pCore; + //pAttrib->cbResident = 0; + //pAttrib->cbValue = 0; + //pAttrib->Extents.cExtents = 0; + //pAttrib->Extents.paExtents = NULL; + //pAttrib->pSubRecHead = NULL; + if (pAttrHdr->fNonResident) + { + pAttrib->cbValue = RT_LE2H_U64(pAttrHdr->u.NonRes.cbData); + int rc = rtFsNtfsAttr_ParseExtents(pAttrib, &pAttrib->Extents, pThis->cClusterShift, 0 /*iVncFirst*/, + pThis->cbVolume, pErrInfo, pRec->TreeNode.Key, offRec); + if (RT_FAILURE(rc)) + { + RTMemFree(pAttrib); + return rc; + } + } + else + { + pAttrib->cbValue = RT_LE2H_U32(pAttrHdr->u.Res.cbValue); + if ( (uint32_t)pAttrib->cbValue > 0 + && RT_LE2H_U16(pAttrHdr->u.Res.offValue) < cbAttrib) + { + pAttrib->cbResident = cbAttrib - RT_LE2H_U16(pAttrHdr->u.Res.offValue); + if (pAttrib->cbResident > (uint32_t)pAttrib->cbValue) + pAttrib->cbResident = (uint32_t)pAttrib->cbValue; + } + } + + RTListAppend(&pCore->AttribHead, &pAttrib->ListEntry); + + if (pAttrHdr->uAttrType == NTFS_AT_ATTRIBUTE_LIST) + pAttrList = pAttrib; + + /* Advance. */ + offRec += cbAttrib; + } + + /* + * Process any attribute list. + */ + if (pAttrList) + { + /** @todo */ + } + + return VINF_SUCCESS; +} + + +/** + * Translates a attribute value offset to a disk offset. + * + * @returns Disk offset, UINT64_MAX if not translatable for some reason. + * @param pAttr The + * @param off The offset to translate. + * @param pcbValid Where to return the run length at the return offset. + * Optional. + */ +static uint64_t rtFsNtfsAttr_OffsetToDisk(PRTFSNTFSATTR pAttr, uint64_t off, uint64_t *pcbValid) +{ + /* + * Searching the extend list is a tad complicated since it starts in one + * structure and continues in a different one. But whatever. + */ + PRTFSNTFSEXTENTS pTable = &pAttr->Extents; + PRTFSNTFSATTRSUBREC pCurSub = NULL; + for (;;) + { + if (off < pTable->cbData) + { + uint32_t iExtent = 0; + while ( iExtent < pTable->cExtents + && off >= pTable->paExtents[iExtent].cbExtent) + { + off -= pTable->paExtents[iExtent].cbExtent; + iExtent++; + } + AssertReturn(iExtent < pTable->cExtents, UINT64_MAX); + if (pcbValid) + *pcbValid = pTable->paExtents[iExtent].cbExtent - off; + return pTable->paExtents[iExtent].off != UINT64_MAX ? pTable->paExtents[iExtent].off + off : UINT64_MAX; + } + + /* Next table. */ + off -= pTable->cbData; + if (!pCurSub) + pCurSub = pAttr->pSubRecHead; + else + pCurSub = pCurSub->pNext; + if (!pCurSub) + { + if (pcbValid) + *pcbValid = 0; + return UINT64_MAX; + } + pTable = &pCurSub->Extents; + } + /* not reached */ +} + + +static int rtFsNtfsAttr_Read(PRTFSNTFSATTR pAttr, uint64_t off, void *pvBuf, size_t cbToRead) +{ + PRTFSNTFSVOL pVol = pAttr->pCore->pVol; + int rc; + if (!pAttr->pAttrHdr->fNonResident) + { + /* + * The attribute is resident. + */ + uint32_t cbAttrib = RT_LE2H_U32(pAttr->pAttrHdr->cbAttrib); + uint32_t cbValue = RT_LE2H_U32(pAttr->pAttrHdr->u.Res.cbValue); + uint16_t offValue = RT_LE2H_U16(pAttr->pAttrHdr->u.Res.offValue); + if ( off < cbValue + && cbToRead <= cbValue + && off + cbToRead <= cbValue) + { + if (offValue <= cbAttrib) + { + cbAttrib -= offValue; + if (off < cbAttrib) + { + /** @todo check if its possible to have cbValue larger than the attribute and + * reading those extra bytes as zero. */ + if ( pAttr->offAttrHdrInMftRec + offValue + cbAttrib <= pVol->cbMftRecord + && cbAttrib <= pVol->cbMftRecord) + { + size_t cbToCopy = cbAttrib - off; + if (cbToCopy > cbToRead) + cbToCopy = cbToRead; + memcpy(pvBuf, (uint8_t *)pAttr->pAttrHdr + offValue, cbToCopy); + pvBuf = (uint8_t *)pvBuf + cbToCopy; + cbToRead -= cbToCopy; + rc = VINF_SUCCESS; + } + else + { + rc = VERR_VFS_BOGUS_OFFSET; + Log(("rtFsNtfsAttr_Read: bad resident attribute!\n")); + } + } + else + rc = VINF_SUCCESS; + } + else + rc = VERR_VFS_BOGUS_FORMAT; + } + else + rc = VERR_EOF; + } + else if (pAttr->pAttrHdr->u.NonRes.uCompressionUnit == 0) + { + /* + * Uncompressed non-resident attribute. + */ + uint64_t const cbAllocated = RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbAllocated); + if ( off >= cbAllocated + || cbToRead > cbAllocated + || off + cbToRead > cbAllocated) + rc = VERR_EOF; + else + { + rc = VINF_SUCCESS; + + uint64_t const cbInitialized = RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbInitialized); + if ( off < cbInitialized + && cbToRead > 0) + { + /* + * Locate the first extent. This is a tad complicated. + * + * We move off along as we traverse the extent tables, so that it is relative + * to the start of the current extent. + */ + PRTFSNTFSEXTENTS pTable = &pAttr->Extents; + uint32_t iExtent = 0; + PRTFSNTFSATTRSUBREC pCurSub = NULL; + for (;;) + { + if (off < pTable->cbData) + { + while ( iExtent < pTable->cExtents + && off >= pTable->paExtents[iExtent].cbExtent) + { + off -= pTable->paExtents[iExtent].cbExtent; + iExtent++; + } + AssertReturn(iExtent < pTable->cExtents, VERR_INTERNAL_ERROR_2); + break; + } + + /* Next table. */ + off -= pTable->cbData; + if (!pCurSub) + pCurSub = pAttr->pSubRecHead; + else + pCurSub = pCurSub->pNext; + if (!pCurSub) + { + iExtent = UINT32_MAX; + break; + } + pTable = &pCurSub->Extents; + iExtent = 0; + } + + /* + * The read loop. + */ + while (iExtent != UINT32_MAX) + { + uint64_t cbMaxRead = pTable->paExtents[iExtent].cbExtent; + Assert(off < cbMaxRead); + cbMaxRead -= off; + size_t const cbThisRead = cbMaxRead >= cbToRead ? cbToRead : (size_t)cbMaxRead; + if (pTable->paExtents[iExtent].off == UINT64_MAX) + RT_BZERO(pvBuf, cbThisRead); + else + { + rc = RTVfsFileReadAt(pVol->hVfsBacking, pTable->paExtents[iExtent].off + off, pvBuf, cbThisRead, NULL); + Log4(("NTFS: Volume read: @%#RX64 LB %#zx -> %Rrc\n", pTable->paExtents[iExtent].off + off, cbThisRead, rc)); + if (RT_FAILURE(rc)) + break; + } + pvBuf = (uint8_t *)pvBuf + cbThisRead; + cbToRead -= cbThisRead; + if (!cbToRead) + break; + off = 0; + + /* + * Advance to the next extent. + */ + iExtent++; + if (iExtent >= pTable->cExtents) + { + pCurSub = pCurSub ? pCurSub->pNext : pAttr->pSubRecHead; + if (!pCurSub) + break; + pTable = &pCurSub->Extents; + iExtent = 0; + } + } + } + } + } + else + { + LogRel(("rtFsNtfsAttr_Read: Compressed files are not supported\n")); + rc = VERR_NOT_SUPPORTED; + } + + /* + * Anything else beyond the end of what's stored/initialized? + */ + if ( cbToRead > 0 + && RT_SUCCESS(rc)) + { + RT_BZERO(pvBuf, cbToRead); + } + + return rc; +} + + +/** + * + * @note Only modifying non-resident data is currently supported. No + * shrinking or growing. Metadata is not modified. + */ +static int rtFsNtfsAttr_Write(PRTFSNTFSATTR pAttr, uint64_t off, void const *pvBuf, size_t cbToWrite) +{ + PRTFSNTFSVOL pVol = pAttr->pCore->pVol; + int rc; + if (!pAttr->pAttrHdr->fNonResident) + { + /* + * The attribute is resident. Currently not supported. + */ +#if 0 + uint32_t cbAttrib = RT_LE2H_U32(pAttr->pAttrHdr->cbAttrib); + uint32_t cbValue = RT_LE2H_U32(pAttr->pAttrHdr->u.Res.cbValue); + uint16_t offValue = RT_LE2H_U16(pAttr->pAttrHdr->u.Res.offValue); + if ( off < cbValue + && cbToWrite <= cbValue + && off + cbToWrite <= cbValue) + { + if (offValue <= cbAttrib) + { + cbAttrib -= offValue; + if (off < cbAttrib) + { + /** @todo check if its possible to have cbValue larger than the attribute and + * reading those extra bytes as zero. */ + if ( pAttr->offAttrHdrInMftRec + offValue + cbAttrib <= pVol->cbMftRecord + && cbAttrib <= pVol->cbMftRecord) + { + size_t cbToCopy = cbAttrib - off; + if (cbToCopy > cbToWrite) + cbToCopy = cbToWrite; + memcpy(pvBuf, (uint8_t *)pAttr->pAttrHdr + offValue, cbToCopy); + pvBuf = (uint8_t *)pvBuf + cbToCopy; + cbToWrite -= cbToCopy; + rc = VINF_SUCCESS; + } + else + { + rc = VERR_VFS_BOGUS_OFFSET; + Log(("rtFsNtfsAttr_Write: bad resident attribute!\n")); + } + } + else + rc = VINF_SUCCESS; + } + else + rc = VERR_VFS_BOGUS_FORMAT; + } + else + rc = VERR_EOF; +#else + LogRel(("rtFsNtfsAttr_Write: file too small to write to.\n")); + rc = VERR_INTERNAL_ERROR_3; +#endif + } + else if (pAttr->pAttrHdr->u.NonRes.uCompressionUnit == 0) + { + /* + * Uncompressed non-resident attribute. + * Note! We currently + */ + uint64_t const cbAllocated = RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbAllocated); + if ( off >= cbAllocated + || cbToWrite > cbAllocated + || off + cbToWrite > cbAllocated) + rc = VERR_EOF; + else + { + rc = VINF_SUCCESS; + + uint64_t const cbInitialized = RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbInitialized); + if ( off < cbInitialized + && cbToWrite > 0) + { + /* + * Locate the first extent. This is a tad complicated. + * + * We move off along as we traverse the extent tables, so that it is relative + * to the start of the current extent. + */ + PRTFSNTFSEXTENTS pTable = &pAttr->Extents; + uint32_t iExtent = 0; + PRTFSNTFSATTRSUBREC pCurSub = NULL; + for (;;) + { + if (off < pTable->cbData) + { + while ( iExtent < pTable->cExtents + && off >= pTable->paExtents[iExtent].cbExtent) + { + off -= pTable->paExtents[iExtent].cbExtent; + iExtent++; + } + AssertReturn(iExtent < pTable->cExtents, VERR_INTERNAL_ERROR_2); + break; + } + + /* Next table. */ + off -= pTable->cbData; + if (!pCurSub) + pCurSub = pAttr->pSubRecHead; + else + pCurSub = pCurSub->pNext; + if (!pCurSub) + { + iExtent = UINT32_MAX; + break; + } + pTable = &pCurSub->Extents; + iExtent = 0; + } + + /* + * The write loop. + */ + while (iExtent != UINT32_MAX) + { + uint64_t cbMaxWrite = pTable->paExtents[iExtent].cbExtent; + Assert(off < cbMaxWrite); + cbMaxWrite -= off; + size_t const cbThisWrite = cbMaxWrite >= cbToWrite ? cbToWrite : (size_t)cbMaxWrite; + if (pTable->paExtents[iExtent].off == UINT64_MAX) + { + if (!ASMMemIsZero(pvBuf, cbThisWrite)) + { + LogRel(("rtFsNtfsAttr_Write: Unable to modify sparse section of file!\n")); + rc = VERR_INTERNAL_ERROR_2; + break; + } + } + else + { + rc = RTVfsFileWriteAt(pVol->hVfsBacking, pTable->paExtents[iExtent].off + off, pvBuf, cbThisWrite, NULL); + Log4(("NTFS: Volume write: @%#RX64 LB %#zx -> %Rrc\n", pTable->paExtents[iExtent].off + off, cbThisWrite, rc)); + if (RT_FAILURE(rc)) + break; + } + pvBuf = (uint8_t const *)pvBuf + cbThisWrite; + cbToWrite -= cbThisWrite; + if (!cbToWrite) + break; + off = 0; + + /* + * Advance to the next extent. + */ + iExtent++; + if (iExtent >= pTable->cExtents) + { + pCurSub = pCurSub ? pCurSub->pNext : pAttr->pSubRecHead; + if (!pCurSub) + break; + pTable = &pCurSub->Extents; + iExtent = 0; + } + } + } + } + } + else + { + LogRel(("rtFsNtfsAttr_Write: Compressed files are not supported\n")); + rc = VERR_NOT_SUPPORTED; + } + + /* + * Anything else beyond the end of what's stored/initialized? + */ + if ( cbToWrite > 0 + && RT_SUCCESS(rc)) + { + LogRel(("rtFsNtfsAttr_Write: Unable to modify sparse section (tail) of file!\n")); + rc = VERR_INTERNAL_ERROR_2; + } + + return rc; +} + + +/** + * + * @returns + * @param pRecHdr . + * @param cbRec . + * @param fRelaxedUsa . + * @param pErrInfo . + * + * @see https://msdn.microsoft.com/en-us/library/bb470212%28v=vs.85%29.aspx + */ +static int rtFsNtfsRec_DoMultiSectorFixups(PNTFSRECHDR pRecHdr, uint32_t cbRec, bool fRelaxedUsa, PRTERRINFO pErrInfo) +{ + /* + * Do sanity checking. + */ + uint16_t offUpdateSeqArray = RT_LE2H_U16(pRecHdr->offUpdateSeqArray); + uint16_t cUpdateSeqEntries = RT_LE2H_U16(pRecHdr->cUpdateSeqEntries); + if ( !(cbRec & (NTFS_MULTI_SECTOR_STRIDE - 1)) + && !(offUpdateSeqArray & 1) /* two byte aligned */ + && cUpdateSeqEntries == 1 + cbRec / NTFS_MULTI_SECTOR_STRIDE + && offUpdateSeqArray + (uint32_t)cUpdateSeqEntries * 2U < NTFS_MULTI_SECTOR_STRIDE - 2U) + { + uint16_t const *pauUsa = (uint16_t const *)((uint8_t *)pRecHdr + offUpdateSeqArray); + + /* + * The first update seqence array entry is the value stored at + * the fixup locations at the end of the blocks. We read this + * and check each of the blocks. + */ + uint16_t const uCheck = *pauUsa++; + cUpdateSeqEntries--; + for (uint16_t iBlock = 0; iBlock < cUpdateSeqEntries; iBlock++) + { + uint16_t const *puBlockCheck = (uint16_t const *)((uint8_t *)pRecHdr + (iBlock + 1) * NTFS_MULTI_SECTOR_STRIDE - 2U); + if (*puBlockCheck == uCheck) + { /* likely */ } + else if (!fRelaxedUsa) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_OFFSET, + "Multisector transfer error: block #%u ends with %#x instead of %#x (fixup: %#x)", + iBlock, RT_LE2H_U16(*puBlockCheck), RT_LE2H_U16(uCheck), RT_LE2H_U16(pauUsa[iBlock]) ); + else + { + Log(("NTFS: Multisector transfer warning: block #%u ends with %#x instead of %#x (fixup: %#x)\n", + iBlock, RT_LE2H_U16(*puBlockCheck), RT_LE2H_U16(uCheck), RT_LE2H_U16(pauUsa[iBlock]) )); + return VINF_SUCCESS; + } + } + + /* + * Apply the fixups. + * Note! We advanced pauUsa above, so it's now at the fixup values. + */ + for (uint16_t iBlock = 0; iBlock < cUpdateSeqEntries; iBlock++) + { + uint16_t *puFixup = (uint16_t *)((uint8_t *)pRecHdr + (iBlock + 1) * NTFS_MULTI_SECTOR_STRIDE - 2U); + *puFixup = pauUsa[iBlock]; + } + return VINF_SUCCESS; + } + if (fRelaxedUsa) + { + Log(("NTFS: Ignoring bogus multisector update sequence: cbRec=%#x uMagic=%#RX32 offUpdateSeqArray=%#x cUpdateSeqEntries=%#x\n", + cbRec, RT_LE2H_U32(pRecHdr->uMagic), offUpdateSeqArray, cUpdateSeqEntries )); + return VINF_SUCCESS; + } + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_OFFSET, + "Bogus multisector update sequence: cbRec=%#x uMagic=%#RX32 offUpdateSeqArray=%#x cUpdateSeqEntries=%#x", + cbRec, RT_LE2H_U32(pRecHdr->uMagic), offUpdateSeqArray, cUpdateSeqEntries); +} + + +/** + * Allocate and parse an MFT record, returning a core object structure. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param idxMft The index of the MTF record. + * @param fRelaxedUsa Relaxed update sequence checking. Won't fail if + * checks doesn't work or not present. + * @param ppCore Where to return the core object structure. + * @param pErrInfo Where to return error details. Optional. + */ +static int rtFsNtfsVol_NewCoreForMftIdx(PRTFSNTFSVOL pThis, uint64_t idxMft, bool fRelaxedUsa, + PRTFSNTFSCORE *ppCore, PRTERRINFO pErrInfo) +{ + *ppCore = NULL; + Assert(pThis->pMftData); + Assert(RTAvlU64Get(&pThis->MftRoot, idxMft) == NULL); + + PRTFSNTFSMFTREC pRec = rtFsNtfsVol_NewMftRec(pThis, idxMft); + AssertReturn(pRec, VERR_NO_MEMORY); + + uint64_t offRec = idxMft * pThis->cbMftRecord; + int rc = rtFsNtfsAttr_Read(pThis->pMftData, offRec, pRec->pbRec, pThis->cbMftRecord); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsRec_DoMultiSectorFixups(&pRec->pFileRec->Hdr, pThis->cbMftRecord, fRelaxedUsa, pErrInfo); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtfsNtfsMftRec_Log(pRec, pThis->cbMftRecord); +#endif + rc = rtFsNtfsVol_ParseMft(pThis, pRec, pErrInfo); + if (RT_SUCCESS(rc)) + { + PRTFSNTFSCORE pCore = pRec->pCore; + rtFsNtfsMftRec_Release(pRec, pThis); + + /* Insert core into the cache list and update the cost, maybe trimming the cache. */ + RTListAppend(&pThis->CoreInUseHead, &pCore->ListEntry); + pThis->cbCoreObjects += pCore->cbCost; + if (pThis->cbCoreObjects > RTFSNTFS_MAX_CORE_CACHE_SIZE) + rtFsNtfsIdxVol_TrimCoreObjectCache(pThis); + + *ppCore = pCore; + return VINF_SUCCESS; + } + + if (pRec->pCore) + rtFsNtfsCore_Destroy(pRec->pCore); + rtFsNtfsMftRec_Release(pRec, pThis); + } + return rc; +} + + +/** + * Queries the core object struct for the given MFT record reference. + * + * Does caching. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param pMftRef The MFT reference to get the corresponding core + * for. + * @param fRelaxedUsa Relaxed update sequence checking. Won't fail if + * checks doesn't work or not present. + * @param ppCore Where to return the referenced core object + * structure. + * @param pErrInfo Where to return error details. Optional. + */ +static int rtFsNtfsVol_QueryCoreForMftRef(PRTFSNTFSVOL pThis, PCNTFSMFTREF pMftRef , bool fRelaxedUsa, + PRTFSNTFSCORE *ppCore, PRTERRINFO pErrInfo) +{ + *ppCore = NULL; + Assert(pThis->pMftData); + + int rc; + PRTFSNTFSMFTREC pMftRec = (PRTFSNTFSMFTREC)RTAvlU64Get(&pThis->MftRoot, NTFSMFTREF_GET_IDX(pMftRef)); + if (pMftRec) + { + /* + * Cache hit. Check that the resure sequence number matches. + * To be slightly paranoid, also check that it's a base MFT record and that it has been parsed already. + */ + if (RT_LE2H_U16(pMftRec->pFileRec->uRecReuseSeqNo) == NTFSMFTREF_GET_SEQ(pMftRef)) + { + if ( NTFSMFTREF_IS_ZERO(&pMftRec->pFileRec->BaseMftRec) + && pMftRec->pCore) + { + rtFsNtfsCore_Retain(pMftRec->pCore); + *ppCore = pMftRec->pCore; + rc = VINF_SUCCESS; + } + else + AssertLogRelMsgFailedStmt(("pCore=%p; BaseMftRec=%#RX64 sqn %#x\n", pMftRec->pCore, + NTFSMFTREF_GET_IDX(&pMftRec->pFileRec->BaseMftRec), + NTFSMFTREF_GET_SEQ(&pMftRec->pFileRec->BaseMftRec)), + rc = VERR_INTERNAL_ERROR_3 ); + } + else + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_OFFSET, + "Stale parent directory MFT reference: %#RX64 sqn %#x - current sqn %#x", + NTFSMFTREF_GET_IDX(pMftRef), NTFSMFTREF_GET_SEQ(pMftRef), + RT_LE2H_U16(pMftRec->pFileRec->uRecReuseSeqNo) ); + } + else + { + /* + * Load new and check that the reuse sequence number match. + */ + rc = rtFsNtfsVol_NewCoreForMftIdx(pThis, NTFSMFTREF_GET_IDX(pMftRef), fRelaxedUsa, ppCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + PRTFSNTFSCORE pCore = *ppCore; + if (RT_LE2H_U16(pCore->pMftRec->pFileRec->uRecReuseSeqNo) == NTFSMFTREF_GET_SEQ(pMftRef)) + rc = VINF_SUCCESS; + else + { + rtFsNtfsCore_Release(pCore); + *ppCore = NULL; + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_OFFSET, + "Stale parent directory MFT reference: %#RX64 sqn %#x - current sqn %#x", + NTFSMFTREF_GET_IDX(pMftRef), NTFSMFTREF_GET_SEQ(pMftRef), + RT_LE2H_U16(pCore->pMftRec->pFileRec->uRecReuseSeqNo) ); + } + } + } + return rc; +} + + +/** + * Destroys a core structure. + * + * ASSUMES the caller has remove @a pThis from the list it's on and updated the + * cbCoreObjects as necessary. + * + * @returns 0 + * @param pThis The core structure. + */ +static uint32_t rtFsNtfsCore_Destroy(PRTFSNTFSCORE pThis) +{ + /* + * Free attributes. + */ + PRTFSNTFSATTR pCurAttr; + PRTFSNTFSATTR pNextAttr; + RTListForEachSafe(&pThis->AttribHead, pCurAttr, pNextAttr, RTFSNTFSATTR, ListEntry) + { + PRTFSNTFSATTRSUBREC pSub = pCurAttr->pSubRecHead; + while (pSub) + { + pCurAttr->pSubRecHead = pSub->pNext; + RTMemFree(pSub->Extents.paExtents); + pSub->Extents.paExtents = NULL; + pSub->pAttrHdr = NULL; + pSub->pNext = NULL; + RTMemFree(pSub); + + pSub = pCurAttr->pSubRecHead; + } + + pCurAttr->pCore = NULL; + pCurAttr->pAttrHdr = NULL; + RTMemFree(pCurAttr->Extents.paExtents); + pCurAttr->Extents.paExtents = NULL; + } + + /* + * Release the MFT chain. + */ + PRTFSNTFSMFTREC pMftRec = pThis->pMftRec; + while (pMftRec) + { + pThis->pMftRec = pMftRec->pNext; + Assert(pMftRec->pCore == pThis); + pMftRec->pNext = NULL; + pMftRec->pCore = NULL; + rtFsNtfsMftRec_Release(pMftRec, pThis->pVol); + + pMftRec = pThis->pMftRec; + } + + RTMemFree(pThis); + + return 0; +} + + +/** + * Trims the core object cache down to RTFSNTFS_MAX_CORE_CACHE_SIZE. + * + * @param pThis The NTFS volume instance. + */ +static void rtFsNtfsIdxVol_TrimCoreObjectCache(PRTFSNTFSVOL pThis) +{ + while (pThis->cbCoreObjects > RTFSNTFS_MAX_CORE_CACHE_SIZE) + { + PRTFSNTFSCORE pCore = RTListRemoveFirst(&pThis->CoreUnusedHead, RTFSNTFSCORE, ListEntry); + if (!pCore) + break; + pThis->cbCoreObjects -= pCore->cbCost; + rtFsNtfsCore_Destroy(pCore); + } +} + + +/** + * Releases a refernece to a core structure, maybe destroying it. + * + * @returns New reference count. + * @param pThis The core structure. + */ +static uint32_t rtFsNtfsCore_Release(PRTFSNTFSCORE pThis) +{ + if (pThis) + { + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < 128); + if (cRefs != 0) + return cRefs; + + /* Move from in-use list to unused list. Trim the cache if too big. */ + RTListNodeRemove(&pThis->ListEntry); + + PRTFSNTFSVOL pVol = pThis->pVol; + RTListAppend(&pVol->CoreUnusedHead, &pThis->ListEntry); + if (pVol->cbCoreObjects > RTFSNTFS_MAX_CORE_CACHE_SIZE) + rtFsNtfsIdxVol_TrimCoreObjectCache(pVol); + } + return 0; +} + + +/** + * Retains a refernece to a core structure. + * + * @returns New reference count. + * @param pThis The core structure. + */ +static uint32_t rtFsNtfsCore_Retain(PRTFSNTFSCORE pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + if (cRefs == 1) + { + /* Move from unused list to in-use list. */ + RTListNodeRemove(&pThis->ListEntry); + RTListAppend(&pThis->pVol->CoreInUseHead, &pThis->ListEntry); + } + Assert(cRefs < 128); + return cRefs; +} + + +/** + * Finds an unnamed attribute. + * + * @returns Pointer to the attribute structure if found, NULL if not. + * @param pThis The core object structure to search. + * @param uAttrType The attribute type to find. + */ +static PRTFSNTFSATTR rtFsNtfsCore_FindUnnamedAttribute(PRTFSNTFSCORE pThis, uint32_t uAttrType) +{ + PRTFSNTFSATTR pCurAttr; + RTListForEach(&pThis->AttribHead, pCurAttr, RTFSNTFSATTR, ListEntry) + { + PNTFSATTRIBHDR pAttrHdr = pCurAttr->pAttrHdr; + if ( pAttrHdr->uAttrType == uAttrType + && pAttrHdr->cwcName == 0) + return pCurAttr; + } + return NULL; +} + + +/** + * Finds a named attribute, case insensitive ASCII variant. + * + * @returns Pointer to the attribute structure if found, NULL if not. + * @param pThis The core object structure to search. + * @param uAttrType The attribute type to find. + * @param pszAttrib The attribute name, predefined 7-bit ASCII name. + * @param cchAttrib The length of the attribute. + */ +static PRTFSNTFSATTR rtFsNtfsCore_FindNamedAttributeAscii(PRTFSNTFSCORE pThis, uint32_t uAttrType, + const char *pszAttrib, size_t cchAttrib) +{ + Assert(cchAttrib > 0); + PRTFSNTFSATTR pCurAttr; + RTListForEach(&pThis->AttribHead, pCurAttr, RTFSNTFSATTR, ListEntry) + { + PNTFSATTRIBHDR pAttrHdr = pCurAttr->pAttrHdr; + if ( pAttrHdr->uAttrType == uAttrType + && pAttrHdr->cwcName == cchAttrib + && RTUtf16NICmpAscii(NTFSATTRIBHDR_GET_NAME(pAttrHdr), pszAttrib, cchAttrib) == 0) + return pCurAttr; + } + return NULL; +} + + +/** + * This attribute conversion code is a slightly modified version of rtFsModeFromDos. + * + * @returns IPRT fmode mask. + * @param fFileAttribs The NT file attributes. + * @param pFilename The filename attribute structure, optional. + * @param cbFilename The size of the filename attribute structure. + */ +static RTFMODE rtFsNtfsConvertFileattribsToMode(uint32_t fFileAttribs, PCNTFSATFILENAME pFilename, uint32_t cbFilename) +{ + RTFMODE fMode = (fFileAttribs << RTFS_DOS_SHIFT) & RTFS_DOS_MASK_NT; + if (fFileAttribs & NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT) + fMode |= RTFS_DOS_DIRECTORY; + + /* everything is readable. */ + fMode |= RTFS_UNIX_IRUSR | RTFS_UNIX_IRGRP | RTFS_UNIX_IROTH; + if (fMode & RTFS_DOS_DIRECTORY) + /* directories are executable. */ + fMode |= RTFS_TYPE_DIRECTORY | RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH; + else + { + fMode |= RTFS_TYPE_FILE; + if ( pFilename + && pFilename->cwcFilename >= 4 + && RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= cbFilename) + { + PCRTUTF16 pwcExt = &pFilename->wszFilename[pFilename->cwcFilename - 4]; + if ( *pwcExt++ == '.') + { + /* check for executable extension. */ + if ( (unsigned)pwcExt[0] < 0x7fU + && (unsigned)pwcExt[1] < 0x7fU + && (unsigned)pwcExt[2] < 0x7fU) + { + char szExt[4]; + szExt[0] = RT_C_TO_LOWER(pwcExt[0]); + szExt[1] = RT_C_TO_LOWER(pwcExt[1]); + szExt[2] = RT_C_TO_LOWER(pwcExt[2]); + szExt[3] = '\0'; + if ( !memcmp(szExt, "exe", 4) + || !memcmp(szExt, "bat", 4) + || !memcmp(szExt, "com", 4) + || !memcmp(szExt, "cmd", 4) + || !memcmp(szExt, "btm", 4) + ) + fMode |= RTFS_UNIX_IXUSR | RTFS_UNIX_IXGRP | RTFS_UNIX_IXOTH; + } + } + } + } + + /* Is it really a symbolic link? */ + if ( (fMode & RTFS_DOS_NT_REPARSE_POINT) + && pFilename + && pFilename->u.uReparseTag == RTFSMODE_SYMLINK_REPARSE_TAG) + fMode = (fMode & ~RTFS_TYPE_MASK) | RTFS_TYPE_SYMLINK; + + /* writable? */ + if (!(fMode & RTFS_DOS_READONLY)) + fMode |= RTFS_UNIX_IWUSR | RTFS_UNIX_IWGRP | RTFS_UNIX_IWOTH; + + return fMode; +} + + +/** + * Worker for various QueryInfo methods. + * + * @returns IPRT status code. + * @param pThis The core object structure to return info for. + * @param pAttr The attribute that's being presented. Take the + * allocation and timestamp info from it, if + * non-resident. + * @param pObjInfo Where to return object info. + * @param enmAddAttr What additional info to return. + */ +static int rtFsNtfsCore_QueryInfo(PRTFSNTFSCORE pThis, PRTFSNTFSATTR pAttr, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + /* + * Wipe the structure and fill in common dummy value. + */ + RT_ZERO(*pObjInfo); + switch (enmAddAttr) + { + case RTFSOBJATTRADD_UNIX: + pObjInfo->Attr.u.Unix.uid = NIL_RTUID; + pObjInfo->Attr.u.Unix.gid = NIL_RTGID; + pObjInfo->Attr.u.Unix.cHardlinks = 1; + //pObjInfo->Attr.u.Unix.INodeIdDevice = 0; + pObjInfo->Attr.u.Unix.INodeId = pThis->pMftRec->TreeNode.Key; + //pObjInfo->Attr.u.Unix.fFlags = 0; + //pObjInfo->Attr.u.Unix.GenerationId = 0; + //pObjInfo->Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = NIL_RTUID; + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = NIL_RTGID; + break; + + default: + break; + } + + /* + * Look for the standard information attribute and use that as basis. + */ + uint32_t fFileAttribs; + PRTFSNTFSATTR pStdInfoAttr = rtFsNtfsCore_FindUnnamedAttribute(pThis, NTFS_AT_STANDARD_INFORMATION); + if ( pStdInfoAttr + && pStdInfoAttr->cbResident >= sizeof(NTFSATSTDINFO) ) + { + Assert(!pStdInfoAttr->pAttrHdr->fNonResident); + PCNTFSATSTDINFO pStdInfo = (PCNTFSATSTDINFO)NTFSATTRIBHDR_GET_RES_VALUE_PTR(pStdInfoAttr->pAttrHdr); + RTTimeSpecSetNtTime(&pObjInfo->BirthTime, RT_LE2H_U64(pStdInfo->iCreationTime)); + RTTimeSpecSetNtTime(&pObjInfo->ModificationTime, RT_LE2H_U64(pStdInfo->iLastDataModTime)); + RTTimeSpecSetNtTime(&pObjInfo->ChangeTime, RT_LE2H_U64(pStdInfo->iLastMftModTime)); + RTTimeSpecSetNtTime(&pObjInfo->AccessTime, RT_LE2H_U64(pStdInfo->iLastAccessTime)); + if (enmAddAttr == RTFSOBJATTRADD_UNIX) + { + pObjInfo->Attr.u.Unix.uid = pStdInfo->idOwner; + pObjInfo->Attr.u.Unix.GenerationId = pStdInfo->uFileVersion; + } + else if (enmAddAttr == RTFSOBJATTRADD_UNIX_OWNER) + pObjInfo->Attr.u.UnixOwner.uid = pStdInfo->idOwner; + fFileAttribs = pStdInfo->fFileAttribs; + } + else + { + /** @todo check out the filename record? */ + switch (pAttr->pAttrHdr->uAttrType) + { + default: + AssertFailed(); + RT_FALL_THRU(); + case NTFS_AT_DATA: + fFileAttribs = NTFS_FA_NORMAL; + break; + + case NTFS_AT_INDEX_ROOT: + case NTFS_AT_INDEX_ALLOCATION: + fFileAttribs = NTFS_FA_DIRECTORY; + break; + } + } + + /* + * Take the allocation info from the destilled attribute data. + */ + pObjInfo->cbObject = pAttr->cbValue; + pObjInfo->cbAllocated = pAttr->Extents.cbData; + if ( pAttr->pAttrHdr->fNonResident + && (int64_t)pObjInfo->cbAllocated < (int64_t)RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbAllocated)) + pObjInfo->cbAllocated = RT_LE2H_U64(pAttr->pAttrHdr->u.NonRes.cbAllocated); + + /* + * See if we can find a filename record before we try convert the file attributes to mode. + */ + PCNTFSATFILENAME pFilename = NULL; + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pThis, NTFS_AT_FILENAME); + if ( pFilenameAttr + && pFilenameAttr->cbResident >= RT_UOFFSETOF(NTFSATFILENAME, wszFilename) ) + { + Assert(!pFilenameAttr->pAttrHdr->fNonResident); + pFilename = (PCNTFSATFILENAME)NTFSATTRIBHDR_GET_RES_VALUE_PTR(pFilenameAttr->pAttrHdr); + if (pStdInfoAttr) + fFileAttribs |= pFilename->fFileAttribs; + else + fFileAttribs = pFilename->fFileAttribs; + } + + /* + * Convert attribs to file mode flags. + */ + pObjInfo->Attr.fMode = rtFsNtfsConvertFileattribsToMode(fFileAttribs, pFilename, + pFilenameAttr ? pFilenameAttr->cbResident : 0); + + return VINF_SUCCESS; +} + + + + +/* + * + * File operations. + * File operations. + * File operations. + * + */ + +/** + * Releases a reference to a shared NTFS file structure. + * + * @returns New reference count. + * @param pShared The shared NTFS file structure. + */ +static uint32_t rtFsNtfsFileShrd_Release(PRTFSNTFSFILESHRD pShared) +{ + uint32_t cRefs = ASMAtomicDecU32(&pShared->cRefs); + Assert(cRefs < 64); + if (cRefs == 0) + { + LogFlow(("rtFsNtfsFileShrd_Release(%p): Destroying it\n", pShared)); + Assert(pShared->pData->uObj.pSharedFile == pShared); + pShared->pData->uObj.pSharedFile = NULL; + rtFsNtfsCore_Release(pShared->pData->pCore); + pShared->pData = NULL; + RTMemFree(pShared); + } + return cRefs; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Close(void *pvThis) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + LogFlow(("rtFsNtfsFile_Close(%p/%p)\n", pThis, pThis->pShared)); + + PRTFSNTFSFILESHRD pShared = pThis->pShared; + pThis->pShared = NULL; + if (pShared) + rtFsNtfsFileShrd_Release(pShared); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsNtfsFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + PRTFSNTFSATTR pDataAttr = pThis->pShared->pData; + return rtFsNtfsCore_QueryInfo(pDataAttr->pCore, pDataAttr, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + if (off == -1) + off = pThis->offFile; + else + AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3); + + int rc; + size_t cbRead = pSgBuf->paSegs[0].cbSeg; + if (!pcbRead) + { + rc = rtFsNtfsAttr_Read(pThis->pShared->pData, off, pSgBuf->paSegs[0].pvSeg, cbRead); + if (RT_SUCCESS(rc)) + pThis->offFile = off + cbRead; + Log6(("rtFsNtfsFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc\n", off, pSgBuf->paSegs[0].cbSeg, rc)); + } + else + { + PRTFSNTFSATTR pDataAttr = pThis->pShared->pData; + if ((uint64_t)off >= pDataAttr->cbValue) + { + *pcbRead = 0; + rc = VINF_EOF; + } + else + { + if ((uint64_t)off + cbRead <= pDataAttr->cbValue) + rc = rtFsNtfsAttr_Read(pThis->pShared->pData, off, pSgBuf->paSegs[0].pvSeg, cbRead); + else + { + /* Return VINF_EOF if beyond end-of-file. */ + cbRead = (size_t)(pDataAttr->cbValue - (uint64_t)off); + rc = rtFsNtfsAttr_Read(pThis->pShared->pData, off, pSgBuf->paSegs[0].pvSeg, cbRead); + if (RT_SUCCESS(rc)) + rc = VINF_EOF; + } + if (RT_SUCCESS(rc)) + { + pThis->offFile = off + cbRead; + *pcbRead = cbRead; + } + else + *pcbRead = 0; + } + Log6(("rtFsNtfsFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc *pcbRead=%#x\n", off, pSgBuf->paSegs[0].cbSeg, rc, *pcbRead)); + } + + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + if (off == -1) + off = pThis->offFile; + else + AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3); + + int rc; + PRTFSNTFSATTR pDataAttr = pThis->pShared->pData; + size_t cbToWrite = pSgBuf->paSegs[0].cbSeg; + if ((uint64_t)off + cbToWrite <= pDataAttr->cbValue) + { + rc = rtFsNtfsAttr_Write(pThis->pShared->pData, off, pSgBuf->paSegs[0].pvSeg, cbToWrite); + Log6(("rtFsNtfsFile_Write: off=%#RX64 cbToWrite=%#zx -> %Rrc\n", off, cbToWrite, rc)); + if (RT_SUCCESS(rc)) + pThis->offFile = off + cbToWrite; + if (pcbWritten) + *pcbWritten = RT_SUCCESS(rc) ? cbToWrite : 0; + } + else if ((uint64_t)off < pDataAttr->cbValue) + { + size_t cbWritten = pDataAttr->cbValue - off; + rc = rtFsNtfsAttr_Write(pThis->pShared->pData, off, pSgBuf->paSegs[0].pvSeg, cbWritten); + if (RT_SUCCESS(rc)) + { + Log6(("rtFsNtfsFile_Write: off=%#RX64 cbToWrite=%#zx -> VERR_EOF [EOF: %#RX64, Written: %#zx]\n", + off, cbToWrite, pDataAttr->cbValue, cbWritten)); + pThis->offFile = off + cbWritten; + if (pcbWritten) + *pcbWritten = cbWritten; + rc = VERR_EOF; + } + else + { + Log6(("rtFsNtfsFile_Write: off=%#RX64 cbToWrite=%#zx -> %Rrc [EOF: %#RX64]\n", off, cbToWrite, rc, pDataAttr->cbValue)); + if (pcbWritten) + *pcbWritten = 0; + } + } + else + { + Log6(("rtFsNtfsFile_Write: off=%#RX64 cbToWrite=%#zx -> VERR_EOF [EOF: %#RX64]\n", off, cbToWrite, pDataAttr->cbValue)); + rc = VERR_EOF; + if (pcbWritten) + *pcbWritten = 0; + } + + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Flush(void *pvThis) +{ + RT_NOREF(pvThis); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + *poffActual = pThis->offFile; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsNtfsFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsNtfsFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsNtfsFile_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsNtfsFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + RTFOFF offNew; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offNew = offSeek; + break; + case RTFILE_SEEK_END: + offNew = (RTFOFF)pThis->pShared->pData->cbValue + offSeek; + break; + case RTFILE_SEEK_CURRENT: + offNew = (RTFOFF)pThis->offFile + offSeek; + break; + default: + return VERR_INVALID_PARAMETER; + } + if (offNew >= 0) + { + pThis->offFile = offNew; + *poffActual = offNew; + return VINF_SUCCESS; + } + return VERR_NEGATIVE_SEEK; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsNtfsFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSNTFSFILE pThis = (PRTFSNTFSFILE)pvThis; + *pcbFile = pThis->pShared->pData->cbValue; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSetSize} + */ +static DECLCALLBACK(int) rtFsNtfsFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags) +{ + NOREF(pvThis); NOREF(cbFile); NOREF(fFlags); + return VERR_NOT_IMPLEMENTED; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize} + */ +static DECLCALLBACK(int) rtFsNtfsFile_QueryMaxSize(void *pvThis, uint64_t *pcbMax) +{ + RT_NOREF(pvThis); + *pcbMax = INT64_MAX; + return VINF_SUCCESS; +} + + +/** + * NTFS file operations. + */ +static const RTVFSFILEOPS g_rtFsNtfsFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "NTFS File", + rtFsNtfsFile_Close, + rtFsNtfsFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsNtfsFile_Read, + rtFsNtfsFile_Write, + rtFsNtfsFile_Flush, + NULL /*PollOne*/, + rtFsNtfsFile_Tell, + NULL /*pfnSkip*/, + NULL /*pfnZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + rtFsNtfsFile_SetMode, + rtFsNtfsFile_SetTimes, + rtFsNtfsFile_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsNtfsFile_Seek, + rtFsNtfsFile_QuerySize, + rtFsNtfsFile_SetSize, + rtFsNtfsFile_QueryMaxSize, + RTVFSFILEOPS_VERSION +}; + + +static int rtFsNtfsVol_NewFile(PRTFSNTFSVOL pThis, uint64_t fOpen, PCNTFSIDXENTRYHDR pEntryHdr, const char *pszStreamName, + PRTVFSFILE phVfsFile, PRTERRINFO pErrInfo, const char *pszWhat) +{ + /* + * Get the core structure for the MFT record and check that it's a directory we've got. + */ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_QueryCoreForMftRef(pThis, &pEntryHdr->u.FileMftRec, false /*fRelaxedUsa*/, &pCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + if (!(pCore->pMftRec->pFileRec->fFlags & NTFSRECFILE_F_DIRECTORY)) + { + /* + * Locate the data attribute. + */ + PRTFSNTFSATTR pDataAttr; + if (pszStreamName == NULL) + { + pDataAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_DATA); + if (pDataAttr) + rc = VINF_SUCCESS; + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_A_FILE, "%s: no unamed data stream", pszWhat); + } + else + { + NOREF(pszStreamName); + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_IMPLEMENTED, "%s: named data streams not implemented yet", pszWhat); + pDataAttr = NULL; + } + if (RT_SUCCESS(rc)) + { + /* + * Get a referenced shared file structure, creating it if necessary. + */ + PRTFSNTFSFILESHRD pShared = pDataAttr->uObj.pSharedFile; + if (pShared) + { + uint32_t cRefs = ASMAtomicIncU32(&pShared->cRefs); + Assert(cRefs > 1); NOREF(cRefs); + } + else + { + pShared = (PRTFSNTFSFILESHRD)RTMemAllocZ(sizeof(*pShared)); + if (pShared) + { + pShared->cRefs = 1; + pShared->pData = pDataAttr; + rtFsNtfsCore_Retain(pCore); + pDataAttr->uObj.pSharedFile = pShared; + } + } + if (pShared) + { + /* + * Create the open file instance. + */ + PRTFSNTFSFILE pNewFile; + rc = RTVfsNewFile(&g_rtFsNtfsFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + pNewFile->offFile = 0; + pNewFile->pShared = pShared; + rtFsNtfsCore_Release(pCore); + return VINF_SUCCESS; + } + + rtFsNtfsFileShrd_Release(pShared); + } + else + rc = VERR_NO_MEMORY; + } + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_A_FILE, "%s: fFlags=%#x", pszWhat, pCore->pMftRec->pFileRec->fFlags); + rtFsNtfsCore_Release(pCore); + } + return rc; +} + + + +/* + * + * NTFS directory code. + * NTFS directory code. + * NTFS directory code. + * + */ + +#ifdef LOG_ENABLED + +/** + * Logs an index header and all the entries. + * + * @param pIdxHdr The index header. + * @param cbIndex The number of valid bytes starting with the header. + * @param offIndex The offset of the index header into the parent + * structure. + * @param pszPrefix The log prefix. + * @param uIdxType The index type. + */ +static void rtFsNtfsVol_LogIndexHdrAndEntries(PCNTFSINDEXHDR pIdxHdr, uint32_t cbIndex, uint32_t offIndex, + const char *pszPrefix, uint32_t uIdxType) +{ + if (!LogIs2Enabled()) + return; + + /* + * Do the header. + */ + if (cbIndex <= sizeof(*pIdxHdr)) + { + Log2(("NTFS: %s: Error! Not enough space for the index header! cbIndex=%#x, index head needs %#x\n", + pszPrefix, cbIndex, sizeof(*pIdxHdr))); + return; + } + + Log2(("NTFS: %s: offFirstEntry %#x%s\n", pszPrefix, RT_LE2H_U32(pIdxHdr->offFirstEntry), + RT_LE2H_U32(pIdxHdr->offFirstEntry) >= cbIndex ? " !out-of-bounds!" : "")); + Log2(("NTFS: %s: cbUsed %#x%s\n", pszPrefix, RT_LE2H_U32(pIdxHdr->cbUsed), + RT_LE2H_U32(pIdxHdr->cbUsed) > cbIndex ? " !out-of-bounds!" : "")); + Log2(("NTFS: %s: cbAllocated %#x%s\n", pszPrefix, RT_LE2H_U32(pIdxHdr->cbAllocated), + RT_LE2H_U32(pIdxHdr->cbAllocated) > cbIndex ? " !out-of-bounds!" : "")); + Log2(("NTFS: %s: fFlags %#x (%s%s)\n", pszPrefix, pIdxHdr->fFlags, + pIdxHdr->fFlags & NTFSINDEXHDR_F_INTERNAL ? "internal" : "leaf", + pIdxHdr->fFlags & ~NTFSINDEXHDR_F_INTERNAL ? " !!unknown-flags!!" : "")); + if (pIdxHdr->abReserved[0]) Log2(("NTFS: %s: abReserved[0] %#x\n", pszPrefix, pIdxHdr->abReserved[0])); + if (pIdxHdr->abReserved[1]) Log2(("NTFS: %s: abReserved[0] %#x\n", pszPrefix, pIdxHdr->abReserved[1])); + if (pIdxHdr->abReserved[2]) Log2(("NTFS: %s: abReserved[0] %#x\n", pszPrefix, pIdxHdr->abReserved[2])); + + /* + * The entries. + */ + bool fSeenEnd = false; + uint32_t iEntry = 0; + uint32_t offCurEntry = RT_LE2H_U32(pIdxHdr->offFirstEntry); + while (offCurEntry < cbIndex) + { + if (offCurEntry + sizeof(NTFSIDXENTRYHDR) > cbIndex) + { + Log2(("NTFS: Entry[%#04x]: Out of bounds: %#x LB %#x, max %#x\n", + iEntry, offCurEntry, sizeof(NTFSIDXENTRYHDR), cbIndex)); + break; + } + PCNTFSIDXENTRYHDR pEntryHdr = (PCNTFSIDXENTRYHDR)((uint8_t const *)pIdxHdr + offCurEntry); + Log2(("NTFS: [%#04x]: @%#05x/@%#05x cbEntry=%#x cbKey=%#x fFlags=%#x (%s%s%s)\n", + iEntry, offCurEntry, offCurEntry + offIndex, RT_LE2H_U16(pEntryHdr->cbEntry), RT_LE2H_U16(pEntryHdr->cbKey), + RT_LE2H_U16(pEntryHdr->fFlags), + pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_INTERNAL ? "internal" : "leaf", + pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_END ? " end" : "", + pEntryHdr->fFlags & ~(NTFSIDXENTRYHDR_F_INTERNAL | NTFSIDXENTRYHDR_F_END) ? " !unknown!" : "")); + if (uIdxType == NTFSATINDEXROOT_TYPE_DIR) + Log2(("NTFS: FileMftRec %#RX64 sqn %#x\n", + NTFSMFTREF_GET_IDX(&pEntryHdr->u.FileMftRec), NTFSMFTREF_GET_SEQ(&pEntryHdr->u.FileMftRec) )); + else + Log2(("NTFS: offData=%#x cbData=%#x uReserved=%#x\n", + RT_LE2H_U16(pEntryHdr->u.View.offData), RT_LE2H_U16(pEntryHdr->u.View.cbData), + RT_LE2H_U32(pEntryHdr->u.View.uReserved) )); + if (pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) + Log2(("NTFS: Subnode=%#RX64\n", RT_LE2H_U64(NTFSIDXENTRYHDR_GET_SUBNODE(pEntryHdr)) )); + + if ( RT_LE2H_U16(pEntryHdr->cbKey) >= RT_UOFFSETOF(NTFSATFILENAME, wszFilename) + && uIdxType == NTFSATINDEXROOT_TYPE_DIR) + { + PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)(pEntryHdr + 1); + RTTIMESPEC Spec; + char sz[80]; + Log2(("NTFS: iCreationTime %#RX64 %s\n", RT_LE2H_U64(pFilename->iCreationTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pFilename->iCreationTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastDataModTime %#RX64 %s\n", RT_LE2H_U64(pFilename->iLastDataModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pFilename->iLastDataModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastMftModTime %#RX64 %s\n", RT_LE2H_U64(pFilename->iLastMftModTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pFilename->iLastMftModTime)), sz, sizeof(sz)) )); + Log2(("NTFS: iLastAccessTime %#RX64 %s\n", RT_LE2H_U64(pFilename->iLastAccessTime), + RTTimeSpecToString(RTTimeSpecSetNtTime(&Spec, RT_LE2H_U64(pFilename->iLastAccessTime)), sz, sizeof(sz)) )); + Log2(("NTFS: cbAllocated %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pFilename->cbAllocated), RT_LE2H_U64(pFilename->cbAllocated))); + Log2(("NTFS: cbData %#RX64 (%Rhcb)\n", + RT_LE2H_U64(pFilename->cbData), RT_LE2H_U64(pFilename->cbData))); + Log2(("NTFS: fFileAttribs %#RX32\n", RT_LE2H_U32(pFilename->fFileAttribs) )); + if (RT_LE2H_U32(pFilename->fFileAttribs) & NTFS_FA_REPARSE_POINT) + Log2(("NTFS: uReparseTag %#RX32\n", RT_LE2H_U32(pFilename->u.uReparseTag) )); + else + Log2(("NTFS: cbPackedEas %#RX16\n", RT_LE2H_U16(pFilename->u.cbPackedEas) )); + Log2(("NTFS: cwcFilename %#x\n", pFilename->cwcFilename)); + Log2(("NTFS: fFilenameType %#x\n", pFilename->fFilenameType)); + if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) <= RT_LE2H_U16(pEntryHdr->cbKey)) + Log2(("NTFS: wszFilename '%.*ls'\n", pFilename->cwcFilename, pFilename->wszFilename )); + else + Log2(("NTFS: Error! Truncated filename!!\n")); + } + + + /* next */ + iEntry++; + offCurEntry += RT_LE2H_U16(pEntryHdr->cbEntry); + fSeenEnd = RT_BOOL(pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_END); + if (fSeenEnd || RT_LE2H_U16(pEntryHdr->cbEntry) < sizeof(*pEntryHdr)) + break; + } + if (!fSeenEnd) + Log2(("NTFS: %s: Warning! Missing NTFSIDXENTRYHDR_F_END node!\n", pszPrefix)); +} + +# if 0 /* unused */ +static void rtFsNtfsVol_LogIndexNode(PCNTFSATINDEXALLOC pIdxNode, uint32_t cbIdxNode, uint32_t uType) +{ + if (!LogIs2Enabled()) + return; + if (cbIdxNode < sizeof(*pIdxNode)) + Log2(("NTFS: Index Node: Error! Too small! cbIdxNode=%#x, index node needs %#x\n", cbIdxNode, sizeof(*pIdxNode))); + else + { + Log2(("NTFS: Index Node: uMagic %#x\n", RT_LE2H_U32(pIdxNode->RecHdr.uMagic))); + Log2(("NTFS: Index Node: UpdateSeqArray %#x L %#x\n", + RT_LE2H_U16(pIdxNode->RecHdr.offUpdateSeqArray), RT_LE2H_U16(pIdxNode->RecHdr.cUpdateSeqEntries) )); + Log2(("NTFS: Index Node: uLsn %#RX64\n", RT_LE2H_U64(pIdxNode->uLsn) )); + Log2(("NTFS: Index Node: iSelfAddress %#RX64\n", RT_LE2H_U64(pIdxNode->iSelfAddress) )); + if (pIdxNode->RecHdr.uMagic == NTFSREC_MAGIC_INDEX_ALLOC) + rtFsNtfsVol_LogIndexHdrAndEntries(&pIdxNode->Hdr, cbIdxNode - RT_UOFFSETOF(NTFSATINDEXALLOC, Hdr), + RT_UOFFSETOF(NTFSATINDEXALLOC, Hdr), "Index Node Hdr", uType); + else + Log2(("NTFS: Index Node: !Error! Invalid magic!\n")); + } +} +# endif + +/** + * Logs a index root structure and what follows (index header + entries). + * + * @param pIdxRoot The index root. + * @param cbIdxRoot Number of valid bytes starting with @a pIdxRoot. + */ +static void rtFsNtfsVol_LogIndexRoot(PCNTFSATINDEXROOT pIdxRoot, uint32_t cbIdxRoot) +{ + if (!LogIs2Enabled()) + return; + if (cbIdxRoot < sizeof(*pIdxRoot)) + Log2(("NTFS: Index Root: Error! Too small! cbIndex=%#x, index head needs %#x\n", cbIdxRoot, sizeof(*pIdxRoot))); + else + { + Log2(("NTFS: Index Root: cbIdxRoot %#x\n", cbIdxRoot)); + Log2(("NTFS: Index Root: uType %#x %s\n", RT_LE2H_U32(pIdxRoot->uType), + pIdxRoot->uType == NTFSATINDEXROOT_TYPE_VIEW ? "view" + : pIdxRoot->uType == NTFSATINDEXROOT_TYPE_DIR ? "directory" : "!unknown!")); + Log2(("NTFS: Index Root: uCollationRules %#x %s\n", RT_LE2H_U32(pIdxRoot->uCollationRules), + pIdxRoot->uCollationRules == NTFS_COLLATION_BINARY ? "binary" + : pIdxRoot->uCollationRules == NTFS_COLLATION_FILENAME ? "filename" + : pIdxRoot->uCollationRules == NTFS_COLLATION_UNICODE_STRING ? "unicode-string" + : pIdxRoot->uCollationRules == NTFS_COLLATION_UINT32 ? "uint32" + : pIdxRoot->uCollationRules == NTFS_COLLATION_SID ? "sid" + : pIdxRoot->uCollationRules == NTFS_COLLATION_UINT32_PAIR ? "uint32-pair" + : pIdxRoot->uCollationRules == NTFS_COLLATION_UINT32_SEQ ? "uint32-sequence" : "!unknown!")); + Log2(("NTFS: Index Root: cbIndexNode %#x\n", RT_LE2H_U32(pIdxRoot->cbIndexNode) )); + Log2(("NTFS: Index Root: cAddressesPerIndexNode %#x => cbNodeAddressingUnit=%#x\n", + pIdxRoot->cAddressesPerIndexNode, RT_LE2H_U32(pIdxRoot->cbIndexNode) / RT_MAX(1, pIdxRoot->cAddressesPerIndexNode) )); + if (pIdxRoot->abReserved[0]) Log2(("NTFS: Index Root: abReserved[0] %#x\n", pIdxRoot->abReserved[0])); + if (pIdxRoot->abReserved[1]) Log2(("NTFS: Index Root: abReserved[1] %#x\n", pIdxRoot->abReserved[1])); + if (pIdxRoot->abReserved[2]) Log2(("NTFS: Index Root: abReserved[2] %#x\n", pIdxRoot->abReserved[2])); + + rtFsNtfsVol_LogIndexHdrAndEntries(&pIdxRoot->Hdr, cbIdxRoot - RT_UOFFSETOF(NTFSATINDEXROOT, Hdr), + RT_UOFFSETOF(NTFSATINDEXROOT, Hdr), "Index Root Hdr", pIdxRoot->uType); + } +} + +#endif /* LOG_ENABLED */ + + +/** + * Validates an index header. + * + * @returns IPRT status code. + * @param pRootInfo Pointer to the index root info. + * @param pNodeInfo Pointer to the node info structure to load. + * @param pIndexHdr Pointer to the index header. + * @param cbIndex Size of the index. + * @param pErrInfo Where to return extra error info. + * @param pszWhat Error prefix. + */ +static int rtFsNtfsVol_LoadIndexNodeInfo(PCRTFSNTFSIDXROOTINFO pRootInfo, PRTFSNTFSIDXNODEINFO pNodeInfo, PCNTFSINDEXHDR pIndexHdr, + uint32_t cbIndex, PRTERRINFO pErrInfo, const char *pszWhat) +{ + uint32_t const cbMinIndex = sizeof(*pIndexHdr) + sizeof(NTFSIDXENTRYHDR); + if (cbIndex < cbMinIndex) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Not enough room for the index header and one entry header! cbIndex=%#x (cbMinIndex=%#x)", + pszWhat, cbIndex, cbMinIndex); + uint32_t const cbAllocated = RT_LE2H_U32(pIndexHdr->cbAllocated); + if ( cbAllocated > cbIndex + || cbAllocated < cbMinIndex + || (cbAllocated & 7) ) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Bogus index allocation size: %#x (min %#x, max %#x, 8 byte aligned)", + pszWhat, cbAllocated, cbMinIndex, cbIndex); + uint32_t const cbUsed = RT_LE2H_U32(pIndexHdr->cbUsed); + if ( cbUsed > cbAllocated + || cbUsed < cbMinIndex + || (cbUsed & 7) ) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Bogus index used size: %#x (min %#x, max %#x, 8 byte aligned)", + pszWhat, cbUsed, cbMinIndex, cbAllocated); + uint32_t const offFirstEntry = RT_LE2H_U32(pIndexHdr->offFirstEntry); + if ( offFirstEntry < sizeof(*pIndexHdr) + || ( offFirstEntry > cbUsed - sizeof(NTFSIDXENTRYHDR) + && offFirstEntry != cbUsed /* empty dir */) + || (offFirstEntry & 7) ) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Bogus first entry offset: %#x (min %#x, max %#x, 8 byte aligned)", + pszWhat, offFirstEntry, sizeof(*pIndexHdr), cbUsed - sizeof(NTFSIDXENTRYHDR)); + + /* + * The index entries. + */ + uint32_t const uType = pRootInfo->pRoot->uType; + uint32_t offEntry = offFirstEntry; + uint32_t iEntry = 0; + for (;;) + { + if (offEntry + sizeof(NTFSIDXENTRYHDR) > cbUsed) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Entry #%u is out of bound: offset %#x (cbUsed=%#x)", + pszWhat, iEntry, offEntry, cbUsed); + PCNTFSIDXENTRYHDR pEntryHdr = (PCNTFSIDXENTRYHDR)((uint8_t const *)pIndexHdr + offEntry); + uint16_t const cbEntry = RT_LE2H_U16(pEntryHdr->cbEntry); + uint32_t const cbSubnodeAddr = (pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_INTERNAL ? sizeof(int64_t) : 0); + uint32_t const cbMinEntry = sizeof(*pEntryHdr) + cbSubnodeAddr; + if ( cbEntry < cbMinEntry + || offEntry + cbEntry > cbUsed + || (cbEntry & 7) ) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Entry #%u has a bogus size: %#x (min %#x, max %#x, 8 byte aligned)", + pszWhat, iEntry, cbEntry, cbMinEntry, cbUsed - offEntry); + + uint32_t const cbMaxKey = cbEntry - sizeof(*pEntryHdr) - cbSubnodeAddr; + uint32_t const cbMinKey = (pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_END) ? 0 + : uType == NTFSATINDEXROOT_TYPE_DIR ? RT_UOFFSETOF(NTFSATFILENAME, wszFilename) : 0; + uint16_t const cbKey = RT_LE2H_U16(pEntryHdr->cbKey); + if ( cbKey < cbMinKey + || cbKey > cbMaxKey) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Entry #%u has a bogus key size: %#x (min %#x, max %#x)", + pszWhat, iEntry, cbKey, cbMinKey, cbMaxKey); + if ( !(pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_END) + && uType == NTFSATINDEXROOT_TYPE_DIR) + { + PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)(pEntryHdr + 1); + if (RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]) > cbKey) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Entry #%u filename is out of bounds: cwcFilename=%#x -> %#x key, max %#x", + pszWhat, iEntry, pFilename->cwcFilename, + RT_UOFFSETOF_DYN(NTFSATFILENAME, wszFilename[pFilename->cwcFilename]), cbKey); + } + + if (pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) + { + int64_t iSubnode = NTFSIDXENTRYHDR_GET_SUBNODE(pEntryHdr); + if ( (uint64_t)iSubnode >= pRootInfo->uEndNodeAddresses + || (iSubnode & pRootInfo->fNodeAddressMisalign) ) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Entry #%u has bogus subnode address: %#RX64 (max %#RX64, misalign %#x)", + pszWhat, iEntry, iSubnode, pRootInfo->uEndNodeAddresses, + pRootInfo->fNodeAddressMisalign); + } + + /* Advance. */ + offEntry += cbEntry; + iEntry++; + if (pEntryHdr->fFlags & NTFSIDXENTRYHDR_F_END) + break; + } + + /* + * Popuplate the node info structure. + */ + pNodeInfo->pIndexHdr = pIndexHdr; + pNodeInfo->fInternal = RT_BOOL(pIndexHdr->fFlags & NTFSINDEXHDR_F_INTERNAL); + if (pNodeInfo != &pRootInfo->NodeInfo) + pNodeInfo->pVol = pRootInfo->NodeInfo.pVol; + pNodeInfo->cEntries = iEntry; + pNodeInfo->papEntries = (PCNTFSIDXENTRYHDR *)RTMemAlloc(iEntry * sizeof(pNodeInfo->papEntries[0])); + if (pNodeInfo->papEntries) + { + PCNTFSIDXENTRYHDR pEntryHdr = NTFSINDEXHDR_GET_FIRST_ENTRY(pIndexHdr); + for (iEntry = 0; iEntry < pNodeInfo->cEntries; iEntry++) + { + pNodeInfo->papEntries[iEntry] = pEntryHdr; + pEntryHdr = NTFSIDXENTRYHDR_GET_NEXT(pEntryHdr); + } + return VINF_SUCCESS; + } + return VERR_NO_MEMORY; +} + + +/** + * Creates a shared directory structure given a MFT core. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param pCore The MFT core structure that's allegedly a directory. + * (No reference consumed of course.) + * @param ppSharedDir Where to return the pointer to the new shared directory + * structure on success. (Referenced.) + * @param pErrInfo Where to return additions error info. Optional. + * @param pszWhat Context prefix for error reporting and logging. + */ +static int rtFsNtfsVol_NewSharedDirFromCore(PRTFSNTFSVOL pThis, PRTFSNTFSCORE pCore, PRTFSNTFSDIRSHRD *ppSharedDir, + PRTERRINFO pErrInfo, const char *pszWhat) +{ + *ppSharedDir = NULL; + + /* + * Look for the index root and validate it. + */ + PRTFSNTFSATTR pRootAttr = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_INDEX_ROOT, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + if (!pRootAttr) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "%s: Found no INDEX_ROOT attribute named $I30", pszWhat); + if (pRootAttr->pAttrHdr->fNonResident) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "%s: INDEX_ROOT is is not resident", pszWhat); + if (pRootAttr->cbResident < sizeof(NTFSATINDEXROOT)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "%s: INDEX_ROOT is too small: %#x, min %#x ", + pszWhat, pRootAttr->cbResident, sizeof(pRootAttr->cbResident)); + + PCNTFSATINDEXROOT pIdxRoot = (PCNTFSATINDEXROOT)NTFSATTRIBHDR_GET_RES_VALUE_PTR(pRootAttr->pAttrHdr); +#ifdef LOG_ENABLED + rtFsNtfsVol_LogIndexRoot(pIdxRoot, pRootAttr->cbResident); +#endif + if (pIdxRoot->uType != NTFSATINDEXROOT_TYPE_DIR) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Wrong INDEX_ROOT type for a directory: %#x, expected %#x", + pszWhat, RT_LE2H_U32(pIdxRoot->uType), RT_LE2H_U32_C(NTFSATINDEXROOT_TYPE_DIR)); + if (pIdxRoot->uCollationRules != NTFS_COLLATION_FILENAME) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Wrong collation rules for a directory: %#x, expected %#x", + pszWhat, RT_LE2H_U32(pIdxRoot->uCollationRules), RT_LE2H_U32_C(NTFS_COLLATION_FILENAME)); + uint32_t cbIndexNode = RT_LE2H_U32(pIdxRoot->cbIndexNode); + if (cbIndexNode < 512 || cbIndexNode > _64K || !RT_IS_POWER_OF_TWO(cbIndexNode)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Bogus index node size: %#x (expected power of two between 512 and 64KB)", + pszWhat, cbIndexNode); + unsigned const cNodeAddressShift = cbIndexNode >= pThis->cbCluster ? pThis->cClusterShift : 9; + if (((uint32_t)pIdxRoot->cAddressesPerIndexNode << cNodeAddressShift) != cbIndexNode) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: Bogus addresses per index node value: %#x (cbIndexNode=%#x cNodeAddressShift=%#x)", + pszWhat, pIdxRoot->cAddressesPerIndexNode, cbIndexNode, cNodeAddressShift); + AssertReturn(pRootAttr->uObj.pSharedDir == NULL, VERR_INTERNAL_ERROR_3); + + /* + * Check for the node data stream and related allocation bitmap. + */ + PRTFSNTFSATTR pIndexAlloc = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_INDEX_ALLOCATION, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + PRTFSNTFSATTR pIndexBitmap = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_BITMAP, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + if (pIndexAlloc && !pIndexBitmap) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: INDEX_ALLOCATION attribute without BITMAP", pszWhat); + if (!pIndexAlloc && pIndexBitmap) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: BITMAP attribute without INDEX_ALLOCATION", pszWhat); + uint64_t uNodeAddressEnd = 0; + if (pIndexAlloc) + { + if (!pIndexAlloc->pAttrHdr->fNonResident) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, "%s: INDEX_ALLOCATION is resident", pszWhat); + if (pIndexAlloc->cbValue & (cbIndexNode - 1)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: INDEX_ALLOCATION size isn't aligned on node boundrary: %#RX64, cbIndexNode=%#x", + pszWhat, pIndexAlloc->cbValue, cbIndexNode); + uint64_t const cNodes = pIndexAlloc->cbValue / cbIndexNode; + if (pIndexBitmap->cbValue < (RT_ALIGN_64(cNodes, 64) >> 3)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "%s: BITMAP size does not match INDEX_ALLOCATION: %#RX64, expected min %#RX64 (cbIndexNode=%#x, cNodes=%#RX64)", + pszWhat, pIndexBitmap->cbValue, RT_ALIGN_64(cNodes, 64) >> 3, cbIndexNode, cNodes); + uNodeAddressEnd = cNodes * pIdxRoot->cAddressesPerIndexNode; + } + + /* + * Create a directory instance. + */ + PRTFSNTFSDIRSHRD pNewDir = (PRTFSNTFSDIRSHRD)RTMemAllocZ(sizeof(*pNewDir)); + if (!pNewDir) + return VERR_NO_MEMORY; + + pNewDir->cRefs = 1; + rtFsNtfsCore_Retain(pCore); + pNewDir->RootInfo.pRootAttr = pRootAttr; + pNewDir->RootInfo.pRoot = pIdxRoot; + pNewDir->RootInfo.pAlloc = pIndexAlloc; + pNewDir->RootInfo.uEndNodeAddresses = uNodeAddressEnd; + pNewDir->RootInfo.cNodeAddressByteShift = cNodeAddressShift; + pNewDir->RootInfo.fNodeAddressMisalign = pIdxRoot->cAddressesPerIndexNode - 1; + pNewDir->RootInfo.NodeInfo.pVol = pThis; + + /* + * Finally validate the index header and entries. + */ + int rc = rtFsNtfsVol_LoadIndexNodeInfo(&pNewDir->RootInfo, &pNewDir->RootInfo.NodeInfo, &pIdxRoot->Hdr, + pRootAttr->cbResident - RT_UOFFSETOF(NTFSATINDEXROOT, Hdr), pErrInfo, pszWhat); + if (RT_SUCCESS(rc)) + { + *ppSharedDir = pNewDir; + pRootAttr->uObj.pSharedDir = pNewDir; + return VINF_SUCCESS; + } + RTMemFree(pNewDir); + rtFsNtfsCore_Release(pCore); + return rc; +} + + +/** + * Gets a shared directory structure given an MFT record reference, creating a + * new one if necessary. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param pDirMftRef The MFT record reference to follow. + * @param ppSharedDir Where to return the shared directory structure + * (referenced). + * @param pErrInfo Where to return error details. Optional. + * @param pszWhat Error/log prefix. + */ +static int rtFsNtfsVol_QueryOrCreateSharedDirByMftRef(PRTFSNTFSVOL pThis, PCNTFSMFTREF pDirMftRef, + PRTFSNTFSDIRSHRD *ppSharedDir, PRTERRINFO pErrInfo, const char *pszWhat) +{ + /* + * Get the core structure for the MFT record and check that it's a directory we've got. + */ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_QueryCoreForMftRef(pThis, pDirMftRef, false /*fRelaxedUsa*/, &pCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + if (pCore->pMftRec->pFileRec->fFlags & NTFSRECFILE_F_DIRECTORY) + { + /* + * Locate the $I30 root index attribute as we associate the + * pointer to the shared directory pointer with it. + */ + PRTFSNTFSATTR pRootAttr = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_INDEX_ROOT, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + if (pRootAttr) + { + if (!pRootAttr->uObj.pSharedDir) + rc = rtFsNtfsVol_NewSharedDirFromCore(pThis, pCore, ppSharedDir, pErrInfo, pszWhat); + else + { + Assert(pRootAttr->uObj.pSharedDir->RootInfo.pRootAttr->pCore == pCore); + rtFsNtfsDirShrd_Retain(pRootAttr->uObj.pSharedDir); + *ppSharedDir = pRootAttr->uObj.pSharedDir; + } + } + else + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_NOT_A_DIRECTORY, + "%s: Found INDEX_ROOT attribute named $I30, even though NTFSRECFILE_F_DIRECTORY is set", + pszWhat); + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_A_DIRECTORY, "%s: fFlags=%#x", pszWhat, pCore->pMftRec->pFileRec->fFlags); + rtFsNtfsCore_Release(pCore); + } + return rc; +} + + +/** + * Frees resource kept by an index node info structure. + * + * @param pNodeInfo The index node info structure to delelte. + */ +static void rtFsNtfsIdxNodeInfo_Delete(PRTFSNTFSIDXNODEINFO pNodeInfo) +{ + RTMemFree(pNodeInfo->papEntries); + pNodeInfo->papEntries = NULL; + pNodeInfo->pNode = NULL; + pNodeInfo->pVol = NULL; +} + + +/** + * Gets or loads the specified subnode. + * + * @returns IPRT status code. + * @param pRootInfo The index root info. + * @param iNode The address of the node being queried. + * @param ppNode Where to return the referenced pointer to the node. + */ +static int rtFsNtfsIdxRootInfo_QueryNode(PRTFSNTFSIDXROOTINFO pRootInfo, int64_t iNode, PRTFSNTFSIDXNODE *ppNode) +{ + PRTFSNTFSVOL pVol = pRootInfo->NodeInfo.pVol; + + /* + * A bit of paranoia. These has been checked already when loading, but it + * usually doesn't hurt too much to be careful. + */ + AssertReturn(!(iNode & pRootInfo->fNodeAddressMisalign), VERR_VFS_BOGUS_OFFSET); + AssertReturn((uint64_t)iNode < pRootInfo->uEndNodeAddresses, VERR_VFS_BOGUS_OFFSET); + AssertReturn(pRootInfo->pAlloc, VERR_VFS_BOGUS_OFFSET); + + /* + * First translate the node address to a disk byte offset and check the index node cache. + */ + uint64_t offNode = iNode << pRootInfo->cNodeAddressByteShift; + uint64_t offNodeOnDisk = rtFsNtfsAttr_OffsetToDisk(pRootInfo->pAlloc, offNode, NULL); + PRTFSNTFSIDXNODE pNode = (PRTFSNTFSIDXNODE)RTAvlU64Get(&pVol->IdxNodeCacheRoot, offNodeOnDisk); + if (pNode) + { + rtFsNtfsIdxNode_Retain(pNode); + *ppNode = pNode; + return VINF_SUCCESS; + } + + /* + * Need to create a load a new node. + */ + pNode = (PRTFSNTFSIDXNODE)RTMemAllocZ(sizeof(*pNode)); + AssertReturn(pNode, VERR_NO_MEMORY); + + pNode->TreeNode.Key = offNodeOnDisk; + uint32_t cbIndexNode = RT_LE2H_U32(pRootInfo->pRoot->cbIndexNode); + pNode->cbCost = sizeof(*pNode) + cbIndexNode; + pNode->cRefs = 1; + pNode->pNode = (PNTFSATINDEXALLOC)RTMemAllocZ(cbIndexNode); + int rc; + if (pNode->pNode) + { + rc = rtFsNtfsAttr_Read(pRootInfo->pAlloc, offNode, pNode->pNode, cbIndexNode); + if (RT_SUCCESS(rc)) + { + rc = VERR_VFS_BOGUS_FORMAT; + if (pNode->pNode->RecHdr.uMagic != NTFSREC_MAGIC_INDEX_ALLOC) + LogRel(("rtFsNtfsIdxRootInfo_QueryNode(iNode=%#x): Invalid node magic %#x -> VERR_VFS_BOGUS_FORMAT\n", + iNode, RT_LE2H_U32(pNode->pNode->RecHdr.uMagic) )); + else if ((int64_t)RT_LE2H_U64(pNode->pNode->iSelfAddress) != iNode) + LogRel(("rtFsNtfsIdxRootInfo_QueryNode(iNode=%#x): Wrong iSelfAddress: %#x -> VERR_VFS_BOGUS_FORMAT\n", + iNode, RT_LE2H_U64(pNode->pNode->iSelfAddress) )); + else + { + rc = rtFsNtfsRec_DoMultiSectorFixups(&pNode->pNode->RecHdr, cbIndexNode, false /*fRelaxedUsa*/, NULL /*pErrInfo*/); + if (RT_SUCCESS(rc)) + { + /* + * Validate/parse it + */ +#ifdef LOG_ENABLED + rtFsNtfsVol_LogIndexHdrAndEntries(&pNode->pNode->Hdr, + cbIndexNode - RT_UOFFSETOF(NTFSATINDEXALLOC, Hdr), + RT_UOFFSETOF(NTFSATINDEXALLOC, Hdr), "index node", + pRootInfo->pRoot->uType); +#endif + rc = rtFsNtfsVol_LoadIndexNodeInfo(pRootInfo, &pNode->NodeInfo, &pNode->pNode->Hdr, + cbIndexNode - RT_UOFFSETOF(NTFSATINDEXALLOC, Hdr), + NULL /*pErrInfo*/, "index node"); + if (RT_SUCCESS(rc)) + { + pNode->cbCost += pNode->NodeInfo.cEntries * sizeof(pNode->NodeInfo.papEntries[0]); + + /* + * Insert it into the cache, trimming the cache if necessary. + */ + bool fInsertOkay = RTAvlU64Insert(&pVol->IdxNodeCacheRoot, &pNode->TreeNode); + Assert(fInsertOkay); + if (fInsertOkay) + { + pVol->cIdxNodes += 1; + pVol->cbIdxNodes += pNode->cbCost; + if (pVol->cbIdxNodes > RTFSNTFS_MAX_CORE_CACHE_SIZE) + rtFsNtfsIdxVol_TrimIndexNodeCache(pVol); + + *ppNode = pNode; + return VINF_SUCCESS; + } + } + } + } + } + + RTMemFree(pNode->pNode); + pNode->pNode = NULL; + } + else + rc = VERR_NO_MEMORY; + RTMemFree(pNode); + return rc; +} + + +/** + * Frees resource kept by an index root info structure. + * + * @param pRootInfo The index root info structure to delete. + */ +static void rtFsNtfsIdxRootInfo_Delete(PRTFSNTFSIDXROOTINFO pRootInfo) +{ + rtFsNtfsIdxNodeInfo_Delete(&pRootInfo->NodeInfo); + pRootInfo->pRootAttr->uObj.pSharedDir = NULL; + rtFsNtfsCore_Release(pRootInfo->pRootAttr->pCore); + pRootInfo->pRootAttr = NULL; + pRootInfo->pAlloc = NULL; + pRootInfo->pRoot = NULL; +} + + +/** + * Destroys a shared directory structure when the reference count reached zero. + * + * @returns zero + * @param pThis The shared directory structure to destroy. + */ +static uint32_t rtFsNtfsDirShrd_Destroy(PRTFSNTFSDIRSHRD pThis) +{ + rtFsNtfsIdxRootInfo_Delete(&pThis->RootInfo); + RTMemFree(pThis); + return 0; +} + + +/** + * Releases a references to a shared directory structure. + * + * @returns New reference count. + * @param pThis The shared directory structure. + */ +static uint32_t rtFsNtfsDirShrd_Release(PRTFSNTFSDIRSHRD pThis) +{ + uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs); + Assert(cRefs < 4096); + if (cRefs > 0) + return cRefs; + return rtFsNtfsDirShrd_Destroy(pThis); +} + + +/** + * Retains a references to a shared directory structure. + * + * @returns New reference count. + * @param pThis The shared directory structure. + */ +static uint32_t rtFsNtfsDirShrd_Retain(PRTFSNTFSDIRSHRD pThis) +{ + uint32_t cRefs = ASMAtomicIncU32(&pThis->cRefs); + Assert(cRefs > 1); + Assert(cRefs < 4096); + return cRefs; +} + + +/** + * Compares the two filenames in an case insentivie manner. + * + * @retval -1 if the first filename comes first + * @retval 0 if equal + * @retval 1 if the second filename comes first. + * + * @param pwszUpper1 The first filename, this has been uppercase already. + * @param cwcUpper1 The length of the first filename. + * @param pawcFilename2 The second filename to compare it with. Not zero + * terminated. + * @param cwcFilename2 The length of the second filename. + * @param pawcUpcase The uppercase table. 64K entries. + */ +static int rtFsNtfsIdxComp_Filename(PCRTUTF16 pwszUpper1, uint8_t cwcUpper1, PCRTUTF16 pawcFilename2, uint8_t cwcFilename2, + PCRTUTF16 const pawcUpcase) +{ + while (cwcUpper1 > 0 && cwcFilename2 > 0) + { + RTUTF16 uc1 = *pwszUpper1++; + RTUTF16 uc2 = *pawcFilename2++; + if (uc1 != uc2) + { + uc2 = pawcUpcase[uc2]; + if (uc1 != uc2) + return uc1 < uc2 ? -1 : 1; + } + + /* Decrement the lengths and loop. */ + cwcUpper1--; + cwcFilename2--; + } + + if (!cwcUpper1) + { + if (!cwcFilename2) + return 0; + return -1; + } + return 1; +} + + +/** + * Look up a name in the directory. + * + * @returns IPRT status code. + * @param pShared The shared directory structure. + * @param pszEntry The name to lookup. + * @param ppFilename Where to return the pointer to the filename structure. + * @param ppEntryHdr Where to return the poitner to the entry header + * structure. + * @param ppNode Where to return the pointer to the node the filename + * structure resides in. This must be released. It will + * be set to NULL if the name was found in the root node. + */ +static int rtFsNtfsDirShrd_Lookup(PRTFSNTFSDIRSHRD pShared, const char *pszEntry, + PCNTFSATFILENAME *ppFilename, PCNTFSIDXENTRYHDR *ppEntryHdr, PRTFSNTFSIDXNODE *ppNode) +{ + PRTFSNTFSVOL pVol = pShared->RootInfo.NodeInfo.pVol; + + *ppFilename = NULL; + *ppEntryHdr = NULL; + *ppNode = NULL; + /** @todo do streams (split on ':') */ + + /* + * Convert the filename to UTF16 and uppercase. + */ + PCRTUTF16 const pawcUpcase = pVol->pawcUpcase; + RTUTF16 wszFilename[256+4]; + PRTUTF16 pwszDst = wszFilename; + PRTUTF16 pwszEnd = &wszFilename[255]; + const char *pszSrc = pszEntry; + for (;;) + { + RTUNICP uc; + int rc = RTStrGetCpEx(&pszSrc, &uc); + if (RT_SUCCESS(rc)) + { + if (uc != 0) + { + if (uc < _64K) + uc = pawcUpcase[uc]; + pwszDst = RTUtf16PutCp(pwszDst, uc); + if ((uintptr_t)pwszDst <= (uintptr_t)pwszEnd) + { /* likely */ } + else + { + Log(("rtFsNtfsDirShrd_Lookup: Filename too long '%s'\n", pszEntry)); + return VERR_FILENAME_TOO_LONG; + } + } + else + { + *pwszDst = '\0'; + break; + } + } + else + { + Log(("rtFsNtfsDirShrd_Lookup: Invalid UTF-8 encoding (%Rrc): %.*Rhxs\n", rc, strlen(pszEntry), pszEntry)); + return rc; + } + } + uint8_t const cwcFilename = (uint8_t)(pwszDst - wszFilename); + + /* + * Do the tree traversal. + */ + PRTFSNTFSIDXROOTINFO pRootInfo = &pShared->RootInfo; + PRTFSNTFSIDXNODEINFO pNodeInfo = &pRootInfo->NodeInfo; + PRTFSNTFSIDXNODE pNode = NULL; + for (;;) + { + /* + * Search it. + */ + PCNTFSIDXENTRYHDR *papEntries = pNodeInfo->papEntries; + uint32_t iEnd = pNodeInfo->cEntries; + AssertReturn(iEnd > 0, VERR_INTERNAL_ERROR_3); + + /* Exclude the end node from the serach as it doesn't have any key. */ + if (papEntries[iEnd - 1]->fFlags & NTFSIDXENTRYHDR_F_END) + iEnd--; + + uint32_t iEntry; + if (1 /*iEnd < 8*/ ) + { + if (iEnd > 0) + { + for (iEntry = 0; iEntry < iEnd; iEntry++) + { + PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)(papEntries[iEntry] + 1); + int iDiff = rtFsNtfsIdxComp_Filename(wszFilename, cwcFilename, pFilename->wszFilename, + pFilename->cwcFilename, pawcUpcase); + if (iDiff > 0) + { /* likely */ } + else if (iDiff == 0) + { + *ppNode = pNode; + *ppEntryHdr = papEntries[iEntry]; + *ppFilename = pFilename; + LogFlow(("rtFsNtfsDirShrd_Lookup(%s): Found it! (iEntry=%u, FileMftRec=%#RX64 sqn %#x)\n", + pszEntry, iEntry, NTFSMFTREF_GET_IDX(&papEntries[iEntry]->u.FileMftRec), + NTFSMFTREF_GET_SEQ(&papEntries[iEntry]->u.FileMftRec) )); + return VINF_SUCCESS; + } + else + break; + } + } + else + iEntry = iEnd; + } + /* else: implement binary search */ + + /* + * Decend thru node iEntry. + * + * We could be bold and ASSUME that there is always an END node, but we're + * playing safe for now. + */ + if (iEnd < pNodeInfo->cEntries) + { + PCNTFSIDXENTRYHDR pEntry = papEntries[iEntry]; + if (pEntry->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) + { + int64_t iSubnode = NTFSIDXENTRYHDR_GET_SUBNODE(pEntry); + rtFsNtfsIdxNode_Release(pNode); + int rc = rtFsNtfsIdxRootInfo_QueryNode(pRootInfo, iSubnode, &pNode); + if (RT_SUCCESS(rc)) + { + pNodeInfo = &pNode->NodeInfo; + continue; + } + LogFlow(("rtFsNtfsDirShrd_Lookup(%s): rtFsNtfsIdxRootInfo_QueryNode(%#RX64) error %Rrc!\n", + pszEntry, iSubnode, rc)); + return rc; + } + } + rtFsNtfsIdxNode_Release(pNode); + LogFlow(("rtFsNtfsDirShrd_Lookup(%s): Not found! (#2)\n", pszEntry)); + return VERR_FILE_NOT_FOUND; + } + + /* not reached */ +} + + +/** + * Gets the shared directory structure for the parent. + * + * @returns IPRT status code. + * @param pThis The directory which parent we want. + * @param ppDotDot Where to return the referenced shared parent dir + * structure. + * + */ +static int rtFsNtfsDirShrd_QueryParent(PRTFSNTFSDIRSHRD pThis, PRTFSNTFSDIRSHRD *ppDotDot) +{ + /* + * The root directory has no parent from our perspective. + */ + if (pThis == pThis->RootInfo.NodeInfo.pVol->pRootDir) + { + rtFsNtfsDirShrd_Retain(pThis); + *ppDotDot = pThis; + return VINF_SUCCESS; + } + + /* + * Look for a filename record so we know where we go from here. + */ + PRTFSNTFSCORE pCore = pThis->RootInfo.pRootAttr->pCore; + PRTFSNTFSATTR pCurAttr; + RTListForEach(&pCore->AttribHead, pCurAttr, RTFSNTFSATTR, ListEntry) + { + if ( pCurAttr->pAttrHdr->uAttrType == NTFS_AT_FILENAME + && pCurAttr->cbResident >= RT_UOFFSETOF(NTFSATFILENAME, wszFilename)) + { + PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)NTFSATTRIBHDR_GET_RES_VALUE_PTR(pCurAttr->pAttrHdr); + int rc = rtFsNtfsVol_QueryOrCreateSharedDirByMftRef(pThis->RootInfo.NodeInfo.pVol, &pFilename->ParentDirMftRec, + ppDotDot, NULL /*pErrInfo*/, ".."); + if (RT_SUCCESS(rc)) + return VINF_SUCCESS; + LogRel(("rtFsNtfsDirShrd_QueryParent: rtFsNtfsVol_QueryOrCreateSharedDirByMftRef failed: %Rrc\n", rc)); + return rc; + } + } + + LogRel(("rtFsNtfsDirShrd_QueryParent: Couldn't find '..' filename for MFT record %RX64!\n", + pThis->RootInfo.pRootAttr->pCore->pMftRec->TreeNode.Key)); + return VERR_VFS_BOGUS_FORMAT; +} + + + +/** + * Destroys an index node. + * + * This will remove it from the cache tree, however the caller must make sure + * its not in the reuse list any more. + * + * @param pNode The node to destroy. + */ +static void rtFsNtfsIdxNode_Destroy(PRTFSNTFSIDXNODE pNode) +{ + PRTFSNTFSVOL pVol = pNode->NodeInfo.pVol; + + /* Remove it from the volume node cache. */ + PAVLU64NODECORE pAssertRemove = RTAvlU64Remove(&pVol->IdxNodeCacheRoot, pNode->TreeNode.Key); + Assert(pAssertRemove == &pNode->TreeNode); NOREF(pAssertRemove); + pVol->cIdxNodes--; + pVol->cbIdxNodes -= pNode->cbCost; + + /* Destroy it. */ + rtFsNtfsIdxNodeInfo_Delete(&pNode->NodeInfo); + RTMemFree(pNode->pNode); + pNode->pNode = NULL; + RTMemFree(pNode); +} + + +/** + * Trims the index node cache. + * + * @param pThis The NTFS volume instance which index node cache + * needs trimming. + */ +static void rtFsNtfsIdxVol_TrimIndexNodeCache(PRTFSNTFSVOL pThis) +{ + while ( pThis->cbIdxNodes > RTFSNTFS_MAX_NODE_CACHE_SIZE + && pThis->cUnusedIdxNodes) + { + PRTFSNTFSIDXNODE pNode = RTListRemoveFirst(&pThis->IdxNodeUnusedHead, RTFSNTFSIDXNODE, UnusedListEntry); + pThis->cUnusedIdxNodes--; + rtFsNtfsIdxNode_Destroy(pNode); + } +} + + +/** + * Index node reference reached zero, put it in the unused list and trim the + * cache. + * + * @returns zero + * @param pNode The index node. + */ +static uint32_t rtFsNtfsIdxNode_MaybeDestroy(PRTFSNTFSIDXNODE pNode) +{ + PRTFSNTFSVOL pVol = pNode->NodeInfo.pVol; + if (pVol) + { + RTListAppend(&pVol->IdxNodeUnusedHead, &pNode->UnusedListEntry); + pVol->cUnusedIdxNodes++; + if (pVol->cbIdxNodes > RTFSNTFS_MAX_NODE_CACHE_SIZE) + rtFsNtfsIdxVol_TrimIndexNodeCache(pVol); + return 0; + } + /* not sure if this is needed yet... */ + rtFsNtfsIdxNodeInfo_Delete(&pNode->NodeInfo); + RTMemFree(pNode); + return 0; +} + + +/** + * Releases a reference to an index node. + * + * @returns New reference count. + * @param pNode The index node to release. NULL is ignored. + */ +static uint32_t rtFsNtfsIdxNode_Release(PRTFSNTFSIDXNODE pNode) +{ + if (pNode) + { + uint32_t cRefs = ASMAtomicDecU32(&pNode->cRefs); + Assert(cRefs < 128); + if (cRefs > 0) + return cRefs; + return rtFsNtfsIdxNode_MaybeDestroy(pNode); + } + return 0; +} + + +/** + * Retains a reference to an index node. + * + * This will remove it from the unused list if necessary. + * + * @returns New reference count. + * @param pNode The index to reference. + */ +static uint32_t rtFsNtfsIdxNode_Retain(PRTFSNTFSIDXNODE pNode) +{ + uint32_t cRefs = ASMAtomicIncU32(&pNode->cRefs); + if (cRefs == 1) + { + RTListNodeRemove(&pNode->UnusedListEntry); + pNode->NodeInfo.pVol->cUnusedIdxNodes--; + } + return cRefs; +} + + + + +/* + * + * Directory instance methods + * Directory instance methods + * Directory instance methods + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsNtfsDir_Close(void *pvThis) +{ + PRTFSNTFSDIR pThis = (PRTFSNTFSDIR)pvThis; + LogFlow(("rtFsNtfsDir_Close(%p/%p)\n", pThis, pThis->pShared)); + + PRTFSNTFSDIRSHRD pShared = pThis->pShared; + pThis->pShared = NULL; + if (pShared) + rtFsNtfsDirShrd_Release(pShared); + + while (pThis->cEnumStackEntries > 0) + { + PRTFSNTFSIDXSTACKENTRY pEntry = &pThis->paEnumStack[--pThis->cEnumStackEntries]; + rtFsNtfsIdxNode_Release(pEntry->pNodeInfo->pNode); + pEntry->pNodeInfo = NULL; + } + RTMemFree(pThis->paEnumStack); + pThis->paEnumStack = NULL; + pThis->cEnumStackMaxDepth = 0; + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsNtfsDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSNTFSDIR pThis = (PRTFSNTFSDIR)pvThis; + Log(("rtFsNtfsDir_QueryInfo\n")); + return rtFsNtfsCore_QueryInfo(pThis->pShared->RootInfo.pRootAttr->pCore, + pThis->pShared->RootInfo.pAlloc ? pThis->pShared->RootInfo.pAlloc + : pThis->pShared->RootInfo.pRootAttr, + pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsNtfsDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + Log(("rtFsNtfsDir_SetMode\n")); + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsNtfsDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + Log(("rtFsNtfsDir_SetTimes\n")); + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsNtfsDir_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + Log(("rtFsNtfsDir_SetOwner\n")); + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpen} + */ +static DECLCALLBACK(int) rtFsNtfsDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen, + uint32_t fFlags, PRTVFSOBJ phVfsObj) +{ + LogFlow(("rtFsNtfsDir_Open: pszEntry='%s' fOpen=%#RX64 fFlags=%#x\n", pszEntry, fOpen, fFlags)); + PRTFSNTFSDIR pThis = (PRTFSNTFSDIR)pvThis; + PRTFSNTFSDIRSHRD pShared = pThis->pShared; + PRTFSNTFSVOL pVol = pShared->RootInfo.NodeInfo.pVol; + int rc; + + /* + * We cannot create or replace anything, just open stuff. + */ + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { /* likely */ } + else + return VERR_WRITE_PROTECT; + + /* + * Special cases '.' and '..' + */ + if ( pszEntry[0] == '.' + && ( pszEntry[1] == '\0' + || ( pszEntry[1] == '.' + && pszEntry[2] == '\0'))) + { + if (!(fFlags & RTVFSOBJ_F_OPEN_DIRECTORY)) + return VERR_IS_A_DIRECTORY; + + PRTFSNTFSDIRSHRD pSharedToOpen; + if (pszEntry[1] == '\0') + { + pSharedToOpen = pShared; + rtFsNtfsDirShrd_Retain(pSharedToOpen); + rc = VINF_SUCCESS; + } + else + { + pSharedToOpen = NULL; + rc = rtFsNtfsDirShrd_QueryParent(pShared, &pSharedToOpen); + } + if (RT_SUCCESS(rc)) + { + RTVFSDIR hVfsDir; + rc = rtFsNtfsVol_NewDirFromShared(pVol, pSharedToOpen, &hVfsDir); + rtFsNtfsDirShrd_Release(pSharedToOpen); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + LogFlow(("rtFsNtfsDir_Open(%s): returns %Rrc\n", pszEntry, rc)); + return rc; + } + + /* + * Lookup the index entry. + */ + PRTFSNTFSIDXNODE pNode; + PCNTFSIDXENTRYHDR pEntryHdr; + PCNTFSATFILENAME pFilename; + rc = rtFsNtfsDirShrd_Lookup(pShared, pszEntry, &pFilename, &pEntryHdr, &pNode); + if (RT_SUCCESS(rc)) + { + uint32_t fFileAttribs = RT_LE2H_U32(pFilename->fFileAttribs); + switch (fFileAttribs & (NTFS_FA_DIRECTORY | NTFS_FA_REPARSE_POINT | NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT)) + { + /* + * File. + */ + case 0: + if (fFlags & RTVFSOBJ_F_OPEN_FILE) + { + RTVFSFILE hVfsFile; + rc = rtFsNtfsVol_NewFile(pVol, fOpen, pEntryHdr, NULL /*pszStreamName*/, &hVfsFile, NULL, pszEntry); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_IS_A_FILE; + break; + + /* + * Directory + */ + case NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT: + case NTFS_FA_DIRECTORY | NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT: + case NTFS_FA_DIRECTORY: + if (fFlags & RTVFSOBJ_F_OPEN_DIRECTORY) + { + PRTFSNTFSDIRSHRD pSharedToOpen; + rc = rtFsNtfsVol_QueryOrCreateSharedDirByMftRef(pVol, &pEntryHdr->u.FileMftRec, + &pSharedToOpen, NULL, pszEntry); + if (RT_SUCCESS(rc)) + { + RTVFSDIR hVfsDir; + rc = rtFsNtfsVol_NewDirFromShared(pVol, pSharedToOpen, &hVfsDir); + rtFsNtfsDirShrd_Release(pSharedToOpen); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + } + else + rc = VERR_IS_A_DIRECTORY; + break; + + /* + * Possible symbolic links. + */ + case NTFS_FA_REPARSE_POINT: + case NTFS_FA_REPARSE_POINT | NTFS_FA_DIRECTORY: + case NTFS_FA_REPARSE_POINT | NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT: + case NTFS_FA_REPARSE_POINT | NTFS_FA_DIRECTORY | NTFS_FA_DUP_FILE_NAME_INDEX_PRESENT: + rc = VERR_NOT_IMPLEMENTED; + break; + + default: + AssertFailed(); + rc = VERR_FILE_NOT_FOUND; + break; + } + rtFsNtfsIdxNode_Release(pNode); + } + + LogFlow(("rtFsNtfsDir_Open(%s): returns %Rrc\n", pszEntry, rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateDir} + */ +static DECLCALLBACK(int) rtFsNtfsDir_CreateDir(void *pvThis, const char *pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir) +{ + RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir); + Log(("rtFsNtfsDir_CreateDir\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink} + */ +static DECLCALLBACK(int) rtFsNtfsDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, phVfsSymlink); + Log(("rtFsNtfsDir_OpenSymlink\n")); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink} + */ +static DECLCALLBACK(int) rtFsNtfsDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget, + RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink); + Log(("rtFsNtfsDir_CreateSymlink\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry} + */ +static DECLCALLBACK(int) rtFsNtfsDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType) +{ + RT_NOREF(pvThis, pszEntry, fType); + Log(("rtFsNtfsDir_UnlinkEntry\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry} + */ +static DECLCALLBACK(int) rtFsNtfsDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName) +{ + RT_NOREF(pvThis, pszEntry, fType, pszNewName); + Log(("rtFsNtfsDir_RenameEntry\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * Cleans up the directory enumeration stack, releasing all node references. + * + * @param pThis The open directory instance data. + */ +static void rtFsNtfsDir_StackCleanup(PRTFSNTFSDIR pThis) +{ + while (pThis->cEnumStackEntries > 0) + { + PRTFSNTFSIDXSTACKENTRY pEntry = &pThis->paEnumStack[--pThis->cEnumStackEntries]; + rtFsNtfsIdxNode_Release(pEntry->pNodeInfo->pNode); + pEntry->pNodeInfo = NULL; + } + if (pThis->paEnumStack) + pThis->paEnumStack[0].iNext = 0; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRewindDir} + */ +static DECLCALLBACK(int) rtFsNtfsDir_RewindDir(void *pvThis) +{ + PRTFSNTFSDIR pThis = (PRTFSNTFSDIR)pvThis; + LogFlow(("rtFsNtfsDir_RewindDir\n")); + + rtFsNtfsDir_StackCleanup(pThis); + pThis->fNoMoreFiles = false; + + return VINF_SUCCESS; +} + +/** + * Descends down @a iSubnode to the first entry in left most leaf node. + * + * @returns IPRT status code. + * @param pThis The open directory instance data. + * @param pRootInfo The root info structure. + * @param iSubnode The subnode address to descend thru. + */ +static int rtFsNtfsDir_StackDescend(PRTFSNTFSDIR pThis, PRTFSNTFSIDXROOTINFO pRootInfo, int64_t iSubnode) +{ + for (;;) + { + /* Load the node. */ + PRTFSNTFSIDXNODE pNode; + int rc = rtFsNtfsIdxRootInfo_QueryNode(pRootInfo, iSubnode, &pNode); + if (RT_SUCCESS(rc)) + { /* likely */ } + else + { + LogFlow(("rtFsNtfsDir_StackDescend: rtFsNtfsIdxRootInfo_QueryNode(%#RX64) error %Rrc!\n", iSubnode, rc)); + return rc; + } + + /* Push it onto the stack. */ + uint32_t iStack = pThis->cEnumStackEntries; + if (iStack + 1 < pThis->cEnumStackMaxDepth) + { /* likely */ } + else if (pThis->cEnumStackMaxDepth < 1024) + { + Assert(pThis->cEnumStackMaxDepth> 0); + uint32_t cDepth = pThis->cEnumStackMaxDepth * 2; + Log5(("rtFsNtfsDir_ReadDir: Growing stack size to %u entries (from %u)\n", cDepth, pThis->cEnumStackMaxDepth)); + void *pvNew = RTMemRealloc(pThis->paEnumStack, cDepth * sizeof(pThis->paEnumStack[0])); + if (pvNew) + pThis->paEnumStack = (PRTFSNTFSIDXSTACKENTRY)pvNew; + else + return VERR_NO_MEMORY; + pThis->cEnumStackMaxDepth = cDepth; + } + else + { + LogRel(("rtFsNtfsDir_StackDescend: Badly unbalanced index! (MFT record #%#RX64) -> VERR_VFS_BOGUS_FORMAT\n", + pThis->pShared->RootInfo.pRootAttr->pCore->pMftRec->TreeNode.Key)); + return VERR_VFS_BOGUS_FORMAT; + } + + Log5(("rtFsNtfsDir_ReadDir: pushing %#RX64 (cEntries=%u, iStack=%u)\n", iSubnode, pNode->NodeInfo.cEntries, iStack)); + pThis->paEnumStack[iStack].iNext = 0; + pThis->paEnumStack[iStack].fDescend = false; + pThis->paEnumStack[iStack].pNodeInfo = &pNode->NodeInfo; + pThis->cEnumStackEntries = iStack + 1; + + /* Stop if this is a leaf node. */ + if ( !pNode->NodeInfo.fInternal + || !pNode->NodeInfo.cEntries /* paranoia */) + return VINF_SUCCESS; + + /* Get the first entry and check that it's an internal node before trying to following it. */ + PCNTFSIDXENTRYHDR pFirstEntry = pNode->NodeInfo.papEntries[0]; + if (pFirstEntry->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) + { /* likely */ } + else + return VINF_SUCCESS; + iSubnode = NTFSIDXENTRYHDR_GET_SUBNODE(pFirstEntry); + } +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnReadDir} + */ +static DECLCALLBACK(int) rtFsNtfsDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + PRTFSNTFSDIR pThis = (PRTFSNTFSDIR)pvThis; + PRTFSNTFSDIRSHRD pShared = pThis->pShared; + int rc; + Log(("rtFsNtfsDir_ReadDir\n")); + + /* + * Return immediately if no files at hand. + */ + if (pThis->fNoMoreFiles) + return VERR_NO_MORE_FILES; + + /* + * Make sure we've got a stack before we jump into the fray. + */ + if (!pThis->cEnumStackMaxDepth) + { + uint32_t cDepth; + if (!pShared->RootInfo.pAlloc) + cDepth = 2; + else + { + cDepth = ASMBitFirstSetU64(pShared->RootInfo.pAlloc->cbValue / RT_LE2H_U32(pShared->RootInfo.pRoot->cbIndexNode)); + cDepth += 3; + } + + pThis->paEnumStack = (PRTFSNTFSIDXSTACKENTRY)RTMemAllocZ(cDepth * sizeof(pThis->paEnumStack[0])); + if (!pThis->paEnumStack) + return VERR_NO_MEMORY; + pThis->cEnumStackMaxDepth = cDepth; + pThis->cEnumStackEntries = 0; + Log5(("rtFsNtfsDir_ReadDir: Initial stack size: %u entries\n", cDepth)); + //pThis->paEnumStack[0].iNext = 0; + } + + /* + * Deal with '.' and '..' by using stack entry zero without setting cEnumStack to zero. + * This is fine because we've got the fNoMoreFiles flag that got checked already. + */ + size_t const cbDirEntry = *pcbDirEntry; + if (pThis->cEnumStackEntries == 0) + { + if (pThis->paEnumStack[0].iNext <= 1) + { + + *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[pThis->paEnumStack[0].iNext + 2]); + if (*pcbDirEntry > cbDirEntry) + return VERR_BUFFER_OVERFLOW; + + /* Names. */ + pDirEntry->cbName = pThis->paEnumStack[0].iNext + 1; + pDirEntry->szName[0] = '.'; + pDirEntry->szName[pDirEntry->cbName - 1] = '.'; + pDirEntry->szName[pDirEntry->cbName] = '\0'; + pDirEntry->wszShortName[0] = '\0'; + pDirEntry->cwcShortName = 0; + + /* Get referenced shared directory structure that we return info about. */ + PRTFSNTFSDIRSHRD pDotShared; + if (pThis->paEnumStack[0].iNext == 0) + { + rtFsNtfsDirShrd_Retain(pShared); + pDotShared = pShared; + } + else + { + pDotShared = NULL; + rc = rtFsNtfsDirShrd_QueryParent(pShared, &pDotShared); + if (RT_FAILURE(rc)) + { + LogRel(("rtFsNtfsDir_ReadDir: couldn't find '..' filename! %Rrc\n", rc)); + return rc; + } + } + + /* Get the info. */ + rc = rtFsNtfsCore_QueryInfo(pDotShared->RootInfo.pRootAttr->pCore, pDotShared->RootInfo.pRootAttr, + &pDirEntry->Info, enmAddAttr); + rtFsNtfsDirShrd_Release(pDotShared); + if (RT_SUCCESS(rc)) + pThis->paEnumStack[0].iNext++; + Log5(("rtFsNtfsDir_ReadDir: => '%s' (%Rrc)\n", pDirEntry->szName, rc)); + return rc; + } + + /* + * Push the root onto the stack and decend down the left side of the tree. + */ + PRTFSNTFSIDXNODEINFO pNodeInfo = &pShared->RootInfo.NodeInfo; + pThis->paEnumStack[0].pNodeInfo = pNodeInfo; + pThis->paEnumStack[0].iNext = 0; + pThis->cEnumStackEntries = 1; + Log5(("rtFsNtfsDir_ReadDir: pushing root\n")); + if ( pNodeInfo->fInternal + && pNodeInfo->cEntries > 0 + && (pNodeInfo->papEntries[0]->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) /* parnaoia */ ) + { + rc = rtFsNtfsDir_StackDescend(pThis, &pShared->RootInfo, NTFSIDXENTRYHDR_GET_SUBNODE(pNodeInfo->papEntries[0])); + if (RT_FAILURE(rc)) + { + pThis->fNoMoreFiles = true; + rtFsNtfsDir_StackCleanup(pThis); + return rc; + } + } + } + + /* + * Work the stack. + */ + int32_t iStack = pThis->cEnumStackEntries - 1; + while (iStack >= 0) + { + PRTFSNTFSIDXNODEINFO pNodeInfo = pThis->paEnumStack[iStack].pNodeInfo; + uint32_t iNext = pThis->paEnumStack[iStack].iNext; + if (iNext < pNodeInfo->cEntries) + { + PCNTFSIDXENTRYHDR pEntry = pNodeInfo->papEntries[iNext]; + if ( !(pEntry->fFlags & NTFSIDXENTRYHDR_F_INTERNAL) + || !pThis->paEnumStack[iStack].fDescend) + { + if (!(pEntry->fFlags & NTFSIDXENTRYHDR_F_END)) + { + /* + * Try return the current entry. + */ + PCNTFSATFILENAME pFilename = (PCNTFSATFILENAME)(pEntry + 1); + + /* Deal with the filename. */ + size_t cchFilename; + rc = RTUtf16CalcUtf8LenEx(pFilename->wszFilename, pFilename->cwcFilename, &cchFilename); + if (RT_FAILURE(rc)) + { + cchFilename = 48; + LogRel(("rtFsNtfsDir_ReadDir: Bad filename (%Rrc) %.*Rhxs\n", + rc, pFilename->cwcFilename * sizeof(RTUTF16), pFilename->wszFilename)); + } + *pcbDirEntry = RT_UOFFSETOF_DYN(RTDIRENTRYEX, szName[cchFilename + 1]); + if (*pcbDirEntry > cbDirEntry) + { + Log5(("rtFsNtfsDir_ReadDir: returns VERR_BUFFER_OVERFLOW (for '%.*ls')\n", + pFilename->cwcFilename, pFilename->wszFilename)); + return VERR_BUFFER_OVERFLOW; + } + + char *pszDst = pDirEntry->szName; + if (RT_SUCCESS(rc)) + rc = RTUtf16ToUtf8Ex(pFilename->wszFilename, pFilename->cwcFilename, &pszDst, + cbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName), &cchFilename); + if (RT_FAILURE(rc)) + cchFilename = RTStrPrintf(pDirEntry->szName, cbDirEntry - RT_UOFFSETOF(RTDIRENTRYEX, szName), + "{invalid-name-%#RX64}", NTFSMFTREF_GET_IDX(&pEntry->u.FileMftRec)); + pDirEntry->cbName = (uint16_t)cchFilename; + + /* Figure out how to detect short names. */ + pDirEntry->cwcShortName = 0; + pDirEntry->wszShortName[0] = '\0'; + + /* Standard attributes: file mode, sizes and timestamps. */ + pDirEntry->Info.cbObject = RT_LE2H_U64(pFilename->cbData); + pDirEntry->Info.cbAllocated = RT_LE2H_U64(pFilename->cbAllocated); + RTTimeSpecSetNtTime(&pDirEntry->Info.BirthTime, RT_LE2H_U64(pFilename->iCreationTime)); + RTTimeSpecSetNtTime(&pDirEntry->Info.ModificationTime, RT_LE2H_U64(pFilename->iLastDataModTime)); + RTTimeSpecSetNtTime(&pDirEntry->Info.ChangeTime, RT_LE2H_U64(pFilename->iLastMftModTime)); + RTTimeSpecSetNtTime(&pDirEntry->Info.AccessTime, RT_LE2H_U64(pFilename->iLastAccessTime)); + pDirEntry->Info.Attr.fMode = rtFsNtfsConvertFileattribsToMode(RT_LE2H_U32(pFilename->fFileAttribs), pFilename, + RT_LE2H_U16(pEntry->cbKey)); + + /* additional stuff. */ + switch (enmAddAttr) + { + case RTFSOBJATTRADD_NOTHING: + enmAddAttr = RTFSOBJATTRADD_UNIX; + RT_FALL_THRU(); + case RTFSOBJATTRADD_UNIX: + pDirEntry->Info.Attr.u.Unix.uid = NIL_RTUID; + pDirEntry->Info.Attr.u.Unix.gid = NIL_RTGID; + pDirEntry->Info.Attr.u.Unix.cHardlinks = 1; + pDirEntry->Info.Attr.u.Unix.INodeIdDevice = 0; + pDirEntry->Info.Attr.u.Unix.INodeId = NTFSMFTREF_GET_IDX(&pEntry->u.FileMftRec); + pDirEntry->Info.Attr.u.Unix.fFlags = 0; + pDirEntry->Info.Attr.u.Unix.GenerationId = 0; + pDirEntry->Info.Attr.u.Unix.Device = 0; + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pDirEntry->Info.Attr.u.UnixOwner.uid = NIL_RTUID; + pDirEntry->Info.Attr.u.UnixOwner.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pDirEntry->Info.Attr.u.UnixGroup.gid = NIL_RTGID; + pDirEntry->Info.Attr.u.UnixGroup.szName[0] = '\0'; + break; + + case RTFSOBJATTRADD_EASIZE: + if (!(pFilename->fFileAttribs & RT_H2LE_U32_C(NTFS_FA_REPARSE_POINT))) + pDirEntry->Info.Attr.u.EASize.cb = pFilename->u.cbPackedEas; + else + pDirEntry->Info.Attr.u.EASize.cb = 0; + break; + + default: + AssertFailed(); + RT_ZERO(pDirEntry->Info.Attr.u); + break; + } + pDirEntry->Info.Attr.enmAdditional = enmAddAttr; + + /* + * Advance the stack entry to the next entry and return. + */ + Log5(("rtFsNtfsDir_ReadDir: => iStack=%u iNext=%u - '%.*ls'\n", + iStack, iNext, pFilename->cwcFilename, pFilename->wszFilename)); + pThis->paEnumStack[iStack].iNext = iNext + 1; + pThis->paEnumStack[iStack].fDescend = true; + return VINF_SUCCESS; + } + + /* + * End node, so pop it. We join the beoynd-end-of-entries path + * further down, forcing the descend code to use continue. + */ + } + else + { + /* + * Descend. + */ + rc = rtFsNtfsDir_StackDescend(pThis, &pShared->RootInfo, + NTFSIDXENTRYHDR_GET_SUBNODE(pNodeInfo->papEntries[iNext])); + if (RT_SUCCESS(rc)) + { + pThis->paEnumStack[iStack].fDescend = false; + iStack = pThis->cEnumStackEntries - 1; + continue; + } + pThis->fNoMoreFiles = true; + rtFsNtfsDir_StackCleanup(pThis); + return rc; + } + } + + /* + * Pop at stack entry. + */ + Log5(("rtFsNtfsDir_ReadDir: popping %#RX64 (iNext=%u, cEntries=%u, iStack=%u) -> %#RX64 (iNext=%d, cEntries=%u)\n", + pNodeInfo->pNode ? pNodeInfo->pNode->pNode->iSelfAddress : 0, iNext, pNodeInfo->cEntries, iStack, + iStack > 0 && pThis->paEnumStack[iStack - 1].pNodeInfo->pNode + ? pThis->paEnumStack[iStack - 1].pNodeInfo->pNode->pNode->iSelfAddress : UINT64_MAX, + iStack > 0 ? pThis->paEnumStack[iStack - 1].iNext : -1, + iStack > 0 ? pThis->paEnumStack[iStack - 1].pNodeInfo->cEntries : 0 )); + rtFsNtfsIdxNode_Release(pNodeInfo->pNode); + pThis->paEnumStack[iStack].pNodeInfo = NULL; + pThis->cEnumStackEntries = iStack; + iStack--; + Assert(iStack < 0 || !pThis->paEnumStack[iStack].fDescend); + } + + /* + * The End. + */ + Log5(("rtFsNtfsDir_ReadDir: no more files\n")); + pThis->fNoMoreFiles = true; + return VERR_NO_MORE_FILES; +} + + +/** + * NTFS directory operations. + */ +static const RTVFSDIROPS g_rtFsNtfsDirOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_DIR, + "NTFS Dir", + rtFsNtfsDir_Close, + rtFsNtfsDir_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSDIROPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj), + rtFsNtfsDir_SetMode, + rtFsNtfsDir_SetTimes, + rtFsNtfsDir_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsNtfsDir_Open, + NULL /* pfnFollowAbsoluteSymlink */, + NULL /* pfnOpenFile */, + NULL /* pfnOpenDir */, + rtFsNtfsDir_CreateDir, + rtFsNtfsDir_OpenSymlink, + rtFsNtfsDir_CreateSymlink, + NULL /* pfnQueryEntryInfo */, + rtFsNtfsDir_UnlinkEntry, + rtFsNtfsDir_RenameEntry, + rtFsNtfsDir_RewindDir, + rtFsNtfsDir_ReadDir, + RTVFSDIROPS_VERSION, +}; + + +/** + * Creates a new directory instance given a shared directory structure. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param pSharedDir The shared directory structure to create a new + * handle to. + * @param phVfsDir Where to return the directory handle. + */ +static int rtFsNtfsVol_NewDirFromShared(PRTFSNTFSVOL pThis, PRTFSNTFSDIRSHRD pSharedDir, PRTVFSDIR phVfsDir) +{ + PRTFSNTFSDIR pNewDir; + int rc = RTVfsNewDir(&g_rtFsNtfsDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsDir, (void **)&pNewDir); + if (RT_SUCCESS(rc)) + { + rtFsNtfsDirShrd_Retain(pSharedDir); + pNewDir->pShared = pSharedDir; + pNewDir->cEnumStackEntries = 0; + pNewDir->cEnumStackMaxDepth = 0; + pNewDir->paEnumStack = NULL; + return VINF_SUCCESS; + } + return rc; +} + + + +/* + * + * Volume level code. + * Volume level code. + * Volume level code. + * + */ + + +/** + * Slow path for querying the allocation state of a cluster. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param iCluster The cluster to query. + * @param pfState Where to return the state. + */ +static int rtFsNtfsVol_QueryClusterStateSlow(PRTFSNTFSVOL pThis, uint64_t iCluster, bool *pfState) +{ + int rc; + uint64_t const cbWholeBitmap = RT_LE2H_U64(pThis->pMftBitmap->pAttrHdr->u.NonRes.cbData); + uint64_t const offInBitmap = iCluster >> 3; + if (offInBitmap < cbWholeBitmap) + { + if (!pThis->pvBitmap) + { + /* + * Try cache the whole bitmap if it's not too large. + */ + if ( cbWholeBitmap <= RTFSNTFS_MAX_WHOLE_BITMAP_CACHE + && cbWholeBitmap >= RT_ALIGN_64(pThis->cClusters >> 3, 8)) + { + pThis->cbBitmapAlloc = RT_ALIGN_Z((uint32_t)cbWholeBitmap, 8); + pThis->pvBitmap = RTMemAlloc(pThis->cbBitmapAlloc); + if (pThis->pvBitmap) + { + memset(pThis->pvBitmap, 0xff, pThis->cbBitmapAlloc); + rc = rtFsNtfsAttr_Read(pThis->pMftBitmap, 0, pThis->pvBitmap, (uint32_t)cbWholeBitmap); + if (RT_SUCCESS(rc)) + { + pThis->iFirstBitmapCluster = 0; + pThis->cBitmapClusters = pThis->cClusters; + *pfState = rtFsNtfsBitmap_IsSet(pThis->pvBitmap, (uint32_t)iCluster); + return VINF_SUCCESS; + } + RTMemFree(pThis->pvBitmap); + pThis->pvBitmap = NULL; + pThis->cbBitmapAlloc = 0; + return rc; + } + } + + /* + * Do a cluster/4K cache. + */ + pThis->cbBitmapAlloc = RT_MAX(pThis->cbCluster, _4K); + pThis->pvBitmap = RTMemAlloc(pThis->cbBitmapAlloc); + if (!pThis->pvBitmap) + { + pThis->cbBitmapAlloc = 0; + return VERR_NO_MEMORY; + } + } + + /* + * Load a cache line. + */ + Assert(RT_IS_POWER_OF_TWO(pThis->cbBitmapAlloc)); + uint64_t offLoad = offInBitmap & ~(pThis->cbBitmapAlloc - 1); + uint32_t cbLoad = (uint32_t)RT_MIN(cbWholeBitmap - offLoad, pThis->cbBitmapAlloc); + + memset(pThis->pvBitmap, 0xff, pThis->cbBitmapAlloc); + rc = rtFsNtfsAttr_Read(pThis->pMftBitmap, offLoad, pThis->pvBitmap, cbLoad); + if (RT_SUCCESS(rc)) + { + pThis->iFirstBitmapCluster = offLoad << 3; + pThis->cBitmapClusters = cbLoad << 3; + *pfState = rtFsNtfsBitmap_IsSet(pThis->pvBitmap, (uint32_t)(iCluster - pThis->iFirstBitmapCluster)); + return VINF_SUCCESS; + } + pThis->cBitmapClusters = 0; + } + else + { + LogRel(("rtFsNtfsVol_QueryClusterStateSlow: iCluster=%#RX64 is outside the bitmap (%#RX64)\n", iCluster, cbWholeBitmap)); + rc = VERR_OUT_OF_RANGE; + } + return rc; +} + + +/** + * Query the allocation state of the given cluster. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param iCluster The cluster to query. + * @param pfState Where to return the state. + */ +static int rtFsNtfsVol_QueryClusterState(PRTFSNTFSVOL pThis, uint64_t iCluster, bool *pfState) +{ + uint64_t iClusterInCache = iCluster - pThis->iFirstBitmapCluster; + if (iClusterInCache < pThis->cBitmapClusters) + { + *pfState = rtFsNtfsBitmap_IsSet(pThis->pvBitmap, (uint32_t)iClusterInCache); + return VINF_SUCCESS; + } + return rtFsNtfsVol_QueryClusterStateSlow(pThis, iCluster, pfState); +} + + +/** + * Callback for RTAvlU64Destroy used by rtFsNtfsVol_Close to destroy the MFT + * record cache. + * + * @returns VINF_SUCCESS + * @param pNode The MFT record to destroy. + * @param pvUser Ignored. + */ +static DECLCALLBACK(int) rtFsNtFsVol_DestroyCachedMftRecord(PAVLU64NODECORE pNode, void *pvUser) +{ + PRTFSNTFSMFTREC pMftRec = (PRTFSNTFSMFTREC)pNode; + RT_NOREF(pvUser); + + RTMemFree(pMftRec->pbRec); + pMftRec->pbRec = NULL; + RTMemFree(pMftRec); + + return VINF_SUCCESS; +} + + + +/** + * Callback for RTAvlU64Destroy used by rtFsNtfsVol_Close to destroy the index + * node cache. + * + * @returns VINF_SUCCESS + * @param pNode The index node to destroy. + * @param pvUser Ignored. + */ +static DECLCALLBACK(int) rtFsNtfsVol_DestroyIndexNode(PAVLU64NODECORE pNode, void *pvUser) +{ + PRTFSNTFSIDXNODE pIdxNode = (PRTFSNTFSIDXNODE)pNode; + RT_NOREF(pvUser); + + RTMemFree(pIdxNode->pNode); + RTMemFree(pIdxNode->NodeInfo.papEntries); + pIdxNode->pNode = NULL; + pIdxNode->NodeInfo.papEntries = NULL; + pIdxNode->NodeInfo.pIndexHdr = NULL; + pIdxNode->NodeInfo.pVol = NULL; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose} + */ +static DECLCALLBACK(int) rtFsNtfsVol_Close(void *pvThis) +{ + PRTFSNTFSVOL pThis = (PRTFSNTFSVOL)pvThis; + Log(("rtFsNtfsVol_Close(%p):\n", pThis)); + + /* + * Index / directory related members. + */ + if (pThis->pRootDir) + { + rtFsNtfsDirShrd_Release(pThis->pRootDir); + pThis->pRootDir = NULL; + } + + RTAvlU64Destroy(&pThis->IdxNodeCacheRoot, rtFsNtfsVol_DestroyIndexNode, NULL); + + RTMemFree(pThis->pawcUpcase); + pThis->pawcUpcase = NULL; + + pThis->IdxNodeUnusedHead.pPrev = pThis->IdxNodeUnusedHead.pNext = NULL; + + /* + * Allocation bitmap cache. + */ + if (pThis->pMftBitmap) + { + rtFsNtfsCore_Release(pThis->pMftBitmap->pCore); + pThis->pMftBitmap = NULL; + } + RTMemFree(pThis->pvBitmap); + pThis->pvBitmap = NULL; + + /* + * The MFT and MFT cache. + */ + if (pThis->pMftData) + { + rtFsNtfsCore_Release(pThis->pMftData->pCore); + pThis->pMftData = NULL; + } + + Assert(RTListIsEmpty(&pThis->CoreInUseHead)); + PRTFSNTFSCORE pCurCore, pNextCore; + RTListForEachSafe(&pThis->CoreInUseHead, pCurCore, pNextCore, RTFSNTFSCORE, ListEntry) + rtFsNtfsCore_Destroy(pCurCore); + RTListForEachSafe(&pThis->CoreUnusedHead, pCurCore, pNextCore, RTFSNTFSCORE, ListEntry) + rtFsNtfsCore_Destroy(pCurCore); + + pThis->CoreInUseHead.pPrev = pThis->CoreInUseHead.pNext = NULL; + pThis->CoreUnusedHead.pPrev = pThis->CoreUnusedHead.pNext = NULL; + + Assert(pThis->MftRoot == NULL); + RTAvlU64Destroy(&pThis->MftRoot, rtFsNtFsVol_DestroyCachedMftRecord, NULL); + + /* + * Backing file and handles. + */ + RTVfsFileRelease(pThis->hVfsBacking); + pThis->hVfsBacking = NIL_RTVFSFILE; + pThis->hVfsSelf = NIL_RTVFS; + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsNtfsVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + NOREF(pvThis); NOREF(pObjInfo); NOREF(enmAddAttr); + return VERR_WRONG_TYPE; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnOpenRoot} + */ +static DECLCALLBACK(int) rtFsNtfsVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir) +{ + PRTFSNTFSVOL pThis = (PRTFSNTFSVOL)pvThis; + AssertReturn(pThis->pRootDir, VERR_INTERNAL_ERROR_4); + int rc = rtFsNtfsVol_NewDirFromShared(pThis, pThis->pRootDir, phVfsDir); + LogFlow(("rtFsNtfsVol_OpenRoot: returns %Rrc\n", rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryRangeState} + */ +static DECLCALLBACK(int) rtFsNtfsVol_QueryRangeState(void *pvThis, uint64_t off, size_t cb, bool *pfUsed) +{ + PRTFSNTFSVOL pThis = (PRTFSNTFSVOL)pvThis; + *pfUsed = true; + + /* + * Round to a cluster range. + */ + uint64_t iCluster = off >> pThis->cClusterShift; + + Assert(RT_IS_POWER_OF_TWO(pThis->cbCluster)); + cb += off & (pThis->cbCluster - 1); + cb = RT_ALIGN_Z(cb, pThis->cbCluster); + size_t cClusters = cb >> pThis->cClusterShift; + + /* + * Check the clusters one-by-one. + * Just to be cautious, we will always check the cluster at off, even when cb is zero. + */ + do + { + bool fState = true; + int rc = rtFsNtfsVol_QueryClusterState(pThis, iCluster, &fState); + if (RT_FAILURE(rc)) + return rc; + if (fState) + { + *pfUsed = true; + LogFlow(("rtFsNtfsVol_QueryRangeState: %RX64 LB %#x - used\n", off & ~(uint64_t)(pThis->cbCluster - 1), cb)); + return VINF_SUCCESS; + } + + iCluster++; + } while (cClusters-- > 0); + + LogFlow(("rtFsNtfsVol_QueryRangeState: %RX64 LB %#x - unused\n", off & ~(uint64_t)(pThis->cbCluster - 1), cb)); + *pfUsed = false; + return VINF_SUCCESS; +} + + +/** + * NTFS volume operations. + */ +static const RTVFSOPS g_rtFsNtfsVolOps = +{ + /* .Obj = */ + { + /* .uVersion = */ RTVFSOBJOPS_VERSION, + /* .enmType = */ RTVFSOBJTYPE_VFS, + /* .pszName = */ "NtfsVol", + /* .pfnClose = */ rtFsNtfsVol_Close, + /* .pfnQueryInfo = */ rtFsNtfsVol_QueryInfo, + /* .uEndMarker = */ RTVFSOBJOPS_VERSION + }, + /* .uVersion = */ RTVFSOPS_VERSION, + /* .fFeatures = */ 0, + /* .pfnOpenRoot = */ rtFsNtfsVol_OpenRoot, + /* .pfnQueryRangeState = */ rtFsNtfsVol_QueryRangeState, + /* .uEndMarker = */ RTVFSOPS_VERSION +}; + + +/** + * Checks that the storage for the given attribute is all marked allocated in + * the allocation bitmap of the volume. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. + * @param pAttr The attribute to check. + * @param pszDesc Description of the attribute. + * @param pErrInfo Where to return error details. + */ +static int rtFsNtfsVolCheckBitmap(PRTFSNTFSVOL pThis, PRTFSNTFSATTR pAttr, const char *pszDesc, PRTERRINFO pErrInfo) +{ + PRTFSNTFSATTRSUBREC pSubRec = NULL; + PRTFSNTFSEXTENTS pTable = &pAttr->Extents; + uint64_t offFile = 0; + for (;;) + { + uint32_t const cExtents = pTable->cExtents; + PRTFSNTFSEXTENT paExtents = pTable->paExtents; + for (uint32_t iExtent = 0; iExtent < cExtents; iExtent++) + { + uint64_t const off = paExtents[iExtent].off; + if (off == UINT64_MAX) + offFile += paExtents[iExtent].cbExtent; + else + { + uint64_t iCluster = off >> pThis->cClusterShift; + uint64_t cClusters = paExtents[iExtent].cbExtent >> pThis->cClusterShift; + Assert((cClusters << pThis->cClusterShift) == paExtents[iExtent].cbExtent); + Assert(cClusters != 0); + + while (cClusters-- > 0) + { + bool fState = false; + int rc = rtFsNtfsVol_QueryClusterState(pThis, iCluster, &fState); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, rc, + "Error querying allocation bitmap entry %#RX64 (for %s offset %#RX64)", + iCluster, pszDesc, offFile); + if (!fState) + return RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "Cluster %#RX64 at offset %#RX64 in %s is not marked allocated", + iCluster, offFile, pszDesc); + offFile += pThis->cbCluster; + } + } + } + + /* Next table. */ + pSubRec = pSubRec ? pSubRec->pNext : pAttr->pSubRecHead; + if (!pSubRec) + return VINF_SUCCESS; + pTable = &pSubRec->Extents; + } +} + + +/** + * Loads, validates and setups the '.' (NTFS_MFT_IDX_ROOT) MFT entry. + * + * @returns IPRT status code + * @param pThis The NTFS volume instance. Will set pawcUpcase. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsNtfsVolLoadRootDir(PRTFSNTFSVOL pThis, PRTERRINFO pErrInfo) +{ + /* + * Load it and do some checks. + */ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_NewCoreForMftIdx(pThis, NTFS_MFT_IDX_ROOT, false /*fRelaxedUsa*/, &pCore, pErrInfo); // DON'T COMMIT + if (RT_SUCCESS(rc)) + { + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_FILENAME); + if (!pFilenameAttr) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "RootDir: has no FILENAME attribute!"); + else if (pFilenameAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "RootDir: FILENAME attribute is non-resident!"); + else if (pFilenameAttr->pAttrHdr->u.Res.cbValue < RT_UOFFSETOF(NTFSATFILENAME, wszFilename[1])) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "RootDir: FILENAME attribute value size is too small: %#x", + pFilenameAttr->pAttrHdr->u.Res.cbValue); + else + { + PNTFSATFILENAME pFilename = (PNTFSATFILENAME)( (uint8_t *)pFilenameAttr->pAttrHdr + + pFilenameAttr->pAttrHdr->u.Res.offValue); + if ( pFilename->cwcFilename != 1 + || ( RTUtf16NICmpAscii(pFilename->wszFilename, ".", 1) != 0 + && RTUtf16NICmpAscii(pFilename->wszFilename, "$", 1) != 0)) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "RootDir: FILENAME is not '.' nor '$: '%.*ls'", + pFilename->cwcFilename, pFilename->wszFilename); + else + { + PRTFSNTFSATTR pIndexRoot = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_INDEX_ROOT, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + PRTFSNTFSATTR pIndexAlloc = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_INDEX_ALLOCATION, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + PRTFSNTFSATTR pIndexBitmap = rtFsNtfsCore_FindNamedAttributeAscii(pCore, NTFS_AT_BITMAP, + RT_STR_TUPLE(NTFS_DIR_ATTRIBUTE_NAME)); + if (!pIndexRoot) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "RootDir: Found no INDEX_ROOT attribute named $I30"); + else if (!pIndexAlloc && pIndexBitmap) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "RootDir: Found no INDEX_ALLOCATION attribute named $I30"); + else if (!pIndexBitmap && pIndexAlloc) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "RootDir: Found no BITMAP attribute named $I30"); + if (RT_SUCCESS(rc) && pIndexAlloc) + rc = rtFsNtfsVolCheckBitmap(pThis, pIndexAlloc, "RootDir", pErrInfo); + if (RT_SUCCESS(rc) && pIndexBitmap) + rc = rtFsNtfsVolCheckBitmap(pThis, pIndexBitmap, "RootDir/bitmap", pErrInfo); + if (RT_SUCCESS(rc)) + { + /* + * Load it as a normal directory. + */ + PRTFSNTFSDIRSHRD pSharedDir; + rc = rtFsNtfsVol_NewSharedDirFromCore(pThis, pCore, &pSharedDir, pErrInfo, "RootDir"); + if (RT_SUCCESS(rc)) + { + rtFsNtfsCore_Release(pCore); + pThis->pRootDir = pSharedDir; + return VINF_SUCCESS; + } + } + } + } + rtFsNtfsCore_Release(pCore); + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, rc, "Root dir: Error reading MFT record"); + return rc; +} + + +/** + * Loads, validates and setups the '$UpCase' (NTFS_MFT_IDX_UP_CASE) MFT entry. + * + * This is needed for filename lookups, I think. + * + * @returns IPRT status code + * @param pThis The NTFS volume instance. Will set pawcUpcase. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsNtfsVolLoadUpCase(PRTFSNTFSVOL pThis, PRTERRINFO pErrInfo) +{ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_NewCoreForMftIdx(pThis, NTFS_MFT_IDX_UP_CASE, false /*fRelaxedUsa*/, &pCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + PRTFSNTFSATTR pDataAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_DATA); + if (pDataAttr) + { + /* + * Validate the '$Upcase' MFT record. + */ + uint32_t const cbMin = 512; + uint32_t const cbMax = _128K; + if (!pDataAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$UpCase: unnamed DATA attribute is resident!"); + else if ( (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated) < cbMin + || (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated) > cbMax) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: unnamed DATA attribute allocated size is out of range: %#RX64, expected at least %#RX32 and no more than %#RX32", + RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated), cbMin, cbMax); + else if ( (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbData) < cbMin + || (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbData) + > (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbData) + || ((uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbData) & 1) ) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: unnamed DATA attribute initialized size is out of range: %#RX64, expected at least %#RX32 and no more than %#RX64", + RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbData), cbMin, + RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated) ); + else if ( (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbInitialized) < cbMin + || (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbInitialized) + > (uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated) + || ((uint64_t)RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbInitialized) & 1) ) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: unnamed DATA attribute initialized size is out of range: %#RX64, expected at least %#RX32 and no more than %#RX64", + RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbInitialized), cbMin, + RT_LE2H_U64(pDataAttr->pAttrHdr->u.NonRes.cbAllocated) ); + else if (pDataAttr->pAttrHdr->u.NonRes.uCompressionUnit != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: unnamed DATA attribute is compressed: %#x", + pDataAttr->pAttrHdr->u.NonRes.uCompressionUnit); + else + { + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_FILENAME); + if (!pFilenameAttr) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$UpCase has no FILENAME attribute!"); + else if (pFilenameAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$UpCase FILENAME attribute is non-resident!"); + else if (pFilenameAttr->pAttrHdr->u.Res.cbValue < RT_UOFFSETOF(NTFSATFILENAME, wszFilename[7])) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: FILENAME attribute value size is too small: %#x", + pFilenameAttr->pAttrHdr->u.Res.cbValue); + else + { + PNTFSATFILENAME pFilename = (PNTFSATFILENAME)( (uint8_t *)pFilenameAttr->pAttrHdr + + pFilenameAttr->pAttrHdr->u.Res.offValue); + if ( pFilename->cwcFilename != 7 + || RTUtf16NICmpAscii(pFilename->wszFilename, "$UpCase", 7) != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase: FILENAME isn't '$UpCase': '%.*ls'", + pFilename->cwcFilename, pFilename->wszFilename); + else + { + /* + * Allocate memory for the uppercase table and read it. + */ + PRTUTF16 pawcUpcase; + pThis->pawcUpcase = pawcUpcase = (PRTUTF16)RTMemAlloc(_64K * sizeof(pThis->pawcUpcase[0])); + if (pawcUpcase) + { + for (size_t i = 0; i < _64K; i++) + pawcUpcase[i] = (uint16_t)i; + + rc = rtFsNtfsAttr_Read(pDataAttr, 0, pawcUpcase, pDataAttr->pAttrHdr->u.NonRes.cbData); + if (RT_SUCCESS(rc)) + { + /* + * Check the data. + */ + for (size_t i = 1; i < _64K; i++) + if (pawcUpcase[i] == 0) + { + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$UpCase entry %#x is zero!", i); + break; + } + + /* + * While we still have the $UpCase file open, check it against the allocation bitmap. + */ + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolCheckBitmap(pThis, pDataAttr, "$UpCase", pErrInfo); + + /* We're done, no need for special success return here though. */ + } + else + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, rc, "Error reading $UpCase data into memory"); + } + else + rc = VERR_NO_MEMORY; + } + } + } + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$UpCase: has no unnamed DATA attribute!"); + rtFsNtfsCore_Release(pCore); + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, rc, "$UpCase: Error reading the MFT record"); + return rc; +} + + +/** + * Loads the allocation bitmap and does basic validation of. + * + * @returns IPRT status code. + * @param pThis The NTFS volume instance. Will set up the + * 'Allocation bitmap and cache' fields. + * @param pErrInfo Where to return error details. + */ +static int rtFsNtfsVolLoadBitmap(PRTFSNTFSVOL pThis, PRTERRINFO pErrInfo) +{ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_NewCoreForMftIdx(pThis, NTFS_MFT_IDX_BITMAP, false /*fRelaxedUsa*/, &pCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + PRTFSNTFSATTR pMftBitmap; + pThis->pMftBitmap = pMftBitmap = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_DATA); + if (pMftBitmap) + { + /* + * Validate the '$Bitmap' MFT record. + * We expect the bitmap to be fully initialized and be sized according to the + * formatted volume size. Allegedly, NTFS pads it to an even 8 byte in size. + */ + uint64_t const cbMinBitmap = RT_ALIGN_64(pThis->cbVolume >> (pThis->cClusterShift + 3), 8); + uint64_t const cbMaxBitmap = RT_ALIGN_64(cbMinBitmap, pThis->cbCluster); + //uint64_t const cbMinInitialized = RT_ALIGN_64((RT_MAX(pThis->uLcnMft, pThis->uLcnMftMirror) + 16) >> 3, 8); + if (!pMftBitmap->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #6 unnamed DATA attribute is resident!"); + else if ( (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated) < cbMinBitmap + || (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated) > cbMaxBitmap) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: unnamed DATA attribute allocated size is out of range: %#RX64, expected at least %#RX64 and no more than %#RX64", + RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated), cbMinBitmap, cbMaxBitmap); + else if ( (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbData) < cbMinBitmap + || (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbData) + > (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbData)) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: unnamed DATA attribute initialized size is out of range: %#RX64, expected at least %#RX64 and no more than %#RX64", + RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbData), cbMinBitmap, + RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated) ); + else if ( (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbInitialized) < cbMinBitmap + || (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbInitialized) + > (uint64_t)RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated)) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: unnamed DATA attribute initialized size is out of range: %#RX64, expected at least %#RX64 and no more than %#RX64", + RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbInitialized), cbMinBitmap, + RT_LE2H_U64(pMftBitmap->pAttrHdr->u.NonRes.cbAllocated) ); + else if (pMftBitmap->pAttrHdr->u.NonRes.uCompressionUnit != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: unnamed DATA attribute is compressed: %#x", + pMftBitmap->pAttrHdr->u.NonRes.uCompressionUnit); + else if (pMftBitmap->Extents.cExtents != 1) /* paranoia for now */ + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: unnamed DATA attribute is expected to have a single extent: %u extents", + pMftBitmap->Extents.cExtents); + else if (pMftBitmap->Extents.paExtents[0].off == UINT64_MAX) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #6 unnamed DATA attribute is sparse"); + else + { + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_FILENAME); + if (!pFilenameAttr) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #6 has no FILENAME attribute!"); + else if (pFilenameAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #6 FILENAME attribute is non-resident!"); + else if (pFilenameAttr->pAttrHdr->u.Res.cbValue < RT_UOFFSETOF(NTFSATFILENAME, wszFilename[7])) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap FILENAME attribute value size is too small: %#x", + pFilenameAttr->pAttrHdr->u.Res.cbValue); + else + { + PNTFSATFILENAME pFilename = (PNTFSATFILENAME)( (uint8_t *)pFilenameAttr->pAttrHdr + + pFilenameAttr->pAttrHdr->u.Res.offValue); + if ( pFilename->cwcFilename != 7 + || RTUtf16NICmpAscii(pFilename->wszFilename, "$Bitmap", 7) != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Bitmap: FILENAME isn't '$Bitmap': '%.*ls'", + pFilename->cwcFilename, pFilename->wszFilename); + else + { + /* + * Read some of it into the buffer and check that essential stuff is flagged as allocated. + */ + /* The boot sector. */ + bool fState = false; + rc = rtFsNtfsVol_QueryClusterState(pThis, 0, &fState); + if (RT_SUCCESS(rc) && !fState) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT allocation bitmap error: Bootsector isn't marked allocated!"); + else if (RT_FAILURE(rc)) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT allocation bitmap (offset 0) read error: %Rrc", rc); + + /* The bitmap ifself, the MFT data, and the MFT bitmap. */ + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolCheckBitmap(pThis, pThis->pMftBitmap, "allocation bitmap", pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolCheckBitmap(pThis, pThis->pMftData, "MFT", pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolCheckBitmap(pThis, + rtFsNtfsCore_FindUnnamedAttribute(pThis->pMftData->pCore, NTFS_AT_BITMAP), + "MFT Bitmap", pErrInfo); + if (RT_SUCCESS(rc)) + { + /* + * Looks like the bitmap is good. + */ + return VINF_SUCCESS; + } + } + } + } + pThis->pMftBitmap = NULL; + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$Bitmap: has no unnamed DATA attribute!"); + rtFsNtfsCore_Release(pCore); + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, rc, "$Bitmap: Error MFT record"); + return rc; +} + + +/** + * Loads, validates and setups the '$Volume' (NTFS_MFT_IDX_VOLUME) MFT entry. + * + * @returns IPRT status code + * @param pThis The NTFS volume instance. Will set uNtfsVersion + * and fVolumeFlags. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsNtfsVolLoadVolumeInfo(PRTFSNTFSVOL pThis, PRTERRINFO pErrInfo) +{ + PRTFSNTFSCORE pCore; + int rc = rtFsNtfsVol_NewCoreForMftIdx(pThis, NTFS_MFT_IDX_VOLUME, false /*fRelaxedUsa*/, &pCore, pErrInfo); + if (RT_SUCCESS(rc)) + { + PRTFSNTFSATTR pVolInfoAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_VOLUME_INFORMATION); + if (pVolInfoAttr) + { + /* + * Validate the '$Volume' MFT record. + */ + if (pVolInfoAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$Volume unnamed VOLUME_INFORMATION attribute is not resident!"); + else if ( pVolInfoAttr->cbResident != sizeof(NTFSATVOLUMEINFO) + || pVolInfoAttr->cbValue != sizeof(NTFSATVOLUMEINFO)) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Volume VOLUME_INFORMATION attribute has the wrong size: cbValue=%#RX64, cbResident=%#RX32, expected %#x\n", + pVolInfoAttr->cbValue, pVolInfoAttr->cbResident, sizeof(NTFSATVOLUMEINFO)); + else + { + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_FILENAME); + if (!pFilenameAttr) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$Volume has no FILENAME attribute!"); + else if (pFilenameAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "$Volume FILENAME attribute is non-resident!"); + else if (pFilenameAttr->pAttrHdr->u.Res.cbValue < RT_UOFFSETOF(NTFSATFILENAME, wszFilename[7])) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Volume FILENAME attribute value size is too small: %#x", + pFilenameAttr->pAttrHdr->u.Res.cbValue); + else + { + PNTFSATFILENAME pFilename = (PNTFSATFILENAME)( (uint8_t *)pFilenameAttr->pAttrHdr + + pFilenameAttr->pAttrHdr->u.Res.offValue); + if ( pFilename->cwcFilename != 7 + || RTUtf16NICmpAscii(pFilename->wszFilename, "$Volume", 7) != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "$Volume FILENAME isn't '$Volume': '%.*ls'", + pFilename->cwcFilename, pFilename->wszFilename); + else + { + /* + * Look at the information. + */ + PCNTFSATVOLUMEINFO pVolInfo; + pVolInfo = (PCNTFSATVOLUMEINFO)((uint8_t *)pVolInfoAttr->pAttrHdr + pVolInfoAttr->pAttrHdr->u.Res.offValue); + pThis->uNtfsVersion = RTFSNTFS_MAKE_VERSION(pVolInfo->uMajorVersion, pVolInfo->uMinorVersion); + pThis->fVolumeFlags = RT_LE2H_U16(pVolInfo->fFlags); + Log(("NTFS: Version %u.%u, flags=%#x\n", pVolInfo->uMajorVersion, pVolInfo->uMinorVersion, pThis->fVolumeFlags)); + + /* We're done, no need for special success return here though. */ + } + } + } + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record $Volume has no unnamed VOLUME_INFORMATION attribute!"); + rtFsNtfsCore_Release(pCore); + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, rc, "Error reading $Volume MFT record"); + return rc; +} + + +/** + * Loads, validates and setups the '$Mft' (NTFS_MFT_IDX_MFT) MFT entry. + * + * This is the first thing we do after we've checked out the boot sector and + * extracted information from it, since everything else depends on us being able + * to access the MFT data. + * + * @returns IPRT status code + * @param pThis The NTFS volume instance. Will set pMftData. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsNtfsVolLoadMft(PRTFSNTFSVOL pThis, PRTERRINFO pErrInfo) +{ + /* + * Bootstrap the MFT data stream. + */ + PRTFSNTFSMFTREC pRec = rtFsNtfsVol_NewMftRec(pThis, NTFS_MFT_IDX_MFT); + AssertReturn(pRec, VERR_NO_MEMORY); + +#if 0 && defined(LOG_ENABLED) + for (uint32_t i = 0; i < 128; i++) + { + uint64_t const offDisk = (pThis->uLcnMft << pThis->cClusterShift) + i * pThis->cbMftRecord; + int rc = RTVfsFileReadAt(pThis->hVfsBacking, offDisk, pRec->pbRec, pThis->cbMftRecord, NULL); + if (RT_SUCCESS(rc)) + { + pRec->TreeNode.Key = i; + rtfsNtfsMftRec_Log(pRec, pThis->cbMftRecord); + pRec->TreeNode.Key = 0; + } + } +#endif + + uint64_t const offDisk = pThis->uLcnMft << pThis->cClusterShift; + int rc = RTVfsFileReadAt(pThis->hVfsBacking, offDisk, pRec->pbRec, pThis->cbMftRecord, NULL); + if (RT_SUCCESS(rc)) + { + rc = rtFsNtfsRec_DoMultiSectorFixups(&pRec->pFileRec->Hdr, pThis->cbMftRecord, true, pErrInfo); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtfsNtfsMftRec_Log(pRec, pThis->cbMftRecord); +#endif + rc = rtFsNtfsVol_ParseMft(pThis, pRec, pErrInfo); + } + if (RT_SUCCESS(rc)) + { + PRTFSNTFSCORE pCore = pRec->pCore; + PRTFSNTFSATTR pMftData; + pThis->pMftData = pMftData = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_DATA); + if (pMftData) + { + /* + * Validate the '$Mft' MFT record. + */ + PNTFSATTRIBHDR pAttrHdr = pMftData->pAttrHdr; + if (!pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #0 unnamed DATA attribute is resident!"); + else if ( (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbAllocated) < pThis->cbMftRecord * 16U + || (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbAllocated) >= pThis->cbBacking) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute allocated size is out of range: %#RX64", + RT_LE2H_U64(pAttrHdr->u.NonRes.cbAllocated)); + else if ( (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbInitialized) < pThis->cbMftRecord * 16U + || (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbInitialized) >= pThis->cbBacking) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute initialized size is out of range: %#RX64", + RT_LE2H_U64(pAttrHdr->u.NonRes.cbInitialized)); + else if ( (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbData) < pThis->cbMftRecord * 16U + || (uint64_t)RT_LE2H_U64(pAttrHdr->u.NonRes.cbData) >= pThis->cbBacking) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute allocated size is out of range: %#RX64", + RT_LE2H_U64(pAttrHdr->u.NonRes.cbData)); + else if (pAttrHdr->u.NonRes.uCompressionUnit != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute is compressed: %#x", + pAttrHdr->u.NonRes.uCompressionUnit); + else if (pMftData->Extents.cExtents == 0) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute has no data on the disk"); + else if (pMftData->Extents.paExtents[0].off != offDisk) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 unnamed DATA attribute has a bogus disk offset: %#RX64, expected %#RX64", + pMftData->Extents.paExtents[0].off, offDisk); + else if (!rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_BITMAP)) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #0 has no unnamed BITMAP attribute!"); + else + { + PRTFSNTFSATTR pFilenameAttr = rtFsNtfsCore_FindUnnamedAttribute(pCore, NTFS_AT_FILENAME); + if (!pFilenameAttr) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #0 has no FILENAME attribute!"); + else if (pFilenameAttr->pAttrHdr->fNonResident) + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #0 FILENAME attribute is non-resident!"); + else if (pFilenameAttr->pAttrHdr->u.Res.cbValue < RT_UOFFSETOF(NTFSATFILENAME, wszFilename[4])) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 FILENAME attribute value size is too small: %#x", + pFilenameAttr->pAttrHdr->u.Res.cbValue); + else + { + PNTFSATFILENAME pFilename = (PNTFSATFILENAME)( (uint8_t *)pFilenameAttr->pAttrHdr + + pFilenameAttr->pAttrHdr->u.Res.offValue); + if ( pFilename->cwcFilename != 4 + || RTUtf16NICmpAscii(pFilename->wszFilename, "$Mft", 4) != 0) + rc = RTERRINFO_LOG_REL_SET_F(pErrInfo, VERR_VFS_BOGUS_FORMAT, + "MFT record #0 FILENAME isn't '$Mft': '%.*ls'", + pFilename->cwcFilename, pFilename->wszFilename); + else + { + /* + * Looks like we're good. Insert core record into the cache. + */ + RTListAppend(&pThis->CoreInUseHead, &pCore->ListEntry); + pThis->cbCoreObjects += pCore->cbCost; + + Assert(pCore->cRefs == 1); + Assert(pRec->cRefs == 2); + rtFsNtfsMftRec_Release(pRec, pThis); + + return VINF_SUCCESS; + } + } + } + pThis->pMftData = NULL; + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, VERR_VFS_BOGUS_FORMAT, "MFT record #0 has no unnamed DATA attribute!"); + } + if (pRec->pCore) + rtFsNtfsCore_Destroy(pRec->pCore); + rtFsNtfsMftRec_Release(pRec, pThis); + } + else + rc = RTERRINFO_LOG_REL_SET(pErrInfo, rc, "Error reading MFT record #0"); + return rc; +} + + +/** + * Loads the bootsector and parses it, copying values into the instance data. + * + * @returns IRPT status code. + * @param pThis The instance data. + * @param pvBuf The buffer. + * @param cbBuf The buffer size. + * @param pErrInfo Where to return additional error details. + */ +static int rtFsNtfsVolLoadAndParseBootsector(PRTFSNTFSVOL pThis, void *pvBuf, size_t cbBuf, PRTERRINFO pErrInfo) +{ + AssertReturn(cbBuf >= sizeof(FATBOOTSECTOR), VERR_INTERNAL_ERROR_2); + + /* + * Read the boot sector and check that it makes sense for a NTFS volume. + * + * Note! There are two potential backup locations of the boot sector, however we + * currently don't implement falling back on these on corruption/read errors. + */ + PFATBOOTSECTOR pBootSector = (PFATBOOTSECTOR)pvBuf; + int rc = RTVfsFileReadAt(pThis->hVfsBacking, 0, pBootSector, sizeof(*pBootSector), NULL); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading boot sector"); + + if (memcmp(pBootSector->achOemName, RT_STR_TUPLE(NTFS_OEM_ID_MAGIC)) != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "Not NTFS - OEM field mismatch: %.8Rhxs'", pBootSector->achOemName); + + /* Check must-be-zero BPB fields. */ + if (pBootSector->Bpb.Ntfs.Bpb.cReservedSectors != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - MBZ: BPB.cReservedSectors=%u", + RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cReservedSectors)); + if (pBootSector->Bpb.Ntfs.Bpb.cFats != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - MBZ: BPB.cFats=%u", + pBootSector->Bpb.Ntfs.Bpb.cFats); + if (pBootSector->Bpb.Ntfs.Bpb.cMaxRootDirEntries != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - MBZ: BPB.cMaxRootDirEntries=%u", + RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cMaxRootDirEntries)); + if (pBootSector->Bpb.Ntfs.Bpb.cTotalSectors16 != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - MBZ: BPB.cTotalSectors16=%u", + RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cTotalSectors16)); + if (pBootSector->Bpb.Ntfs.Bpb.cSectorsPerFat != 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - MBZ: BPB.cSectorsPerFat=%u", + RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cSectorsPerFat)); + + /* Check other relevant BPB fields. */ + uint32_t cbSector = RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cbSector); + if ( cbSector != 512 + && cbSector != 1024 + && cbSector != 2048 + && cbSector != 4096) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not NTFS - BPB.cbSector is ouf of range: %u", cbSector); + pThis->cbSector = cbSector; + Log2(("NTFS BPB: cbSector=%#x\n", cbSector)); + + uint32_t cClusterPerSector = RT_LE2H_U16(pBootSector->Bpb.Ntfs.Bpb.cSectorsPerCluster); + if ( !RT_IS_POWER_OF_TWO(cClusterPerSector) + || cClusterPerSector == 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, + "Not NTFS - BPB.cCluster is ouf of range: %u", cClusterPerSector); + + pThis->cbCluster = cClusterPerSector * cbSector; + if (pThis->cbCluster > _64K) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "cluster size exceeds 64KB: %#x", pThis->cbCluster); + pThis->cClusterShift = ASMBitFirstSetU32(pThis->cbCluster) - 1; + Log2(("NTFS BPB: cClusterPerSector=%#x => %#x bytes, %u shift\n", cClusterPerSector, pThis->cbCluster, pThis->cClusterShift)); + pThis->iMaxVirtualCluster = (uint64_t)INT64_MAX >> pThis->cClusterShift; + Log2(("NTFS BPB: iMaxVirtualCluster=%#RX64\n", pThis->iMaxVirtualCluster)); + + /* NTFS BPB: cSectors. */ + uint64_t cSectors = RT_LE2H_U64(pBootSector->Bpb.Ntfs.cSectors); + if (cSectors > pThis->cbBacking / pThis->cbSector) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS sector count exceeds volume size: %#RX64 vs %#RX64", + cSectors, pThis->cbBacking / pThis->cbSector); + if (cSectors < 256) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, "NTFS sector count too small: %#RX64", cSectors); + pThis->cbVolume = cSectors * pThis->cbSector; + pThis->cClusters = cSectors / cClusterPerSector; + Log2(("NTFS BPB: cSectors=%#RX64 => %#xu bytes (%Rhcb) => cClusters=%#RX64\n", + cSectors, pThis->cbVolume, pThis->cbVolume, pThis->cClusters)); + + /* NTFS BPB: MFT location. */ + uint64_t uLcn = RT_LE2H_U64(pBootSector->Bpb.Ntfs.uLcnMft); + if ( uLcn < 1 + || uLcn >= pThis->cClusters) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS MFT location is out of bounds: %#RX64 (%#RX64 clusters)", uLcn, pThis->cClusters); + pThis->uLcnMft = uLcn; + Log2(("NTFS BPB: uLcnMft=%#RX64 (byte offset %#RX64)\n", uLcn, uLcn << pThis->cClusterShift)); + + /* NTFS BPB: Mirror MFT location. */ + uLcn = RT_LE2H_U64(pBootSector->Bpb.Ntfs.uLcnMftMirror); + if ( uLcn < 1 + || uLcn >= pThis->cClusters) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS mirror MFT location is out of bounds: %#RX64 (%#RX64 clusters)", uLcn, pThis->cClusters); + pThis->uLcnMftMirror = uLcn; + Log2(("NTFS BPB: uLcnMftMirror=%#RX64 (byte offset %#RX64)\n", uLcn, uLcn << pThis->cClusterShift)); + + /* NTFS BPB: Size of MFT file record. */ + if (pBootSector->Bpb.Ntfs.cClustersPerMftRecord >= 0) + { + if ( !RT_IS_POWER_OF_TWO((uint32_t)pBootSector->Bpb.Ntfs.cClustersPerMftRecord) + || pBootSector->Bpb.Ntfs.cClustersPerMftRecord == 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS clusters-per-mft-record value is zero or not a power of two: %#x", + pBootSector->Bpb.Ntfs.cClustersPerMftRecord); + pThis->cbMftRecord = (uint32_t)pBootSector->Bpb.Ntfs.cClustersPerMftRecord << pThis->cClusterShift; + Assert(pThis->cbMftRecord == pBootSector->Bpb.Ntfs.cClustersPerMftRecord * pThis->cbCluster); + } + else if ( pBootSector->Bpb.Ntfs.cClustersPerMftRecord < -20 + || pBootSector->Bpb.Ntfs.cClustersPerMftRecord > -9) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS clusters-per-mft-record is out of shift range: %d", + pBootSector->Bpb.Ntfs.cClustersPerMftRecord); + else + pThis->cbMftRecord = UINT32_C(1) << -pBootSector->Bpb.Ntfs.cClustersPerMftRecord; + Log2(("NTFS BPB: cbMftRecord=%#x\n", pThis->cbMftRecord)); + if ( pThis->cbMftRecord > _32K + || pThis->cbMftRecord < 256) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "Unsupported NTFS MFT record size: %#x", pThis->cbMftRecord); + + /* NTFS BPB: Default index node size */ + if (pBootSector->Bpb.Ntfs.cClustersPerIndexNode >= 0) + { + if ( !RT_IS_POWER_OF_TWO((uint32_t)pBootSector->Bpb.Ntfs.cClustersPerIndexNode) + || pBootSector->Bpb.Ntfs.cClustersPerIndexNode == 0) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS default clusters-per-index-tree-node is zero or not a power of two: %#x", + pBootSector->Bpb.Ntfs.cClustersPerIndexNode); + pThis->cbDefaultIndexNode = (uint32_t)pBootSector->Bpb.Ntfs.cClustersPerIndexNode << pThis->cClusterShift; + Assert(pThis->cbDefaultIndexNode == pBootSector->Bpb.Ntfs.cClustersPerIndexNode * pThis->cbCluster); + } + else if ( pBootSector->Bpb.Ntfs.cClustersPerIndexNode < -32 + || pBootSector->Bpb.Ntfs.cClustersPerIndexNode > -9) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNSUPPORTED_FORMAT, + "NTFS default clusters-per-index-tree-node is out of shift range: %d", + pBootSector->Bpb.Ntfs.cClustersPerIndexNode); + else + pThis->cbDefaultIndexNode = UINT32_C(1) << -pBootSector->Bpb.Ntfs.cClustersPerMftRecord; + Log2(("NTFS BPB: cbDefaultIndexNode=%#x\n", pThis->cbDefaultIndexNode)); + + pThis->uSerialNo = RT_LE2H_U64(pBootSector->Bpb.Ntfs.uSerialNumber); + Log2(("NTFS BPB: uSerialNo=%#x\n", pThis->uSerialNo)); + + + return VINF_SUCCESS; +} + + +RTDECL(int) RTFsNtfsVolOpen(RTVFSFILE hVfsFileIn, uint32_t fMntFlags, uint32_t fNtfsFlags, PRTVFS phVfs, PRTERRINFO pErrInfo) +{ + AssertPtrReturn(phVfs, VERR_INVALID_POINTER); + AssertReturn(!(fMntFlags & ~RTVFSMNT_F_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(!fNtfsFlags, VERR_INVALID_FLAGS); + + uint32_t cRefs = RTVfsFileRetain(hVfsFileIn); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a VFS instance and initialize the data so rtFsNtfsVol_Close works. + */ + RTVFS hVfs; + PRTFSNTFSVOL pThis; + int rc = RTVfsNew(&g_rtFsNtfsVolOps, sizeof(*pThis), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis); + if (RT_SUCCESS(rc)) + { + pThis->hVfsBacking = hVfsFileIn; + pThis->hVfsSelf = hVfs; + pThis->fMntFlags = fMntFlags; + pThis->fNtfsFlags = fNtfsFlags; + RTListInit(&pThis->CoreInUseHead); + RTListInit(&pThis->CoreUnusedHead); + RTListInit(&pThis->IdxNodeUnusedHead); + + rc = RTVfsFileGetSize(pThis->hVfsBacking, &pThis->cbBacking); + if (RT_SUCCESS(rc)) + { + void *pvBuf = RTMemTmpAlloc(_64K); + if (pvBuf) + { + rc = rtFsNtfsVolLoadAndParseBootsector(pThis, pvBuf, _64K, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolLoadMft(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolLoadVolumeInfo(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolLoadBitmap(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolLoadUpCase(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsNtfsVolLoadRootDir(pThis, pErrInfo); + RTMemTmpFree(pvBuf); + if (RT_SUCCESS(rc)) + { + *phVfs = hVfs; + return VINF_SUCCESS; + } + } + else + rc = VERR_NO_TMP_MEMORY; + } + + RTVfsRelease(hVfs); + *phVfs = NIL_RTVFS; + } + else + RTVfsFileRelease(hVfsFileIn); + + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate} + */ +static DECLCALLBACK(int) rtVfsChainNtfsVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec, + PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg); + + /* + * Basic checks. + */ + if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE) + return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE; + if ( pElement->enmType != RTVFSOBJTYPE_VFS + && pElement->enmType != RTVFSOBJTYPE_DIR) + return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS; + if (pElement->cArgs > 1) + return VERR_VFS_CHAIN_AT_MOST_ONE_ARG; + + /* + * Parse the flag if present, save in pElement->uProvider. + */ + bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ; + if (pElement->cArgs > 0) + { + const char *psz = pElement->paArgs[0].psz; + if (*psz) + { + if (!strcmp(psz, "ro")) + fReadOnly = true; + else if (!strcmp(psz, "rw")) + fReadOnly = false; + else + { + *poffError = pElement->paArgs[0].offSpec; + return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument"); + } + } + } + + pElement->uProvider = fReadOnly ? RTVFSMNT_F_READ_ONLY : 0; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate} + */ +static DECLCALLBACK(int) rtVfsChainNtfsVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec, + PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj, + PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec, poffError); + + int rc; + RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj); + if (hVfsFileIn != NIL_RTVFSFILE) + { + RTVFS hVfs; + rc = RTFsNtfsVolOpen(hVfsFileIn, (uint32_t)pElement->uProvider, (uint32_t)(pElement->uProvider >> 32), &hVfs, pErrInfo); + RTVfsFileRelease(hVfsFileIn); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromVfs(hVfs); + RTVfsRelease(hVfs); + if (*phVfsObj != NIL_RTVFSOBJ) + return VINF_SUCCESS; + rc = VERR_VFS_CHAIN_CAST_FAILED; + } + } + else + rc = VERR_VFS_CHAIN_CAST_FAILED; + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement} + */ +static DECLCALLBACK(bool) rtVfsChainNtfsVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg, + PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement, + PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement) +{ + RT_NOREF(pProviderReg, pSpec, pReuseSpec); + if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider + || !pReuseElement->paArgs[0].uProvider) + return true; + return false; +} + + +/** VFS chain element 'file'. */ +static RTVFSCHAINELEMENTREG g_rtVfsChainNtfsVolReg = +{ + /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION, + /* fReserved = */ 0, + /* pszName = */ "ntfs", + /* ListEntry = */ { NULL, NULL }, + /* pszHelp = */ "Open a NTFS file system, requires a file object on the left side.\n" + "First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n", + /* pfnValidate = */ rtVfsChainNtfsVol_Validate, + /* pfnInstantiate = */ rtVfsChainNtfsVol_Instantiate, + /* pfnCanReuseElement = */ rtVfsChainNtfsVol_CanReuseElement, + /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION +}; + +RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainNtfsVolReg, rtVfsChainNtfsVolReg); + diff --git a/src/VBox/Runtime/common/fs/xfsvfs.cpp b/src/VBox/Runtime/common/fs/xfsvfs.cpp new file mode 100644 index 00000000..84432e35 --- /dev/null +++ b/src/VBox/Runtime/common/fs/xfsvfs.cpp @@ -0,0 +1,2240 @@ +/* $Id: xfsvfs.cpp $ */ +/** @file + * IPRT - XFS Virtual Filesystem. + */ + +/* + * Copyright (C) 2018-2019 Oracle Corporation + * + * This file is part of VirtualBox Open Source Edition (OSE), as + * available from http://www.virtualbox.org. This file is free software; + * you can redistribute it and/or modify it under the terms of the GNU + * General Public License (GPL) as published by the Free Software + * Foundation, in version 2 as it comes in the "COPYING" file of the + * VirtualBox OSE distribution. VirtualBox OSE is distributed in the + * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL) only, as it comes in the "COPYING.CDDL" file of the + * VirtualBox OSE distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_FS +#include <iprt/fsvfs.h> + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/avl.h> +#include <iprt/file.h> +#include <iprt/err.h> +#include <iprt/list.h> +#include <iprt/log.h> +#include <iprt/mem.h> +#include <iprt/string.h> +#include <iprt/vfs.h> +#include <iprt/vfslowlevel.h> +#include <iprt/formats/xfs.h> + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** The maximum allocation group cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSXFS_MAX_AG_CACHE_SIZE _512K +#else +# define RTFSXFS_MAX_AG_CACHE_SIZE _128K +#endif +/** The maximum inode cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSXFS_MAX_INODE_CACHE_SIZE _512K +#else +# define RTFSXFS_MAX_INODE_CACHE_SIZE _128K +#endif +/** The maximum extent tree cache size (in bytes). */ +#if ARCH_BITS >= 64 +# define RTFSXFS_MAX_BLOCK_CACHE_SIZE _512K +#else +# define RTFSXFS_MAX_BLOCK_CACHE_SIZE _128K +#endif + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** Pointer to the XFS filesystem data. */ +typedef struct RTFSXFSVOL *PRTFSXFSVOL; + + +/** + * Cached allocation group descriptor data. + */ +typedef struct RTFSXFSAG +{ + /** AVL tree node, indexed by the allocation group number. */ + AVLU32NODECORE Core; + /** List node for the LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** @todo */ +} RTFSXFSAG; +/** Pointer to allocation group descriptor data. */ +typedef RTFSXFSAG *PRTFSXFSAG; + + +/** + * In-memory inode. + */ +typedef struct RTFSXFSINODE +{ + /** AVL tree node, indexed by the inode number. */ + AVLU64NODECORE Core; + /** List node for the inode LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** Byte offset in the backing file where the inode is stored.. */ + uint64_t offInode; + /** Inode data. */ + RTFSOBJINFO ObjInfo; + /** Inode data fork format. */ + uint8_t enmFormat; + /** Inode flags. */ + uint16_t fFlags; +} RTFSXFSINODE; +/** Pointer to an in-memory inode. */ +typedef RTFSXFSINODE *PRTFSXFSINODE; + + +/** + * Block cache entry. + */ +typedef struct RTFSXFSBLOCKENTRY +{ + /** AVL tree node, indexed by the filesystem block number. */ + AVLU64NODECORE Core; + /** List node for the inode LRU list used for eviction. */ + RTLISTNODE NdLru; + /** Reference counter. */ + volatile uint32_t cRefs; + /** The block data. */ + uint8_t abData[1]; +} RTFSXFSBLOCKENTRY; +/** Pointer to a block cache entry. */ +typedef RTFSXFSBLOCKENTRY *PRTFSXFSBLOCKENTRY; + + +/** + * Open directory instance. + */ +typedef struct RTFSXFSDIR +{ + /** Volume this directory belongs to. */ + PRTFSXFSVOL pVol; + /** The underlying inode structure. */ + PRTFSXFSINODE pInode; + /** Set if we've reached the end of the directory enumeration. */ + bool fNoMoreFiles; + /** Current offset into the directory where the next entry should be read. */ + uint64_t offEntry; + /** Next entry index (for logging purposes). */ + uint32_t idxEntry; +} RTFSXFSDIR; +/** Pointer to an open directory instance. */ +typedef RTFSXFSDIR *PRTFSXFSDIR; + + +/** + * Open file instance. + */ +typedef struct RTFSXFSFILE +{ + /** Volume this directory belongs to. */ + PRTFSXFSVOL pVol; + /** The underlying inode structure. */ + PRTFSXFSINODE pInode; + /** Current offset into the file for I/O. */ + RTFOFF offFile; +} RTFSXFSFILE; +/** Pointer to an open file instance. */ +typedef RTFSXFSFILE *PRTFSXFSFILE; + + +/** + * XFS filesystem volume. + */ +typedef struct RTFSXFSVOL +{ + /** Handle to itself. */ + RTVFS hVfsSelf; + /** The file, partition, or whatever backing the ext volume. */ + RTVFSFILE hVfsBacking; + /** The size of the backing thingy. */ + uint64_t cbBacking; + + /** RTVFSMNT_F_XXX. */ + uint32_t fMntFlags; + /** RTFSXFSVFS_F_XXX (currently none defined). */ + uint32_t fXfsFlags; + + /** Size of one sector. */ + size_t cbSector; + /** Size of one block. */ + size_t cbBlock; + /** Number of bits to shift for converting a block number to byte offset. */ + uint32_t cBlockShift; + /** Number of blocks per allocation group. */ + XFSAGNUMBER cBlocksPerAg; + /** Number of blocks per allocation group as log2. */ + uint32_t cAgBlocksLog; + /** Number of allocation groups for this volume. */ + uint32_t cAgs; + /** inode of the root directory. */ + XFSINO uInodeRoot; + /** Inode size in bytes. */ + size_t cbInode; + /** Number of inodes per block. */ + uint32_t cInodesPerBlock; + /** Number of inodes per block as log2. */ + uint32_t cInodesPerBlockLog; + + /** @name Allocation group cache. + * @{ */ + /** LRU list anchor. */ + RTLISTANCHOR LstAgLru; + /** Root of the cached allocation group tree. */ + AVLU32TREE AgRoot; + /** Size of the cached allocation groups. */ + size_t cbAgs; + /** @} */ + + /** @name Inode cache. + * @{ */ + /** LRU list anchor for the inode cache. */ + RTLISTANCHOR LstInodeLru; + /** Root of the cached inode tree. */ + AVLU64TREE InodeRoot; + /** Size of the cached inodes. */ + size_t cbInodes; + /** @} */ + + /** @name Block cache. + * @{ */ + /** LRU list anchor for the block cache. */ + RTLISTANCHOR LstBlockLru; + /** Root of the cached block tree. */ + AVLU64TREE BlockRoot; + /** Size of cached blocks. */ + size_t cbBlocks; + /** @} */ +} RTFSXFSVOL; + + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +static int rtFsXfsVol_OpenDirByInode(PRTFSXFSVOL pThis, uint32_t iInode, PRTVFSDIR phVfsDir); + +#ifdef LOG_ENABLED +/** + * Logs the XFS filesystem superblock. + * + * @returns nothing. + * @param iAg The allocation group number for the given super block. + * @param pSb Pointer to the superblock. + */ +static void rtFsXfsSb_Log(uint32_t iAg, PCXFSSUPERBLOCK pSb) +{ + if (LogIs2Enabled()) + { + Log2(("XFS: Superblock %#RX32:\n", iAg)); + Log2(("XFS: u32Magic %#RX32\n", RT_BE2H_U32(pSb->u32Magic))); + Log2(("XFS: cbBlock %RU32\n", RT_BE2H_U32(pSb->cbBlock))); + Log2(("XFS: cBlocks %RU64\n", RT_BE2H_U64(pSb->cBlocks))); + Log2(("XFS: cBlocksRtDev %RU64\n", RT_BE2H_U64(pSb->cBlocksRtDev))); + Log2(("XFS: cExtentsRtDev %RU64\n", RT_BE2H_U64(pSb->cExtentsRtDev))); + Log2(("XFS: abUuid <todo>\n")); + Log2(("XFS: uBlockJournal %#RX64\n", RT_BE2H_U64(pSb->uBlockJournal))); + Log2(("XFS: uInodeRoot %#RX64\n", RT_BE2H_U64(pSb->uInodeRoot))); + Log2(("XFS: uInodeBitmapRtExt %#RX64\n", RT_BE2H_U64(pSb->uInodeBitmapRtExt))); + Log2(("XFS: uInodeBitmapSummary %#RX64\n", RT_BE2H_U64(pSb->uInodeBitmapSummary))); + Log2(("XFS: cRtExtent %RU32\n", RT_BE2H_U32(pSb->cRtExtent))); + Log2(("XFS: cAgBlocks %RU32\n", RT_BE2H_U32(pSb->cAgBlocks))); + Log2(("XFS: cAg %RU32\n", RT_BE2H_U32(pSb->cAg))); + Log2(("XFS: cRtBitmapBlocks %RU32\n", RT_BE2H_U32(pSb->cRtBitmapBlocks))); + Log2(("XFS: cJournalBlocks %RU32\n", RT_BE2H_U32(pSb->cJournalBlocks))); + Log2(("XFS: fVersion %#RX16%s%s%s%s%s%s%s%s%s%s%s\n", RT_BE2H_U16(pSb->fVersion), + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_ATTR ? " attr" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_NLINK ? " nlink" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_QUOTA ? " quota" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_ALIGN ? " align" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_DALIGN ? " dalign" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_SHARED ? " shared" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_LOGV2 ? " logv2" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_SECTOR ? " sector" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_EXTFLG ? " extflg" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_DIRV2 ? " dirv2" : "", + RT_BE2H_U16(pSb->fVersion) & XFS_SB_VERSION_F_FEAT2 ? " feat2" : "")); + Log2(("XFS: cbSector %RU16\n", RT_BE2H_U16(pSb->cbSector))); + Log2(("XFS: cbInode %RU16\n", RT_BE2H_U16(pSb->cbInode))); + Log2(("XFS: cIndoesPerBlock %RU16\n", RT_BE2H_U16(pSb->cInodesPerBlock))); + Log2(("XFS: achFsName %12s\n", &pSb->achFsName[0])); + Log2(("XFS: cBlockSzLog %RU8\n", pSb->cBlockSzLog)); + Log2(("XFS: cSectorSzLog %RU8\n", pSb->cSectorSzLog)); + Log2(("XFS: cInodeSzLog %RU8\n", pSb->cInodeSzLog)); + Log2(("XFS: cInodesPerBlockLog %RU8\n", pSb->cInodesPerBlockLog)); + Log2(("XFS: cAgBlocksLog %RU8\n", pSb->cAgBlocksLog)); + Log2(("XFS: cExtentsRtDevLog %RU8\n", pSb->cExtentsRtDevLog)); + Log2(("XFS: fInProgress %RU8\n", pSb->fInProgress)); + Log2(("XFS: cInodeMaxPct %RU8\n", pSb->cInodeMaxPct)); + Log2(("XFS: cInodesGlobal %#RX64\n", RT_BE2H_U64(pSb->cInodesGlobal))); + Log2(("XFS: cInodesGlobalFree %#RX64\n", RT_BE2H_U64(pSb->cInodesGlobalFree))); + Log2(("XFS: cBlocksFree %#RX64\n", RT_BE2H_U64(pSb->cBlocksFree))); + Log2(("XFS: cExtentsRtFree %#RX64\n", RT_BE2H_U64(pSb->cExtentsRtFree))); + Log2(("XFS: uInodeQuotaUsr %#RX64\n", RT_BE2H_U64(pSb->uInodeQuotaUsr))); + Log2(("XFS: uInodeQuotaGrp %#RX64\n", RT_BE2H_U64(pSb->uInodeQuotaGrp))); + Log2(("XFS: fQuotaFlags %#RX16\n", RT_BE2H_U16(pSb->fQuotaFlags))); + Log2(("XFS: fFlagsMisc %#RX8\n", pSb->fFlagsMisc)); + Log2(("XFS: uSharedVn %#RX8\n", pSb->uSharedVn)); + Log2(("XFS: cBlocksInodeAlignment %#RX32\n", RT_BE2H_U32(pSb->cBlocksInodeAlignment))); + Log2(("XFS: cBlocksRaidStripe %#RX32\n", RT_BE2H_U32(pSb->cBlocksRaidStripe))); + Log2(("XFS: cBlocksRaidWidth %#RX32\n", RT_BE2H_U32(pSb->cBlocksRaidWidth))); + Log2(("XFS: cDirBlockAllocLog %RU8\n", pSb->cDirBlockAllocLog)); + Log2(("XFS: cLogDevSubVolSectorSzLog %RU8\n", pSb->cLogDevSubVolSectorSzLog)); + Log2(("XFS: cLogDevSectorSzLog %RU16\n", RT_BE2H_U16(pSb->cLogDevSectorSzLog))); + Log2(("XFS: cLogDevRaidStripe %RU32\n", RT_BE2H_U32(pSb->cLogDevRaidStripe))); + Log2(("XFS: fFeatures2 %#RX32\n", RT_BE2H_U32(pSb->fFeatures2))); + Log2(("XFS: fFeaturesRw %#RX32\n", RT_BE2H_U32(pSb->fFeaturesRw))); + Log2(("XFS: fFeaturesRo %#RX32\n", RT_BE2H_U32(pSb->fFeaturesRo))); + Log2(("XFS: fFeaturesIncompatRw %#RX32\n", RT_BE2H_U32(pSb->fFeaturesIncompatRw))); + Log2(("XFS: fFeaturesJrnlIncompatRw %#RX32\n", RT_BE2H_U32(pSb->fFeaturesJrnlIncompatRw))); + Log2(("XFS: u32Chksum %#RX32\n", RT_BE2H_U32(pSb->u32Chksum))); + Log2(("XFS: u32SparseInodeAlignment %#RX32\n", RT_BE2H_U32(pSb->u32SparseInodeAlignment))); + Log2(("XFS: uInodeProjectQuota %#RX64\n", RT_BE2H_U64(pSb->uInodeProjectQuota))); + Log2(("XFS: uJrnlSeqSbUpdate %#RX64\n", RT_BE2H_U64(pSb->uJrnlSeqSbUpdate))); + Log2(("XFS: abUuidMeta <todo>\n")); + Log2(("XFS: uInodeRm %#RX64\n", RT_BE2H_U64(pSb->uInodeRm))); + } +} + + +/** + * Logs a AG free space block. + * + * @returns nothing. + * @param iAg The allocation group number for the given free space block. + * @param pAgf The AG free space block. + */ +static void rtFsXfsAgf_Log(uint32_t iAg, PCXFSAGF pAgf) +{ + if (LogIs2Enabled()) + { + Log2(("XFS: AGF %#RX32:\n", iAg)); + Log2(("XFS: u32Magic %#RX32\n", RT_BE2H_U32(pAgf->u32Magic))); + Log2(("XFS: uVersion %#RX32\n", RT_BE2H_U32(pAgf->uVersion))); + Log2(("XFS: uSeqNo %#RX32\n", RT_BE2H_U32(pAgf->uSeqNo))); + Log2(("XFS: cLengthBlocks %#RX32\n", RT_BE2H_U32(pAgf->cLengthBlocks))); + Log2(("XFS: auRoots[0] %#RX32\n", RT_BE2H_U32(pAgf->auRoots[0]))); + Log2(("XFS: auRoots[1] %#RX32\n", RT_BE2H_U32(pAgf->auRoots[1]))); + Log2(("XFS: auRoots[2] %#RX32\n", RT_BE2H_U32(pAgf->auRoots[2]))); + Log2(("XFS: acLvls[0] %RU32\n", RT_BE2H_U32(pAgf->acLvls[0]))); + Log2(("XFS: acLvls[1] %RU32\n", RT_BE2H_U32(pAgf->acLvls[1]))); + Log2(("XFS: acLvls[2] %RU32\n", RT_BE2H_U32(pAgf->acLvls[2]))); + Log2(("XFS: idxFreeListFirst %RU32\n", RT_BE2H_U32(pAgf->idxFreeListFirst))); + Log2(("XFS: idxFreeListLast %RU32\n", RT_BE2H_U32(pAgf->idxFreeListLast))); + Log2(("XFS: cFreeListBlocks %RU32\n", RT_BE2H_U32(pAgf->cFreeListBlocks))); + Log2(("XFS: cFreeBlocks %RU32\n", RT_BE2H_U32(pAgf->cFreeBlocks))); + Log2(("XFS: cFreeBlocksLongest %RU32\n", RT_BE2H_U32(pAgf->cFreeBlocksLongest))); + Log2(("XFS: cBlocksBTrees %RU32\n", RT_BE2H_U32(pAgf->cBlocksBTrees))); + Log2(("XFS: abUuid <todo>\n")); + Log2(("XFS: cBlocksRevMap %RU32\n", RT_BE2H_U32(pAgf->cBlocksRevMap))); + Log2(("XFS: cBlocksRefcountBTree %RU32\n", RT_BE2H_U32(pAgf->cBlocksRefcountBTree))); + Log2(("XFS: uRootRefcount %#RX32\n", RT_BE2H_U32(pAgf->uRootRefcount))); + Log2(("XFS: cLvlRefcount %RU32\n", RT_BE2H_U32(pAgf->cLvlRefcount))); + Log2(("XFS: uSeqNoLastWrite %#RX64\n", RT_BE2H_U64(pAgf->uSeqNoLastWrite))); + Log2(("XFS: uChkSum %#RX32\n", RT_BE2H_U32(pAgf->uChkSum))); + } +} + + +/** + * Loads an AG inode information block. + * + * @returns nothing. + * @param iAg The allocation group number for the given inode information block. + * @param pAgi The AG inode information block. + */ +static void rtFsXfsAgi_Log(uint32_t iAg, PCXFSAGI pAgi) +{ + if (LogIs2Enabled()) + { + Log2(("XFS: AGI %#RX32:\n", iAg)); + Log2(("XFS: u32Magic %#RX32\n", RT_BE2H_U32(pAgi->u32Magic))); + Log2(("XFS: uVersion %#RX32\n", RT_BE2H_U32(pAgi->uVersion))); + Log2(("XFS: uSeqNo %#RX32\n", RT_BE2H_U32(pAgi->uSeqNo))); + Log2(("XFS: cLengthBlocks %#RX32\n", RT_BE2H_U32(pAgi->cLengthBlocks))); + Log2(("XFS: cInodesAlloc %#RX32\n", RT_BE2H_U32(pAgi->cInodesAlloc))); + Log2(("XFS: uRootInode %#RX32\n", RT_BE2H_U32(pAgi->uRootInode))); + Log2(("XFS: cLvlsInode %RU32\n", RT_BE2H_U32(pAgi->cLvlsInode))); + Log2(("XFS: uInodeNew %#RX32\n", RT_BE2H_U32(pAgi->uInodeNew))); + Log2(("XFS: uInodeDir %#RX32\n", RT_BE2H_U32(pAgi->uInodeDir))); + Log2(("XFS: au32HashUnlinked[0..63] <todo>\n")); + Log2(("XFS: abUuid <todo>\n")); + Log2(("XFS: uChkSum %#RX32\n", RT_BE2H_U32(pAgi->uChkSum))); + Log2(("XFS: uSeqNoLastWrite %#RX64\n", RT_BE2H_U64(pAgi->uSeqNoLastWrite))); + Log2(("XFS: uRootFreeInode %#RX32\n", RT_BE2H_U32(pAgi->uRootFreeInode))); + Log2(("XFS: cLvlsFreeInode %RU32\n", RT_BE2H_U32(pAgi->cLvlsFreeInode))); + } +} + + +/** + * Logs a XFS filesystem inode. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param iInode Inode number. + * @param pInode Pointer to the inode. + */ +static void rtFsXfsInode_Log(PRTFSXFSVOL pThis, XFSINO iInode, PCXFSINODECORE pInode) +{ + RT_NOREF(pThis); + + if (LogIs2Enabled()) + { + RTTIMESPEC Spec; + char sz[80]; + + Log2(("XFS: Inode %#RX64:\n", iInode)); + Log2(("XFS: u16Magic %#RX16\n", RT_BE2H_U16(pInode->u16Magic))); + Log2(("XFS: fMode %#RX16\n", RT_BE2H_U16(pInode->fMode))); + Log2(("XFS: iVersion %#RX8\n", pInode->iVersion)); + Log2(("XFS: enmFormat %#RX8\n", pInode->enmFormat)); + Log2(("XFS: cOnLinks %RU16\n", RT_BE2H_U16(pInode->cOnLinks))); + Log2(("XFS: uUid %#RX32\n", RT_BE2H_U32(pInode->uUid))); + Log2(("XFS: uGid %#RX32\n", RT_BE2H_U32(pInode->uGid))); + Log2(("XFS: cLinks %#RX32\n", RT_BE2H_U32(pInode->cLinks))); + Log2(("XFS: uProjIdLow %#RX16\n", RT_BE2H_U16(pInode->uProjIdLow))); + Log2(("XFS: uProjIdHigh %#RX16\n", RT_BE2H_U16(pInode->uProjIdHigh))); + Log2(("XFS: cFlush %RU16\n", RT_BE2H_U16(pInode->cFlush))); + Log2(("XFS: TsLastAccessed %#RX32:%#RX32 %s\n", RT_BE2H_U32(pInode->TsLastAccessed.cSecEpoch), + RT_BE2H_U32(pInode->TsLastAccessed.cNanoSec), + RTTimeSpecToString(RTTimeSpecAddNano(RTTimeSpecSetSeconds(&Spec, RT_BE2H_U32(pInode->TsLastAccessed.cSecEpoch)), + RT_BE2H_U32(pInode->TsLastAccessed.cNanoSec)), + sz, sizeof(sz)))); + Log2(("XFS: TsLastModified %#RX32:%#RX32 %s\n", RT_BE2H_U32(pInode->TsLastModified.cSecEpoch), + RT_BE2H_U32(pInode->TsLastModified.cNanoSec), + RTTimeSpecToString(RTTimeSpecAddNano(RTTimeSpecSetSeconds(&Spec, RT_BE2H_U32(pInode->TsLastModified.cSecEpoch)), + RT_BE2H_U32(pInode->TsLastModified.cNanoSec)), + sz, sizeof(sz)))); + Log2(("XFS: TsCreatedModified %#RX32:%#RX32 %s\n", RT_BE2H_U32(pInode->TsCreatedModified.cSecEpoch), + RT_BE2H_U32(pInode->TsCreatedModified.cNanoSec), + RTTimeSpecToString(RTTimeSpecAddNano(RTTimeSpecSetSeconds(&Spec, RT_BE2H_U32(pInode->TsCreatedModified.cSecEpoch)), + RT_BE2H_U32(pInode->TsCreatedModified.cNanoSec)), + sz, sizeof(sz)))); + Log2(("XFS: cbInode %#RX64\n", RT_BE2H_U64(pInode->cbInode))); + Log2(("XFS: cBlocks %#RX64\n", RT_BE2H_U64(pInode->cBlocks))); + Log2(("XFS: cExtentBlocksMin %#RX32\n", RT_BE2H_U32(pInode->cExtentBlocksMin))); + Log2(("XFS: cExtentsData %#RX32\n", RT_BE2H_U32(pInode->cExtentsData))); + Log2(("XFS: cExtentsAttr %#RX16\n", RT_BE2H_U16(pInode->cExtentsAttr))); + Log2(("XFS: offAttrFork %#RX8\n", pInode->offAttrFork)); + Log2(("XFS: enmFormatAttr %#RX8\n", pInode->enmFormatAttr)); + Log2(("XFS: fEvtMaskDmig %#RX32\n", RT_BE2H_U32(pInode->fEvtMaskDmig))); + Log2(("XFS: uStateDmig %#RX16\n", RT_BE2H_U16(pInode->uStateDmig))); + Log2(("XFS: fFlags %#RX16\n", RT_BE2H_U16(pInode->fFlags))); + Log2(("XFS: cGeneration %#RX32\n", RT_BE2H_U32(pInode->cGeneration))); + Log2(("XFS: offBlockUnlinkedNext %#RX32\n", RT_BE2H_U32(pInode->offBlockUnlinkedNext))); + Log2(("XFS: uChkSum %#RX32\n", RT_BE2H_U32(pInode->uChkSum))); + Log2(("XFS: cAttrChanges %#RX64\n", RT_BE2H_U64(pInode->cAttrChanges))); + Log2(("XFS: uFlushSeqNo %#RX64\n", RT_BE2H_U64(pInode->uFlushSeqNo))); + Log2(("XFS: fFlags2 %#RX64\n", RT_BE2H_U64(pInode->fFlags2))); + Log2(("XFS: cExtentCowMin %#RX32\n", RT_BE2H_U32(pInode->cExtentCowMin))); + Log2(("XFS: TsCreation %#RX32:%#RX32 %s\n", RT_BE2H_U32(pInode->TsCreation.cSecEpoch), + RT_BE2H_U32(pInode->TsCreation.cNanoSec), + RTTimeSpecToString(RTTimeSpecAddNano(RTTimeSpecSetSeconds(&Spec, RT_BE2H_U32(pInode->TsCreation.cSecEpoch)), + RT_BE2H_U32(pInode->TsCreation.cNanoSec)), + sz, sizeof(sz)))); + Log2(("XFS: uInode %#RX64\n", RT_BE2H_U64(pInode->uInode))); + Log2(("XFS: abUuid <todo>\n")); + } +} + + +#if 0 +/** + * Logs a XFS filesystem directory entry. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param idxDirEntry Directory entry index number. + * @param pDirEntry The directory entry. + */ +static void rtFsXfsDirEntry_Log(PRTFSXFSVOL pThis, uint32_t idxDirEntry, PCXFSDIRENTRYEX pDirEntry) +{ + if (LogIs2Enabled()) + { + } +} +#endif +#endif + + +/** + * Converts a block number to a byte offset. + * + * @returns Offset in bytes for the given block number. + * @param pThis The XFS volume instance. + * @param iBlock The block number to convert. + */ +DECLINLINE(uint64_t) rtFsXfsBlockIdxToDiskOffset(PRTFSXFSVOL pThis, uint64_t iBlock) +{ + return iBlock << pThis->cBlockShift; +} + + +/** + * Converts a byte offset to a block number. + * + * @returns Block number. + * @param pThis The XFS volume instance. + * @param iBlock The offset to convert. + */ +DECLINLINE(uint64_t) rtFsXfsDiskOffsetToBlockIdx(PRTFSXFSVOL pThis, uint64_t off) +{ + return off >> pThis->cBlockShift; +} + + +/** + * Splits the given absolute inode number into the AG number, block inside the AG + * and the offset into the block where to find the inode structure. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param iInode The inode to split. + * @param piAg Where to store the AG number. + * @param puBlock Where to store the block number inside the AG. + * @param poffBlock Where to store the offset into the block. + */ +DECLINLINE(void) rtFsXfsInodeSplitAbs(PRTFSXFSVOL pThis, XFSINO iInode, + uint32_t *piAg, uint32_t *puBlock, + uint32_t *poffBlock) +{ + *poffBlock = iInode & (pThis->cInodesPerBlock - 1); + iInode >>= pThis->cInodesPerBlockLog; + *puBlock = iInode & (RT_BIT_32(pThis->cAgBlocksLog) - 1); /* Using the log2 value here as it is rounded. */ + iInode >>= RT_BIT_32(pThis->cAgBlocksLog) - 1; + *piAg = (uint32_t)iInode; +} + + +/** + * Allocates a new block group. + * + * @returns Pointer to the new block group descriptor or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param cbAlloc How much to allocate. + * @param iBlockGroup Block group number. + */ +static PRTFSXFSBLOCKENTRY rtFsXfsVol_BlockAlloc(PRTFSXFSVOL pThis, size_t cbAlloc, uint64_t iBlock) +{ + PRTFSXFSBLOCKENTRY pBlock = (PRTFSXFSBLOCKENTRY)RTMemAllocZ(cbAlloc); + if (RT_LIKELY(pBlock)) + { + pBlock->Core.Key = iBlock; + pBlock->cRefs = 0; + pThis->cbBlocks += cbAlloc; + } + + return pBlock; +} + + +/** + * Returns a new block entry utilizing the cache if possible. + * + * @returns Pointer to the new block entry or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param iBlock Block number. + */ +static PRTFSXFSBLOCKENTRY rtFsXfsVol_BlockGetNew(PRTFSXFSVOL pThis, uint64_t iBlock) +{ + PRTFSXFSBLOCKENTRY pBlock = NULL; + size_t cbAlloc = RT_UOFFSETOF_DYN(RTFSXFSBLOCKENTRY, abData[pThis->cbBlock]); + if (pThis->cbBlocks + cbAlloc <= RTFSXFS_MAX_BLOCK_CACHE_SIZE) + pBlock = rtFsXfsVol_BlockAlloc(pThis, cbAlloc, iBlock); + else + { + pBlock = RTListRemoveLast(&pThis->LstBlockLru, RTFSXFSBLOCKENTRY, NdLru); + if (!pBlock) + pBlock = rtFsXfsVol_BlockAlloc(pThis, cbAlloc, iBlock); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->BlockRoot, pBlock->Core.Key); + Assert(pCore == &pBlock->Core); RT_NOREF(pCore); + } + } + + Assert(!pBlock->cRefs); + pBlock->Core.Key = iBlock; + pBlock->cRefs = 1; + + return pBlock; +} + + +/** + * Frees the given block. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pBlock The block to free. + */ +static void rtFsXfsVol_BlockFree(PRTFSXFSVOL pThis, PRTFSXFSBLOCKENTRY pBlock) +{ + Assert(!pBlock->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the block group + * is freed right away. + */ + if (pThis->cbBlocks <= RTFSXFS_MAX_BLOCK_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstBlockLru, &pBlock->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->BlockRoot, pBlock->Core.Key); + Assert(pCore == &pBlock->Core); RT_NOREF(pCore); + RTMemFree(pBlock); + pThis->cbBlocks -= RT_UOFFSETOF_DYN(RTFSXFSBLOCKENTRY, abData[pThis->cbBlock]); + } +} + + +/** + * Gets the specified block data from the volume. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param iBlock The filesystem block to load. + * @param ppBlock Where to return the pointer to the block entry on success. + * @param ppvData Where to return the pointer to the block data on success. + */ +static int rtFsXfsVol_BlockLoad(PRTFSXFSVOL pThis, uint64_t iBlock, PRTFSXFSBLOCKENTRY *ppBlock, void **ppvData) +{ + int rc = VINF_SUCCESS; + + /* Try to fetch the block group from the cache first. */ + PRTFSXFSBLOCKENTRY pBlock = (PRTFSXFSBLOCKENTRY)RTAvlU64Get(&pThis->BlockRoot, iBlock); + if (!pBlock) + { + /* Slow path, load from disk. */ + pBlock = rtFsXfsVol_BlockGetNew(pThis, iBlock); + if (RT_LIKELY(pBlock)) + { + uint64_t offRead = rtFsXfsBlockIdxToDiskOffset(pThis, iBlock); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &pBlock->abData[0], pThis->cbBlock, NULL); + if (RT_SUCCESS(rc)) + { + bool fIns = RTAvlU64Insert(&pThis->BlockRoot, &pBlock->Core); + Assert(fIns); RT_NOREF(fIns); + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pBlock->cRefs); + if (cRefs == 1) /* Blocks get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pBlock->NdLru); + } + + if (RT_SUCCESS(rc)) + { + *ppBlock = pBlock; + *ppvData = &pBlock->abData[0]; + } + else if (pBlock) + { + ASMAtomicDecU32(&pBlock->cRefs); + rtFsXfsVol_BlockFree(pThis, pBlock); /* Free the block. */ + } + + return rc; +} + + +/** + * Releases a reference of the given block. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pBlock The block to release. + */ +static void rtFsXfsVol_BlockRelease(PRTFSXFSVOL pThis, PRTFSXFSBLOCKENTRY pBlock) +{ + uint32_t cRefs = ASMAtomicDecU32(&pBlock->cRefs); + if (!cRefs) + rtFsXfsVol_BlockFree(pThis, pBlock); +} + + +/** + * Allocates a new alloction group. + * + * @returns Pointer to the new allocation group descriptor or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param iAG Allocation group number. + */ +static PRTFSXFSAG rtFsXfsAg_Alloc(PRTFSXFSVOL pThis, uint32_t iAg) +{ + PRTFSXFSAG pAg = (PRTFSXFSAG)RTMemAllocZ(sizeof(RTFSXFSAG)); + if (RT_LIKELY(pAg)) + { + pAg->Core.Key = iAg; + pAg->cRefs = 0; + pThis->cbAgs += sizeof(RTFSXFSAG); + } + + return pAg; +} + + +/** + * Frees the given allocation group. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pAg The allocation group to free. + */ +static void rtFsXfsAg_Free(PRTFSXFSVOL pThis, PRTFSXFSAG pAg) +{ + Assert(!pAg->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the allocation group + * is freed right away. + */ + if (pThis->cbAgs <= RTFSXFS_MAX_AG_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstAgLru, &pAg->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->AgRoot, pAg->Core.Key); + Assert(pCore == &pAg->Core); RT_NOREF(pCore); + RTMemFree(pAg); + pThis->cbAgs -= sizeof(RTFSXFSAG); + } +} + + +/** + * Returns a new block group utilizing the cache if possible. + * + * @returns Pointer to the new block group descriptor or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param iAg Allocation group number. + */ +static PRTFSXFSAG rtFsXfsAg_GetNew(PRTFSXFSVOL pThis, uint32_t iAg) +{ + PRTFSXFSAG pAg = NULL; + if (pThis->cbAgs + sizeof(RTFSXFSAG) <= RTFSXFS_MAX_AG_CACHE_SIZE) + pAg = rtFsXfsAg_Alloc(pThis, iAg); + else + { + pAg = RTListRemoveLast(&pThis->LstAgLru, RTFSXFSAG, NdLru); + if (!pAg) + pAg = rtFsXfsAg_Alloc(pThis, iAg); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU32NODECORE pCore = RTAvlU32Remove(&pThis->AgRoot, pAg->Core.Key); + Assert(pCore == &pAg->Core); RT_NOREF(pCore); + } + } + + Assert(!pAg->cRefs); + pAg->Core.Key = iAg; + pAg->cRefs = 1; + + return pAg; +} + + +/** + * Loads the given allocation group number and returns it on success. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param iAg The allocation group to load. + * @param ppAg Where to store the allocation group on success. + */ +static int rtFsXfsAg_Load(PRTFSXFSVOL pThis, uint32_t iAg, PRTFSXFSAG *ppAg) +{ + int rc = VINF_SUCCESS; + + AssertReturn(iAg < pThis->cAgs, VERR_VFS_BOGUS_FORMAT); + + /* Try to fetch the allocation group from the cache first. */ + PRTFSXFSAG pAg = (PRTFSXFSAG)RTAvlU32Get(&pThis->AgRoot, iAg); + if (!pAg) + { + /* Slow path, load from disk. */ + pAg = rtFsXfsAg_GetNew(pThis, iAg); + if (RT_LIKELY(pAg)) + { + uint64_t offRead = rtFsXfsBlockIdxToDiskOffset(pThis, iAg * pThis->cBlocksPerAg); + XFSSUPERBLOCK Sb; + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &Sb, sizeof(Sb), NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsXfsSb_Log(iAg, &Sb); +#endif + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pAg->cRefs); + if (cRefs == 1) /* Block groups get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pAg->NdLru); + } + + if (RT_SUCCESS(rc)) + *ppAg = pAg; + else if (pAg) + { + ASMAtomicDecU32(&pAg->cRefs); + rtFsXfsAg_Free(pThis, pAg); /* Free the allocation group. */ + } + + return rc; +} + + +/** + * Releases a reference of the given allocation group. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pAg The allocation group to release. + */ +static void rtFsXfsAg_Release(PRTFSXFSVOL pThis, PRTFSXFSAG pAg) +{ + uint32_t cRefs = ASMAtomicDecU32(&pAg->cRefs); + if (!cRefs) + rtFsXfsAg_Free(pThis, pAg); +} + + +/** + * Allocates a new inode. + * + * @returns Pointer to the new inode or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param iInode Inode number. + */ +static PRTFSXFSINODE rtFsXfsInode_Alloc(PRTFSXFSVOL pThis, uint32_t iInode) +{ + PRTFSXFSINODE pInode = (PRTFSXFSINODE)RTMemAllocZ(sizeof(RTFSXFSINODE)); + if (RT_LIKELY(pInode)) + { + pInode->Core.Key = iInode; + pInode->cRefs = 0; + pThis->cbInodes += sizeof(RTFSXFSINODE); + } + + return pInode; +} + + +/** + * Frees the given inode. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pInode The inode to free. + */ +static void rtFsXfsInode_Free(PRTFSXFSVOL pThis, PRTFSXFSINODE pInode) +{ + Assert(!pInode->cRefs); + + /* + * Put it into the cache if the limit wasn't exceeded, otherwise the inode + * is freed right away. + */ + if (pThis->cbInodes <= RTFSXFS_MAX_INODE_CACHE_SIZE) + { + /* Put onto the LRU list. */ + RTListPrepend(&pThis->LstInodeLru, &pInode->NdLru); + } + else + { + /* Remove from the tree and free memory. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->InodeRoot, pInode->Core.Key); + Assert(pCore == &pInode->Core); RT_NOREF(pCore); + RTMemFree(pInode); + pThis->cbInodes -= sizeof(RTFSXFSINODE); + } +} + + +/** + * Returns a new inodep utilizing the cache if possible. + * + * @returns Pointer to the new inode or NULL if out of memory. + * @param pThis The XFS volume instance. + * @param iInode Inode number. + */ +static PRTFSXFSINODE rtFsXfsInode_GetNew(PRTFSXFSVOL pThis, XFSINO iInode) +{ + PRTFSXFSINODE pInode = NULL; + if (pThis->cbInodes + sizeof(RTFSXFSINODE) <= RTFSXFS_MAX_INODE_CACHE_SIZE) + pInode = rtFsXfsInode_Alloc(pThis, iInode); + else + { + pInode = RTListRemoveLast(&pThis->LstInodeLru, RTFSXFSINODE, NdLru); + if (!pInode) + pInode = rtFsXfsInode_Alloc(pThis, iInode); + else + { + /* Remove the block group from the tree because it gets a new key. */ + PAVLU64NODECORE pCore = RTAvlU64Remove(&pThis->InodeRoot, pInode->Core.Key); + Assert(pCore == &pInode->Core); RT_NOREF(pCore); + } + } + + Assert(!pInode->cRefs); + pInode->Core.Key = iInode; + pInode->cRefs = 1; + + return pInode; +} + + +/** + * Loads the given inode number and returns it on success. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param iInode The inode to load. + * @param ppInode Where to store the inode on success. + */ +static int rtFsXfsInode_Load(PRTFSXFSVOL pThis, XFSINO iInode, PRTFSXFSINODE *ppInode) +{ + int rc = VINF_SUCCESS; + + /* Try to fetch the inode from the cache first. */ + PRTFSXFSINODE pInode = (PRTFSXFSINODE)RTAvlU64Get(&pThis->InodeRoot, iInode); + if (!pInode) + { + /* Slow path, load from disk. */ + pInode = rtFsXfsInode_GetNew(pThis, iInode); + if (RT_LIKELY(pInode)) + { + uint32_t iAg; + uint32_t uBlock; + uint32_t offBlock; + + rtFsXfsInodeSplitAbs(pThis, iInode, &iAg, &uBlock, &offBlock); + + uint64_t offRead = (iAg * pThis->cBlocksPerAg + uBlock) * pThis->cbBlock + offBlock; + XFSINODECORE Inode; + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead, &Inode, RT_MIN(sizeof(Inode), pThis->cbInode), NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsXfsInode_Log(pThis, iInode, &Inode); +#endif + + pInode->offInode = offRead; + pInode->fFlags = RT_BE2H_U16(Inode.fFlags); + pInode->enmFormat = Inode.enmFormat; + pInode->ObjInfo.cbObject = RT_BE2H_U64(Inode.cbInode); + pInode->ObjInfo.cbAllocated = RT_BE2H_U64(Inode.cBlocks) * pThis->cbBlock; + RTTimeSpecSetSeconds(&pInode->ObjInfo.AccessTime, RT_BE2H_U32(Inode.TsLastAccessed.cSecEpoch)); + RTTimeSpecAddNano(&pInode->ObjInfo.AccessTime, RT_BE2H_U32(Inode.TsLastAccessed.cNanoSec)); + RTTimeSpecSetSeconds(&pInode->ObjInfo.ModificationTime, RT_BE2H_U32(Inode.TsLastModified.cSecEpoch)); + RTTimeSpecAddNano(&pInode->ObjInfo.ModificationTime, RT_BE2H_U32(Inode.TsLastModified.cNanoSec)); + RTTimeSpecSetSeconds(&pInode->ObjInfo.ChangeTime, RT_BE2H_U32(Inode.TsCreatedModified.cSecEpoch)); + RTTimeSpecAddNano(&pInode->ObjInfo.ChangeTime, RT_BE2H_U32(Inode.TsCreatedModified.cNanoSec)); + pInode->ObjInfo.Attr.enmAdditional = RTFSOBJATTRADD_UNIX; + pInode->ObjInfo.Attr.u.Unix.uid = RT_BE2H_U32(Inode.uUid); + pInode->ObjInfo.Attr.u.Unix.gid = RT_BE2H_U32(Inode.uGid); + pInode->ObjInfo.Attr.u.Unix.cHardlinks = RT_BE2H_U16(Inode.cOnLinks); /** @todo v2 inodes. */ + pInode->ObjInfo.Attr.u.Unix.INodeIdDevice = 0; + pInode->ObjInfo.Attr.u.Unix.INodeId = iInode; + pInode->ObjInfo.Attr.u.Unix.fFlags = 0; + pInode->ObjInfo.Attr.u.Unix.GenerationId = RT_BE2H_U32(Inode.cGeneration); + pInode->ObjInfo.Attr.u.Unix.Device = 0; + if (Inode.iVersion >= 3) + { + RTTimeSpecSetSeconds(&pInode->ObjInfo.BirthTime, RT_BE2H_U32(Inode.TsCreation.cSecEpoch)); + RTTimeSpecAddNano(&pInode->ObjInfo.BirthTime, RT_BE2H_U32(Inode.TsCreation.cNanoSec)); + } + else + pInode->ObjInfo.BirthTime = pInode->ObjInfo.ChangeTime; + + /* Fill in the mode. */ + pInode->ObjInfo.Attr.fMode = 0; + uint16_t fInodeMode = RT_BE2H_U16(Inode.fMode); + switch (XFS_INODE_MODE_TYPE_GET_TYPE(fInodeMode)) + { + case XFS_INODE_MODE_TYPE_FIFO: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_FIFO; + break; + case XFS_INODE_MODE_TYPE_CHAR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DEV_CHAR; + break; + case XFS_INODE_MODE_TYPE_DIR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DIRECTORY; + break; + case XFS_INODE_MODE_TYPE_BLOCK: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_DEV_BLOCK; + break; + case XFS_INODE_MODE_TYPE_REGULAR: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_FILE; + break; + case XFS_INODE_MODE_TYPE_SYMLINK: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_SYMLINK; + break; + case XFS_INODE_MODE_TYPE_SOCKET: + pInode->ObjInfo.Attr.fMode |= RTFS_TYPE_SOCKET; + break; + default: + rc = VERR_VFS_BOGUS_FORMAT; + } + if (fInodeMode & XFS_INODE_MODE_EXEC_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXOTH; + if (fInodeMode & XFS_INODE_MODE_WRITE_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWOTH; + if (fInodeMode & XFS_INODE_MODE_READ_OTHER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IROTH; + if (fInodeMode & XFS_INODE_MODE_EXEC_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXGRP; + if (fInodeMode & XFS_INODE_MODE_WRITE_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWGRP; + if (fInodeMode & XFS_INODE_MODE_READ_GROUP) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IRGRP; + if (fInodeMode & XFS_INODE_MODE_EXEC_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IXUSR; + if (fInodeMode & XFS_INODE_MODE_WRITE_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IWUSR; + if (fInodeMode & XFS_INODE_MODE_READ_OWNER) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_IRUSR; + if (fInodeMode & XFS_INODE_MODE_STICKY) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISTXT; + if (fInodeMode & XFS_INODE_MODE_SET_GROUP_ID) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISGID; + if (fInodeMode & XFS_INODE_MODE_SET_USER_ID) + pInode->ObjInfo.Attr.fMode |= RTFS_UNIX_ISUID; + } + } + else + rc = VERR_NO_MEMORY; + } + else + { + /* Remove from current LRU list position and add to the beginning. */ + uint32_t cRefs = ASMAtomicIncU32(&pInode->cRefs); + if (cRefs == 1) /* Inodes get removed from the LRU list if they are referenced. */ + RTListNodeRemove(&pInode->NdLru); + } + + if (RT_SUCCESS(rc)) + *ppInode = pInode; + else if (pInode) + { + ASMAtomicDecU32(&pInode->cRefs); + rtFsXfsInode_Free(pThis, pInode); /* Free the inode. */ + } + + return rc; +} + + +/** + * Releases a reference of the given inode. + * + * @returns nothing. + * @param pThis The XFS volume instance. + * @param pInode The inode to release. + */ +static void rtFsXfsInode_Release(PRTFSXFSVOL pThis, PRTFSXFSINODE pInode) +{ + uint32_t cRefs = ASMAtomicDecU32(&pInode->cRefs); + if (!cRefs) + rtFsXfsInode_Free(pThis, pInode); +} + + +/** + * Worker for various QueryInfo methods. + * + * @returns IPRT status code. + * @param pInode The inode structure to return info for. + * @param pObjInfo Where to return object info. + * @param enmAddAttr What additional info to return. + */ +static int rtFsXfsInode_QueryInfo(PRTFSXFSINODE pInode, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_ZERO(*pObjInfo); + + pObjInfo->cbObject = pInode->ObjInfo.cbObject; + pObjInfo->cbAllocated = pInode->ObjInfo.cbAllocated; + pObjInfo->AccessTime = pInode->ObjInfo.AccessTime; + pObjInfo->ModificationTime = pInode->ObjInfo.ModificationTime; + pObjInfo->ChangeTime = pInode->ObjInfo.ChangeTime; + pObjInfo->BirthTime = pInode->ObjInfo.BirthTime; + pObjInfo->Attr.fMode = pInode->ObjInfo.Attr.fMode; + pObjInfo->Attr.enmAdditional = enmAddAttr; + switch (enmAddAttr) + { + case RTFSOBJATTRADD_UNIX: + memcpy(&pObjInfo->Attr.u.Unix, &pInode->ObjInfo.Attr.u.Unix, sizeof(pInode->ObjInfo.Attr.u.Unix)); + break; + + case RTFSOBJATTRADD_UNIX_OWNER: + pObjInfo->Attr.u.UnixOwner.uid = pInode->ObjInfo.Attr.u.Unix.uid; + break; + + case RTFSOBJATTRADD_UNIX_GROUP: + pObjInfo->Attr.u.UnixGroup.gid = pInode->ObjInfo.Attr.u.Unix.gid; + break; + + default: + break; + } + + return VINF_SUCCESS; +} + + +/** + * Maps the given inode block to the destination filesystem block. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param pInode The inode structure to read from. + * @param iBlock The inode block to map. + * @param cBlocks Number of blocks requested. + * @param piBlockFs Where to store the filesystem block on success. + * @param pcBlocks Where to store the number of contiguous blocks on success. + * @param pfSparse Where to store the sparse flag on success. + * + * @todo Optimize + */ +static int rtFsXfsInode_MapBlockToFs(PRTFSXFSVOL pThis, PRTFSXFSINODE pInode, uint64_t iBlock, size_t cBlocks, + uint64_t *piBlockFs, size_t *pcBlocks, bool *pfSparse) +{ + RT_NOREF(pThis, pInode, iBlock, cBlocks, piBlockFs, pcBlocks, pfSparse); + return VERR_NOT_IMPLEMENTED; +} + + +/** + * Reads data from the given inode at the given byte offset. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param pInode The inode structure to read from. + * @param off The byte offset to start reading from. + * @param pvBuf Where to store the read data to. + * @param pcbRead Where to return the amount of data read. + */ +static int rtFsXfsInode_Read(PRTFSXFSVOL pThis, PRTFSXFSINODE pInode, uint64_t off, void *pvBuf, size_t cbRead, size_t *pcbRead) +{ + int rc = VINF_SUCCESS; + uint8_t *pbBuf = (uint8_t *)pvBuf; + + if (((uint64_t)pInode->ObjInfo.cbObject < off + cbRead)) + { + if (!pcbRead) + return VERR_EOF; + else + cbRead = (uint64_t)pInode->ObjInfo.cbObject - off; + } + + while ( cbRead + && RT_SUCCESS(rc)) + { + uint64_t iBlockStart = rtFsXfsDiskOffsetToBlockIdx(pThis, off); + uint32_t offBlockStart = off % pThis->cbBlock; + + /* Resolve the inode block to the proper filesystem block. */ + uint64_t iBlockFs = 0; + size_t cBlocks = 0; + bool fSparse = false; + rc = rtFsXfsInode_MapBlockToFs(pThis, pInode, iBlockStart, 1, &iBlockFs, &cBlocks, &fSparse); + if (RT_SUCCESS(rc)) + { + Assert(cBlocks == 1); + + size_t cbThisRead = RT_MIN(cbRead, pThis->cbBlock - offBlockStart); + + if (!fSparse) + { + uint64_t offRead = rtFsXfsBlockIdxToDiskOffset(pThis, iBlockFs); + rc = RTVfsFileReadAt(pThis->hVfsBacking, offRead + offBlockStart, pbBuf, cbThisRead, NULL); + } + else + memset(pbBuf, 0, cbThisRead); + + if (RT_SUCCESS(rc)) + { + pbBuf += cbThisRead; + cbRead -= cbThisRead; + off += cbThisRead; + if (pcbRead) + *pcbRead += cbThisRead; + } + } + } + + return rc; +} + + + +/* + * + * File operations. + * File operations. + * File operations. + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsXfsFile_Close(void *pvThis) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + LogFlow(("rtFsXfsFile_Close(%p/%p)\n", pThis, pThis->pInode)); + + rtFsXfsInode_Release(pThis->pVol, pThis->pInode); + pThis->pInode = NULL; + pThis->pVol = NULL; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsXfsFile_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + return rtFsXfsInode_QueryInfo(pThis->pInode, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnRead} + */ +static DECLCALLBACK(int) rtFsXfsFile_Read(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbRead) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + AssertReturn(pSgBuf->cSegs == 1, VERR_INTERNAL_ERROR_3); + RT_NOREF(fBlocking); + + if (off == -1) + off = pThis->offFile; + else + AssertReturn(off >= 0, VERR_INTERNAL_ERROR_3); + + int rc; + size_t cbRead = pSgBuf->paSegs[0].cbSeg; + if (!pcbRead) + { + rc = rtFsXfsInode_Read(pThis->pVol, pThis->pInode, (uint64_t)off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + if (RT_SUCCESS(rc)) + pThis->offFile = off + cbRead; + Log6(("rtFsXfsFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc\n", off, pSgBuf->paSegs[0].cbSeg, rc)); + } + else + { + PRTFSXFSINODE pInode = pThis->pInode; + if (off >= pInode->ObjInfo.cbObject) + { + *pcbRead = 0; + rc = VINF_EOF; + } + else + { + if ((uint64_t)off + cbRead <= (uint64_t)pInode->ObjInfo.cbObject) + rc = rtFsXfsInode_Read(pThis->pVol, pThis->pInode, (uint64_t)off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + else + { + /* Return VINF_EOF if beyond end-of-file. */ + cbRead = (size_t)(pInode->ObjInfo.cbObject - off); + rc = rtFsXfsInode_Read(pThis->pVol, pThis->pInode, off, pSgBuf->paSegs[0].pvSeg, cbRead, NULL); + if (RT_SUCCESS(rc)) + rc = VINF_EOF; + } + if (RT_SUCCESS(rc)) + { + pThis->offFile = off + cbRead; + *pcbRead = cbRead; + } + else + *pcbRead = 0; + } + Log6(("rtFsXfsFile_Read: off=%#RX64 cbSeg=%#x -> %Rrc *pcbRead=%#x\n", off, pSgBuf->paSegs[0].cbSeg, rc, *pcbRead)); + } + + return rc; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnWrite} + */ +static DECLCALLBACK(int) rtFsXfsFile_Write(void *pvThis, RTFOFF off, PCRTSGBUF pSgBuf, bool fBlocking, size_t *pcbWritten) +{ + RT_NOREF(pvThis, off, pSgBuf, fBlocking, pcbWritten); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnFlush} + */ +static DECLCALLBACK(int) rtFsXfsFile_Flush(void *pvThis) +{ + RT_NOREF(pvThis); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSIOSTREAMOPS,pfnTell} + */ +static DECLCALLBACK(int) rtFsXfsFile_Tell(void *pvThis, PRTFOFF poffActual) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + *poffActual = pThis->offFile; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsXfsFile_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsXfsFile_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsXfsFile_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSeek} + */ +static DECLCALLBACK(int) rtFsXfsFile_Seek(void *pvThis, RTFOFF offSeek, unsigned uMethod, PRTFOFF poffActual) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + RTFOFF offNew; + switch (uMethod) + { + case RTFILE_SEEK_BEGIN: + offNew = offSeek; + break; + case RTFILE_SEEK_END: + offNew = pThis->pInode->ObjInfo.cbObject + offSeek; + break; + case RTFILE_SEEK_CURRENT: + offNew = (RTFOFF)pThis->offFile + offSeek; + break; + default: + return VERR_INVALID_PARAMETER; + } + if (offNew >= 0) + { + pThis->offFile = offNew; + *poffActual = offNew; + return VINF_SUCCESS; + } + return VERR_NEGATIVE_SEEK; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQuerySize} + */ +static DECLCALLBACK(int) rtFsXfsFile_QuerySize(void *pvThis, uint64_t *pcbFile) +{ + PRTFSXFSFILE pThis = (PRTFSXFSFILE)pvThis; + *pcbFile = (uint64_t)pThis->pInode->ObjInfo.cbObject; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnSetSize} + */ +static DECLCALLBACK(int) rtFsXfsFile_SetSize(void *pvThis, uint64_t cbFile, uint32_t fFlags) +{ + RT_NOREF(pvThis, cbFile, fFlags); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSFILEOPS,pfnQueryMaxSize} + */ +static DECLCALLBACK(int) rtFsXfsFile_QueryMaxSize(void *pvThis, uint64_t *pcbMax) +{ + RT_NOREF(pvThis); + *pcbMax = INT64_MAX; /** @todo */ + return VINF_SUCCESS; +} + + +/** + * XFS file operations. + */ +static const RTVFSFILEOPS g_rtFsXfsFileOps = +{ + { /* Stream */ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_FILE, + "XFS File", + rtFsXfsFile_Close, + rtFsXfsFile_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSIOSTREAMOPS_VERSION, + RTVFSIOSTREAMOPS_FEAT_NO_SG, + rtFsXfsFile_Read, + rtFsXfsFile_Write, + rtFsXfsFile_Flush, + NULL /*PollOne*/, + rtFsXfsFile_Tell, + NULL /*pfnSkip*/, + NULL /*pfnZeroFill*/, + RTVFSIOSTREAMOPS_VERSION, + }, + RTVFSFILEOPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSFILEOPS, ObjSet) - RT_UOFFSETOF(RTVFSFILEOPS, Stream.Obj), + rtFsXfsFile_SetMode, + rtFsXfsFile_SetTimes, + rtFsXfsFile_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsXfsFile_Seek, + rtFsXfsFile_QuerySize, + rtFsXfsFile_SetSize, + rtFsXfsFile_QueryMaxSize, + RTVFSFILEOPS_VERSION +}; + + +/** + * Creates a new VFS file from the given regular file inode. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param fOpen Open flags passed. + * @param iInode The inode for the file. + * @param phVfsFile Where to store the VFS file handle on success. + * @param pErrInfo Where to record additional error information on error, optional. + * @param pszWhat Logging prefix. + */ +static int rtFsXfsVol_NewFile(PRTFSXFSVOL pThis, uint64_t fOpen, uint32_t iInode, + PRTVFSFILE phVfsFile, PRTERRINFO pErrInfo, const char *pszWhat) +{ + /* + * Load the inode and check that it really is a file. + */ + PRTFSXFSINODE pInode = NULL; + int rc = rtFsXfsInode_Load(pThis, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_FILE(pInode->ObjInfo.Attr.fMode)) + { + PRTFSXFSFILE pNewFile; + rc = RTVfsNewFile(&g_rtFsXfsFileOps, sizeof(*pNewFile), fOpen, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsFile, (void **)&pNewFile); + if (RT_SUCCESS(rc)) + { + pNewFile->pVol = pThis; + pNewFile->pInode = pInode; + pNewFile->offFile = 0; + } + } + else + rc = RTERRINFO_LOG_SET_F(pErrInfo, VERR_NOT_A_FILE, "%s: fMode=%#RX32", pszWhat, pInode->ObjInfo.Attr.fMode); + + if (RT_FAILURE(rc)) + rtFsXfsInode_Release(pThis, pInode); + } + + return rc; +} + + + +/* + * + * XFS directory code. + * XFS directory code. + * XFS directory code. + * + */ + +/** + * Looks up an entry in the given directory inode. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param pInode The directory inode structure to. + * @param pszEntry The entry to lookup. + * @param piInode Where to store the inode number if the entry was found. + */ +static int rtFsXfsDir_Lookup(PRTFSXFSVOL pThis, PRTFSXFSINODE pInode, const char *pszEntry, uint32_t *piInode) +{ + uint64_t offEntry = 0; + int rc = VERR_FILE_NOT_FOUND; + uint32_t idxDirEntry = 0; + size_t cchEntry = strlen(pszEntry); + + if (cchEntry > 255) + return VERR_FILENAME_TOO_LONG; + + RT_NOREF(pThis, idxDirEntry, offEntry, pInode, piInode); + +#if 0 /** @todo */ + while (offEntry < (uint64_t)pInode->ObjInfo.cbObject) + { + EXTDIRENTRYEX DirEntry; + size_t cbThis = RT_MIN(sizeof(DirEntry), (uint64_t)pInode->ObjInfo.cbObject - offEntry); + int rc2 = rtFsXfsInode_Read(pThis, pInode, offEntry, &DirEntry, cbThis, NULL); + if (RT_SUCCESS(rc2)) + { +#ifdef LOG_ENABLED + rtFsExtDirEntry_Log(pThis, idxDirEntry, &DirEntry); +#endif + + uint16_t cbName = pThis->fFeaturesIncompat & EXT_SB_FEAT_INCOMPAT_DIR_FILETYPE + ? DirEntry.Core.u.v2.cbName + : RT_LE2H_U16(DirEntry.Core.u.v1.cbName); + if ( cchEntry == cbName + && !memcmp(pszEntry, &DirEntry.Core.achName[0], cchEntry)) + { + *piInode = RT_LE2H_U32(DirEntry.Core.iInodeRef); + rc = VINF_SUCCESS; + break; + } + + offEntry += RT_LE2H_U16(DirEntry.Core.cbRecord); + idxDirEntry++; + } + else + { + rc = rc2; + break; + } + } +#endif + return rc; +} + + + +/* + * + * Directory instance methods + * Directory instance methods + * Directory instance methods + * + */ + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnClose} + */ +static DECLCALLBACK(int) rtFsXfsDir_Close(void *pvThis) +{ + PRTFSXFSDIR pThis = (PRTFSXFSDIR)pvThis; + LogFlowFunc(("pThis=%p\n", pThis)); + rtFsXfsInode_Release(pThis->pVol, pThis->pInode); + pThis->pInode = NULL; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsXfsDir_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + PRTFSXFSDIR pThis = (PRTFSXFSDIR)pvThis; + LogFlowFunc(("\n")); + return rtFsXfsInode_QueryInfo(pThis->pInode, pObjInfo, enmAddAttr); +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnMode} + */ +static DECLCALLBACK(int) rtFsXfsDir_SetMode(void *pvThis, RTFMODE fMode, RTFMODE fMask) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, fMode, fMask); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetTimes} + */ +static DECLCALLBACK(int) rtFsXfsDir_SetTimes(void *pvThis, PCRTTIMESPEC pAccessTime, PCRTTIMESPEC pModificationTime, + PCRTTIMESPEC pChangeTime, PCRTTIMESPEC pBirthTime) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, pAccessTime, pModificationTime, pChangeTime, pBirthTime); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSOBJSETOPS,pfnSetOwner} + */ +static DECLCALLBACK(int) rtFsXfsDir_SetOwner(void *pvThis, RTUID uid, RTGID gid) +{ + LogFlowFunc(("\n")); + RT_NOREF(pvThis, uid, gid); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpen} + */ +static DECLCALLBACK(int) rtFsXfsDir_Open(void *pvThis, const char *pszEntry, uint64_t fOpen, + uint32_t fFlags, PRTVFSOBJ phVfsObj) +{ + LogFlowFunc(("pszEntry='%s' fOpen=%#RX64 fFlags=%#x\n", pszEntry, fOpen, fFlags)); + PRTFSXFSDIR pThis = (PRTFSXFSDIR)pvThis; + PRTFSXFSVOL pVol = pThis->pVol; + int rc = VINF_SUCCESS; + + RT_NOREF(pThis, pVol, phVfsObj, pszEntry, fFlags); + + /* + * We cannot create or replace anything, just open stuff. + */ + if ( (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN + || (fOpen & RTFILE_O_ACTION_MASK) == RTFILE_O_OPEN_CREATE) + { /* likely */ } + else + return VERR_WRITE_PROTECT; + + /* + * Lookup the entry. + */ + uint32_t iInode = 0; + rc = rtFsXfsDir_Lookup(pVol, pThis->pInode, pszEntry, &iInode); + if (RT_SUCCESS(rc)) + { + PRTFSXFSINODE pInode = NULL; + rc = rtFsXfsInode_Load(pVol, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(pInode->ObjInfo.Attr.fMode)) + { + RTVFSDIR hVfsDir; + rc = rtFsXfsVol_OpenDirByInode(pVol, iInode, &hVfsDir); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromDir(hVfsDir); + RTVfsDirRelease(hVfsDir); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else if (RTFS_IS_FILE(pInode->ObjInfo.Attr.fMode)) + { + RTVFSFILE hVfsFile; + rc = rtFsXfsVol_NewFile(pVol, fOpen, iInode, &hVfsFile, NULL, pszEntry); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromFile(hVfsFile); + RTVfsFileRelease(hVfsFile); + AssertStmt(*phVfsObj != NIL_RTVFSOBJ, rc = VERR_INTERNAL_ERROR_3); + } + } + else + rc = VERR_NOT_SUPPORTED; + } + } + + LogFlow(("rtFsXfsDir_Open(%s): returns %Rrc\n", pszEntry, rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateDir} + */ +static DECLCALLBACK(int) rtFsXfsDir_CreateDir(void *pvThis, const char *pszSubDir, RTFMODE fMode, PRTVFSDIR phVfsDir) +{ + RT_NOREF(pvThis, pszSubDir, fMode, phVfsDir); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnOpenSymlink} + */ +static DECLCALLBACK(int) rtFsXfsDir_OpenSymlink(void *pvThis, const char *pszSymlink, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, phVfsSymlink); + LogFlowFunc(("\n")); + return VERR_NOT_SUPPORTED; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnCreateSymlink} + */ +static DECLCALLBACK(int) rtFsXfsDir_CreateSymlink(void *pvThis, const char *pszSymlink, const char *pszTarget, + RTSYMLINKTYPE enmType, PRTVFSSYMLINK phVfsSymlink) +{ + RT_NOREF(pvThis, pszSymlink, pszTarget, enmType, phVfsSymlink); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnUnlinkEntry} + */ +static DECLCALLBACK(int) rtFsXfsDir_UnlinkEntry(void *pvThis, const char *pszEntry, RTFMODE fType) +{ + RT_NOREF(pvThis, pszEntry, fType); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRenameEntry} + */ +static DECLCALLBACK(int) rtFsXfsDir_RenameEntry(void *pvThis, const char *pszEntry, RTFMODE fType, const char *pszNewName) +{ + RT_NOREF(pvThis, pszEntry, fType, pszNewName); + LogFlowFunc(("\n")); + return VERR_WRITE_PROTECT; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnRewindDir} + */ +static DECLCALLBACK(int) rtFsXfsDir_RewindDir(void *pvThis) +{ + PRTFSXFSDIR pThis = (PRTFSXFSDIR)pvThis; + LogFlowFunc(("\n")); + + pThis->fNoMoreFiles = false; + pThis->offEntry = 0; + pThis->idxEntry = 0; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSDIROPS,pfnReadDir} + */ +static DECLCALLBACK(int) rtFsXfsDir_ReadDir(void *pvThis, PRTDIRENTRYEX pDirEntry, size_t *pcbDirEntry, + RTFSOBJATTRADD enmAddAttr) +{ + PRTFSXFSDIR pThis = (PRTFSXFSDIR)pvThis; + PRTFSXFSINODE pInode = pThis->pInode; + LogFlowFunc(("\n")); + + if (pThis->fNoMoreFiles) + return VERR_NO_MORE_FILES; + + RT_NOREF(pInode, pDirEntry, pcbDirEntry, enmAddAttr); + return VERR_NOT_IMPLEMENTED; +} + + +/** + * XFS directory operations. + */ +static const RTVFSDIROPS g_rtFsXfsDirOps = +{ + { /* Obj */ + RTVFSOBJOPS_VERSION, + RTVFSOBJTYPE_DIR, + "XFS Dir", + rtFsXfsDir_Close, + rtFsXfsDir_QueryInfo, + RTVFSOBJOPS_VERSION + }, + RTVFSDIROPS_VERSION, + 0, + { /* ObjSet */ + RTVFSOBJSETOPS_VERSION, + RT_UOFFSETOF(RTVFSDIROPS, ObjSet) - RT_UOFFSETOF(RTVFSDIROPS, Obj), + rtFsXfsDir_SetMode, + rtFsXfsDir_SetTimes, + rtFsXfsDir_SetOwner, + RTVFSOBJSETOPS_VERSION + }, + rtFsXfsDir_Open, + NULL /* pfnFollowAbsoluteSymlink */, + NULL /* pfnOpenFile */, + NULL /* pfnOpenDir */, + rtFsXfsDir_CreateDir, + rtFsXfsDir_OpenSymlink, + rtFsXfsDir_CreateSymlink, + NULL /* pfnQueryEntryInfo */, + rtFsXfsDir_UnlinkEntry, + rtFsXfsDir_RenameEntry, + rtFsXfsDir_RewindDir, + rtFsXfsDir_ReadDir, + RTVFSDIROPS_VERSION, +}; + + +/** + * Opens a directory by the given inode. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param iInode The inode to open. + * @param phVfsDir Where to store the handle to the VFS directory on success. + */ +static int rtFsXfsVol_OpenDirByInode(PRTFSXFSVOL pThis, uint32_t iInode, PRTVFSDIR phVfsDir) +{ + PRTFSXFSINODE pInode = NULL; + int rc = rtFsXfsInode_Load(pThis, iInode, &pInode); + if (RT_SUCCESS(rc)) + { + if (RTFS_IS_DIRECTORY(pInode->ObjInfo.Attr.fMode)) + { + PRTFSXFSDIR pNewDir; + rc = RTVfsNewDir(&g_rtFsXfsDirOps, sizeof(*pNewDir), 0 /*fFlags*/, pThis->hVfsSelf, NIL_RTVFSLOCK, + phVfsDir, (void **)&pNewDir); + if (RT_SUCCESS(rc)) + { + pNewDir->fNoMoreFiles = false; + pNewDir->pVol = pThis; + pNewDir->pInode = pInode; + } + } + else + rc = VERR_VFS_BOGUS_FORMAT; + + if (RT_FAILURE(rc)) + rtFsXfsInode_Release(pThis, pInode); + } + + return rc; +} + + + +/* + * + * Volume level code. + * Volume level code. + * Volume level code. + * + */ + +static DECLCALLBACK(int) rtFsXfsVolAgTreeDestroy(PAVLU32NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSXFSAG pAg = (PRTFSXFSAG)pCore; + Assert(!pAg->cRefs); + RTMemFree(pAg); + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtFsXfsVolInodeTreeDestroy(PAVLU64NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSXFSINODE pInode = (PRTFSXFSINODE)pCore; + Assert(!pInode->cRefs); + RTMemFree(pInode); + return VINF_SUCCESS; +} + + +static DECLCALLBACK(int) rtFsXfsVolBlockTreeDestroy(PAVLU64NODECORE pCore, void *pvUser) +{ + RT_NOREF(pvUser); + + PRTFSXFSBLOCKENTRY pBlock = (PRTFSXFSBLOCKENTRY)pCore; + Assert(!pBlock->cRefs); + RTMemFree(pBlock); + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnClose} + */ +static DECLCALLBACK(int) rtFsXfsVol_Close(void *pvThis) +{ + PRTFSXFSVOL pThis = (PRTFSXFSVOL)pvThis; + + /* Destroy the block group tree. */ + RTAvlU32Destroy(&pThis->AgRoot, rtFsXfsVolAgTreeDestroy, pThis); + pThis->AgRoot = NULL; + RTListInit(&pThis->LstAgLru); + + /* Destroy the inode tree. */ + RTAvlU64Destroy(&pThis->InodeRoot, rtFsXfsVolInodeTreeDestroy, pThis); + pThis->InodeRoot = NULL; + RTListInit(&pThis->LstInodeLru); + + /* Destroy the block cache tree. */ + RTAvlU64Destroy(&pThis->BlockRoot, rtFsXfsVolBlockTreeDestroy, pThis); + pThis->BlockRoot = NULL; + RTListInit(&pThis->LstBlockLru); + + /* + * Backing file and handles. + */ + RTVfsFileRelease(pThis->hVfsBacking); + pThis->hVfsBacking = NIL_RTVFSFILE; + pThis->hVfsSelf = NIL_RTVFS; + + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryInfo} + */ +static DECLCALLBACK(int) rtFsXfsVol_QueryInfo(void *pvThis, PRTFSOBJINFO pObjInfo, RTFSOBJATTRADD enmAddAttr) +{ + RT_NOREF(pvThis, pObjInfo, enmAddAttr); + return VERR_WRONG_TYPE; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnOpenRoot} + */ +static DECLCALLBACK(int) rtFsXfsVol_OpenRoot(void *pvThis, PRTVFSDIR phVfsDir) +{ + PRTFSXFSVOL pThis = (PRTFSXFSVOL)pvThis; + int rc = rtFsXfsVol_OpenDirByInode(pThis, pThis->uInodeRoot, phVfsDir); + LogFlowFunc(("returns %Rrc\n", rc)); + return rc; +} + + +/** + * @interface_method_impl{RTVFSOBJOPS::Obj,pfnQueryRangeState} + */ +static DECLCALLBACK(int) rtFsXfsVol_QueryRangeState(void *pvThis, uint64_t off, size_t cb, bool *pfUsed) +{ + RT_NOREF(pvThis, off, cb, pfUsed); + return VERR_NOT_IMPLEMENTED; +} + + +DECL_HIDDEN_CONST(const RTVFSOPS) g_rtFsXfsVolOps = +{ + /* .Obj = */ + { + /* .uVersion = */ RTVFSOBJOPS_VERSION, + /* .enmType = */ RTVFSOBJTYPE_VFS, + /* .pszName = */ "XfsVol", + /* .pfnClose = */ rtFsXfsVol_Close, + /* .pfnQueryInfo = */ rtFsXfsVol_QueryInfo, + /* .uEndMarker = */ RTVFSOBJOPS_VERSION + }, + /* .uVersion = */ RTVFSOPS_VERSION, + /* .fFeatures = */ 0, + /* .pfnOpenRoot = */ rtFsXfsVol_OpenRoot, + /* .pfnQueryRangeState = */ rtFsXfsVol_QueryRangeState, + /* .uEndMarker = */ RTVFSOPS_VERSION +}; + + +/** + * Loads and parses the AGI block. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsXfsVolLoadAgi(PRTFSXFSVOL pThis, PRTERRINFO pErrInfo) +{ + XFSAGI Agi; + int rc = RTVfsFileReadAt(pThis->hVfsBacking, 2 * pThis->cbSector, &Agi, sizeof(&Agi), NULL); + if (RT_SUCCESS(rc)) + { +#ifdef LOG_ENABLED + rtFsXfsAgi_Log(0, &Agi); +#endif + + /** @todo Verification */ + RT_NOREF(pErrInfo); + } + + return rc; +} + + +/** + * Loads and parses the superblock of the filesystem. + * + * @returns IPRT status code. + * @param pThis The XFS volume instance. + * @param pErrInfo Where to return additional error info. + */ +static int rtFsXfsVolLoadAndParseSuperblock(PRTFSXFSVOL pThis, PRTERRINFO pErrInfo) +{ + int rc = VINF_SUCCESS; + XFSSUPERBLOCK Sb; + rc = RTVfsFileReadAt(pThis->hVfsBacking, XFS_SB_OFFSET, &Sb, sizeof(XFSSUPERBLOCK), NULL); + if (RT_FAILURE(rc)) + return RTERRINFO_LOG_SET(pErrInfo, rc, "Error reading super block"); + + /* Validate the superblock. */ + if (RT_BE2H_U32(Sb.u32Magic) != XFS_SB_MAGIC) + return RTERRINFO_LOG_SET_F(pErrInfo, VERR_VFS_UNKNOWN_FORMAT, "Not XFS - Signature mismatch: %RX32", RT_BE2H_U32(Sb.u32Magic)); + +#ifdef LOG_ENABLED + rtFsXfsSb_Log(0, &Sb); +#endif + + /** @todo More verification */ + pThis->cbSector = RT_BE2H_U32(Sb.cbSector); + pThis->cbBlock = RT_BE2H_U32(Sb.cbBlock); + pThis->cBlockShift = Sb.cBlockSzLog; + pThis->cBlocksPerAg = RT_BE2H_U32(Sb.cAgBlocks); + pThis->cAgs = RT_BE2H_U32(Sb.cAg); + pThis->uInodeRoot = RT_BE2H_U64(Sb.uInodeRoot); + pThis->cbInode = RT_BE2H_U16(Sb.cbInode); + pThis->cInodesPerBlock = RT_BE2H_U16(Sb.cInodesPerBlock); + pThis->cAgBlocksLog = Sb.cAgBlocksLog; + pThis->cInodesPerBlockLog = Sb.cInodesPerBlockLog; + return rc; +} + + +RTDECL(int) RTFsXfsVolOpen(RTVFSFILE hVfsFileIn, uint32_t fMntFlags, uint32_t fXfsFlags, PRTVFS phVfs, PRTERRINFO pErrInfo) +{ + AssertPtrReturn(phVfs, VERR_INVALID_POINTER); + AssertReturn(!(fMntFlags & ~RTVFSMNT_F_VALID_MASK), VERR_INVALID_FLAGS); + AssertReturn(!fXfsFlags, VERR_INVALID_FLAGS); + + uint32_t cRefs = RTVfsFileRetain(hVfsFileIn); + AssertReturn(cRefs != UINT32_MAX, VERR_INVALID_HANDLE); + + /* + * Create a VFS instance and initialize the data so rtFsXfsVol_Close works. + */ + RTVFS hVfs; + PRTFSXFSVOL pThis; + int rc = RTVfsNew(&g_rtFsXfsVolOps, sizeof(*pThis), NIL_RTVFS, RTVFSLOCK_CREATE_RW, &hVfs, (void **)&pThis); + if (RT_SUCCESS(rc)) + { + pThis->hVfsBacking = hVfsFileIn; + pThis->hVfsSelf = hVfs; + pThis->fMntFlags = fMntFlags; + pThis->fXfsFlags = fXfsFlags; + pThis->AgRoot = NULL; + pThis->InodeRoot = NULL; + pThis->BlockRoot = NULL; + pThis->cbAgs = 0; + pThis->cbInodes = 0; + pThis->cbBlocks = 0; + RTListInit(&pThis->LstAgLru); + RTListInit(&pThis->LstInodeLru); + RTListInit(&pThis->LstBlockLru); + + rc = RTVfsFileGetSize(pThis->hVfsBacking, &pThis->cbBacking); + if (RT_SUCCESS(rc)) + { + rc = rtFsXfsVolLoadAndParseSuperblock(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + rc = rtFsXfsVolLoadAgi(pThis, pErrInfo); + if (RT_SUCCESS(rc)) + { + *phVfs = hVfs; + return VINF_SUCCESS; + } + } + + RTVfsRelease(hVfs); + *phVfs = NIL_RTVFS; + } + else + RTVfsFileRelease(hVfsFileIn); + + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnValidate} + */ +static DECLCALLBACK(int) rtVfsChainXfsVol_Validate(PCRTVFSCHAINELEMENTREG pProviderReg, PRTVFSCHAINSPEC pSpec, + PRTVFSCHAINELEMSPEC pElement, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg); + + /* + * Basic checks. + */ + if (pElement->enmTypeIn != RTVFSOBJTYPE_FILE) + return pElement->enmTypeIn == RTVFSOBJTYPE_INVALID ? VERR_VFS_CHAIN_CANNOT_BE_FIRST_ELEMENT : VERR_VFS_CHAIN_TAKES_FILE; + if ( pElement->enmType != RTVFSOBJTYPE_VFS + && pElement->enmType != RTVFSOBJTYPE_DIR) + return VERR_VFS_CHAIN_ONLY_DIR_OR_VFS; + if (pElement->cArgs > 1) + return VERR_VFS_CHAIN_AT_MOST_ONE_ARG; + + /* + * Parse the flag if present, save in pElement->uProvider. + */ + bool fReadOnly = (pSpec->fOpenFile & RTFILE_O_ACCESS_MASK) == RTFILE_O_READ; + if (pElement->cArgs > 0) + { + const char *psz = pElement->paArgs[0].psz; + if (*psz) + { + if (!strcmp(psz, "ro")) + fReadOnly = true; + else if (!strcmp(psz, "rw")) + fReadOnly = false; + else + { + *poffError = pElement->paArgs[0].offSpec; + return RTErrInfoSet(pErrInfo, VERR_VFS_CHAIN_INVALID_ARGUMENT, "Expected 'ro' or 'rw' as argument"); + } + } + } + + pElement->uProvider = fReadOnly ? RTVFSMNT_F_READ_ONLY : 0; + return VINF_SUCCESS; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnInstantiate} + */ +static DECLCALLBACK(int) rtVfsChainXfsVol_Instantiate(PCRTVFSCHAINELEMENTREG pProviderReg, PCRTVFSCHAINSPEC pSpec, + PCRTVFSCHAINELEMSPEC pElement, RTVFSOBJ hPrevVfsObj, + PRTVFSOBJ phVfsObj, uint32_t *poffError, PRTERRINFO pErrInfo) +{ + RT_NOREF(pProviderReg, pSpec, poffError); + + int rc; + RTVFSFILE hVfsFileIn = RTVfsObjToFile(hPrevVfsObj); + if (hVfsFileIn != NIL_RTVFSFILE) + { + RTVFS hVfs; + rc = RTFsXfsVolOpen(hVfsFileIn, (uint32_t)pElement->uProvider, (uint32_t)(pElement->uProvider >> 32), &hVfs, pErrInfo); + RTVfsFileRelease(hVfsFileIn); + if (RT_SUCCESS(rc)) + { + *phVfsObj = RTVfsObjFromVfs(hVfs); + RTVfsRelease(hVfs); + if (*phVfsObj != NIL_RTVFSOBJ) + return VINF_SUCCESS; + rc = VERR_VFS_CHAIN_CAST_FAILED; + } + } + else + rc = VERR_VFS_CHAIN_CAST_FAILED; + return rc; +} + + +/** + * @interface_method_impl{RTVFSCHAINELEMENTREG,pfnCanReuseElement} + */ +static DECLCALLBACK(bool) rtVfsChainXfsVol_CanReuseElement(PCRTVFSCHAINELEMENTREG pProviderReg, + PCRTVFSCHAINSPEC pSpec, PCRTVFSCHAINELEMSPEC pElement, + PCRTVFSCHAINSPEC pReuseSpec, PCRTVFSCHAINELEMSPEC pReuseElement) +{ + RT_NOREF(pProviderReg, pSpec, pReuseSpec); + if ( pElement->paArgs[0].uProvider == pReuseElement->paArgs[0].uProvider + || !pReuseElement->paArgs[0].uProvider) + return true; + return false; +} + + +/** VFS chain element 'xfs'. */ +static RTVFSCHAINELEMENTREG g_rtVfsChainXfsVolReg = +{ + /* uVersion = */ RTVFSCHAINELEMENTREG_VERSION, + /* fReserved = */ 0, + /* pszName = */ "xfs", + /* ListEntry = */ { NULL, NULL }, + /* pszHelp = */ "Open a XFS file system, requires a file object on the left side.\n" + "First argument is an optional 'ro' (read-only) or 'rw' (read-write) flag.\n", + /* pfnValidate = */ rtVfsChainXfsVol_Validate, + /* pfnInstantiate = */ rtVfsChainXfsVol_Instantiate, + /* pfnCanReuseElement = */ rtVfsChainXfsVol_CanReuseElement, + /* uEndMarker = */ RTVFSCHAINELEMENTREG_VERSION +}; + +RTVFSCHAIN_AUTO_REGISTER_ELEMENT_PROVIDER(&g_rtVfsChainXfsVolReg, rtVfsChainXfsVolReg); + |