#include "ecma_167.h"
#include "osta_misc.h"
#include "udf_rel.h"
#include "wcache.h"

Include dependency graph for udf_info.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	HASH_POSIX 0x01

#define	HASH_ULFN 0x02

#define	HASH_DOS 0x04

#define	HASH_ALL 0x07

#define	HASH_KEEP_NAME 0x08

#define	UDFExtentToMapping(e) UDFExtentToMapping_(e)

#define	UDFDOSName__(Vcb, DosName, UdfName, FileInfo) UDFDOSName(Vcb, DosName, UdfName, (FileInfo) && ((FileInfo)->Index < 2));

#define	UDFCheckSpaceAllocation(Vcb, FileInfo, Map, asXXX) {;}

#define	UDFMarkSpaceAsXXXNoProtect(Vcb, FileInfo, Map, asXXX) UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX);

#define	UDFMarkSpaceAsXXX(Vcb, FileInfo, Map, asXXX) UDFMarkSpaceAsXXX_(Vcb, Map, asXXX);

#define	AS_FREE 0x00

#define	AS_USED 0x01

#define	AS_DISCARDED 0x02

#define	AS_BAD 0x04

#define	UDFAllocFreeExtent(v, l, ss, sl, e, af) UDFAllocFreeExtent_(v, l, ss, sl, e, af)

#define	UDF_PREALLOC_CLASS_FE 0x00

#define	UDF_PREALLOC_CLASS_DIR 0x01

#define	FLUSH_FE_KEEP FALSE

#define	FLUSH_FE_FOR_DEL TRUE

#define	UDF_FSPACE_BM 0x00

#define	UDF_ZSPACE_BM 0x01

#define	UDFMarkAllocatedAsNotAllocated(Vcb, Off, Len, Ext) UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, TRUE)

#define	UDFMarkRecordedAsAllocated(Vcb, Off, Len, Ext) UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, FALSE)

#define	UDFZeroExtent__(Vcb, Ext, Off, Len, Dir, WB) UDFZeroExtent(Vcb, Ext, Off, Len, FALSE, Dir, WB)

#define	UDFSparseExtent__(Vcb, Ext, Off, Len, Dir, WB) UDFZeroExtent(Vcb, Ext, Off, Len, TRUE, Dir, WB)

#define	UDFIncFileLinkCount(fi) UDFChangeFileLinkCount(fi, TRUE)

#define	UDFDecFileLinkCount(fi) UDFChangeFileLinkCount(fi, FALSE)

#define	UDFSetEntityID_imp(eID, Str) UDFSetEntityID_imp_(eID, (uint8*)(Str), sizeof(Str));

#define	UDFIncFileCounter(Vcb) UDFChangeFileCounter(Vcb, TRUE, TRUE);

#define	UDFDecFileCounter(Vcb) UDFChangeFileCounter(Vcb, TRUE, FALSE);

#define	UDFIncDirCounter(Vcb) UDFChangeFileCounter(Vcb, FALSE, TRUE);

#define	UDFDecDirCounter(Vcb) UDFChangeFileCounter(Vcb, FALSE, FALSE);

#define	UDF_FREE_NOTHING 0x00

#define	UDF_FREE_FILEINFO 0x01

#define	UDF_FREE_DLOC 0x02

#define	UDFIsDeleted(DirNdx) (((DirNdx)->FileCharacteristics & FILE_DELETED) ? TRUE : FALSE)

#define	UDFIsADirectory(FileInfo) (((FileInfo) && ((FileInfo)->Dloc) && ((FileInfo)->Dloc->DirIndex \|\| ((FileInfo)->FileIdent && ((FileInfo)->FileIdent->fileCharacteristics & FILE_DIRECTORY)))) ? TRUE : FALSE)

#define	UDFGetFileAllocationSize(Vcb, FileInfo) (((FileInfo)->Dloc->DataLoc.Mapping) ? UDFGetExtentLength((FileInfo)->Dloc->DataLoc.Mapping) : Vcb->LBlockSize)

#define	UDFIsFlushed(FI)

#define	UDFIsFileCached__(Vcb, FileInfo, Offset, Length, ForWrite) (UDFIsExtentCached(Vcb, &((FileInfo)->Dloc->DataLoc), Offset, Length, ForWrite))

#define	UDFGetLVIDiUse(Vcb)

#define	UDFIsAStreamDir(FI) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR))

#define	UDFHasAStreamDir(FI) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_HAS_SDIR))

#define	UDFIsAStream(FI) ((FI) && UDFIsAStreamDir((FI)->ParentFile))

#define	UDFIsSDirDeleted(FI) ((FI) && (FI)->Dloc && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_DEL_SDIR))

#define	UDFGetPartNumByPartNdx(Vcb, pi) (Vcb->Partitions[pi].PartitionNum)

#define	UDFStreamsSupported(Vcb) (Vcb->maxUDFWriteRev >= 0x0200)

#define	UDFNtAclSupported(Vcb) (Vcb->maxUDFWriteRev >= 0x0200)

#define	UDFReferenceFile__(fi)

#define	UDFReferenceFileEx__(fi, i)

#define	UDFDereferenceFile__(fi)

#define	UDFIsDirEmpty__(fi) UDFIsDirEmpty((fi)->Dloc->DirIndex)

#define	UDFIsDirOpened__(fi) (fi->OpenCount)

#define	UDFSetFileAllocMode__(fi, mode)

#define	UDFGetFileAllocMode__(fi) ((fi)->Dloc->DataLoc.Flags & EXTENT_FLAG_ALLOC_MASK)

#define	UDFGetFileICBAllocMode__(fi) (((PFILE_ENTRY)((fi)->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK)

#define	UDF_DIR_INDEX_FRAME_SH 9

#define	UDF_DIR_INDEX_FRAME ((uint_di)(1 << UDF_DIR_INDEX_FRAME_SH))

#define	UDF_DIR_INDEX_FRAME_GRAN (32)

#define	UDF_DIR_INDEX_FRAME_GRAN_MASK (UDF_DIR_INDEX_FRAME_GRAN-1)

#define	AlignDirIndex(n) ((n+UDF_DIR_INDEX_FRAME_GRAN_MASK) & ~(UDF_DIR_INDEX_FRAME_GRAN_MASK))

#define	UDFDirIndexGetLastIndex(di) ((((di)->FrameCount - 1) << UDF_DIR_INDEX_FRAME_SH) + (di)->LastFrameCount)

#define	UDFGetBit(arr, bit) ( (BOOLEAN) ( ((((uint32*)(arr))[(bit)>>5]) >> ((bit)&31)) &1 ) )

#define	UDFSetBit(arr, bit) ( (((uint32*)(arr))[(bit)>>5]) \|= (((uint32)1) << ((bit)&31)) )

#define	UDFClrBit(arr, bit) ( (((uint32*)(arr))[(bit)>>5]) &= (~(((uint32)1) << ((bit)&31))) )

#define	UDFSetBits(arr, bit, bc)

#define	UDFClrBits(arr, bit, bc)

#define	UDFGetUsedBit(arr, bit) (!UDFGetBit(arr,bit))

#define	UDFGetFreeBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFSetUsedBit(arr, bit) UDFClrBit(arr,bit)

#define	UDFSetFreeBit(arr, bit) UDFSetBit(arr,bit)

#define	UDFSetUsedBits(arr, bit, bc) UDFClrBits(arr,bit,bc)

#define	UDFSetFreeBits(arr, bit, bc) UDFSetBits(arr,bit,bc)

#define	UDFGetBadBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFGetZeroBit(arr, bit) UDFGetBit(arr,bit)

#define	UDFSetZeroBit(arr, bit) UDFSetBit(arr,bit)

#define	UDFClrZeroBit(arr, bit) UDFClrBit(arr,bit)

#define	UDFSetZeroBits(arr, bit, bc) UDFSetBits(arr,bit,bc)

#define	UDFClrZeroBits(arr, bit, bc) UDFClrBits(arr,bit,bc)

#define	UDFSetFreeBitOwner(Vcb, i)

#define	UDFSetUsedBitOwner(Vcb, i, o)

#define	UDFCheckUsedBitOwner(Vcb, i, o)

#define	UDFCheckFreeBitOwner(Vcb, i)

#define	UDFRegisterFsStructure(Vcb, Lba, Length) {NOTHING;}

#define	UDF_MAX_VERIFY_CACHE (810241024/2048)

#define	UDF_VERIFY_CACHE_LOW (410241024/2048)

#define	UDF_VERIFY_CACHE_GRAN (512*1024/2048)

#define	UDF_SYS_CACHE_STOP_THR (1010241024/2048)

#define	PH_FORGET_VERIFIED 0x00800000

#define	PH_READ_VERIFY_CACHE 0x00400000

#define	PH_KEEP_VERIFY_CACHE 0x00200000

#define	UFD_VERIFY_FLAG_FORCE 0x01

#define	UFD_VERIFY_FLAG_WAIT 0x02

#define	UFD_VERIFY_FLAG_BG 0x04

#define	UFD_VERIFY_FLAG_LOCKED 0x10

Functions
uint32	UDFMemRealloc (IN int8 OldBuff, IN uint32 OldLength, OUT int8 *NewBuff, IN uint32 NewLength)

uint32	UDFExtentOffsetToLba (IN PVCB Vcb, IN PEXTENT_AD Extent, IN int64 Offset, OUT uint32 SectorOffset, OUT PSIZE_T AvailLength, OUT uint32 Flags, OUT uint32 *Index)

ULONG	UDFLocateLbaInExtent (IN PVCB Vcb, IN PEXTENT_MAP Extent, IN lba_t lba)

OSSTATUS	UDFReadExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT int8 *Buffer, OUT PSIZE_T ReadBytes)

OSSTATUS	UDFReadExtentLocation (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, OUT PEXTENT_MAP _SubExtInfo, IN OUT uint32 _SubExtInfoSz, OUT int64 *_NextOffset)

int64	UDFGetExtentLength (IN PEXTENT_MAP Extent)

void __fastcall	UDFDecompressUnicode (IN OUT PUNICODE_STRING UName, IN uint8 CS0, IN SIZE_T Length, OUT uint16 valueCRC)

uint8	UDFBuildHashEntry (IN PVCB Vcb, IN PUNICODE_STRING Name, OUT PHASH_ENTRY hashes, IN uint8 Mask)

PDIR_INDEX_ITEM	UDFDirIndexGetFrame (IN PDIR_INDEX_HDR hDirNdx, IN uint32 Frame, OUT uint32 FrameLen, OUT uint_di Index, IN uint_di Rel)

void	UDFDirIndexFree (PDIR_INDEX_HDR hDirNdx)

OSSTATUS	UDFDirIndexGrow (IN PDIR_INDEX_HDR *_hDirNdx, IN uint_di d)

OSSTATUS	UDFDirIndexTrunc (IN PDIR_INDEX_HDR *_hDirNdx, IN uint_di d)

BOOLEAN	UDFDirIndexInitScan (IN PUDF_FILE_INFO DirInfo, OUT PUDF_DIR_SCAN_CONTEXT Context, IN uint_di Index)

PDIR_INDEX_ITEM	UDFDirIndexScan (PUDF_DIR_SCAN_CONTEXT Context, PUDF_FILE_INFO *_FileInfo)

OSSTATUS	UDFIndexDirectory (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFFindFile (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN BOOLEAN NotDeleted, IN PUNICODE_STRING Name, IN PUDF_FILE_INFO DirInfo, IN OUT uint_di *Index)

__inline OSSTATUS	UDFFindFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN PUNICODE_STRING Name, IN PUDF_FILE_INFO DirInfo)

uint32	UDFGetMappingLength (IN PEXTENT_MAP Extent)

PEXTENT_MAP __fastcall	UDFMergeMappings (IN PEXTENT_MAP Extent, IN PEXTENT_MAP Extent2)

PEXTENT_MAP	UDFShortAllocDescToMapping (IN PVCB Vcb, IN uint32 PartNum, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFLongAllocDescToMapping (IN PVCB Vcb, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFExtAllocDescToMapping (IN PVCB Vcb, IN PLONG_AD AllocDesc, IN uint32 AllocDescLength, IN uint32 SubCallCount, OUT PEXTENT_INFO AllocLoc)

PEXTENT_MAP	UDFReadMappingFromXEntry (IN PVCB Vcb, IN uint32 PartNum, IN tag XEntry, IN OUT uint32 Offset, OUT PEXTENT_INFO AllocLoc)

OSSTATUS	UDFReadFileEntry (IN PVCB Vcb, IN long_ad Icb, IN OUT PFILE_ENTRY FileEntry, IN OUT uint16 Ident)

OSSTATUS	UDFFindLastFileSet (IN PVCB Vcb, IN lb_addr *Addr, IN OUT PFILE_SET_DESC FileSetDesc)

OSSTATUS	UDFLoadSparingTable (IN PVCB Vcb, IN PSPARABLE_PARTITION_MAP PartMap)

PEXTENT_MAP __fastcall	UDFExtentToMapping_ (IN PEXTENT_AD Extent)

OSSTATUS __fastcall	UDFRemapPacket (IN PVCB Vcb, IN uint32 Lba, IN BOOLEAN RemapSpared)

OSSTATUS __fastcall	UDFUnmapRange (IN PVCB Vcb, IN uint32 Lba, IN uint32 BCount)

uint32 __fastcall	UDFRelocateSector (IN PVCB Vcb, IN uint32 Lba)

BOOLEAN __fastcall	UDFAreSectorsRelocated (IN PVCB Vcb, IN uint32 Lba, IN uint32 BlockCount)

PEXTENT_MAP __fastcall	UDFRelocateSectors (IN PVCB Vcb, IN uint32 Lba, IN uint32 BlockCount)

BOOLEAN	UDFUnicodeInString (IN uint8 *string, IN WCHAR ch)

BOOLEAN __fastcall	UDFIsIllegalChar (IN WCHAR ch)

void __fastcall	UDFDOSName (IN PVCB Vcb, IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

void __fastcall	UDFDOSName201 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

void __fastcall	UDFDOSName200 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact, IN BOOLEAN Mode150)

void __fastcall	UDFDOSName100 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)

SIZE_T	UDFGetBitmapLen (uint32 *Bitmap, SIZE_T Offs, SIZE_T Lim)

SIZE_T	UDFFindMinSuitableExtent (IN PVCB Vcb, IN uint32 Length, IN uint32 SearchStart, IN uint32 SearchLim, OUT uint32 *MaxExtLen, IN uint8 AllocFlags)

void	UDFMarkSpaceAsXXXNoProtect_ (IN PVCB Vcb, IN PEXTENT_MAP Map, IN uint32 asXXX)

void	UDFMarkSpaceAsXXX_ (IN PVCB Vcb, IN PEXTENT_MAP Map, IN uint32 asXXX)

OSSTATUS	UDFAllocFreeExtent_ (IN PVCB Vcb, IN int64 Length, IN uint32 SearchStart, IN uint32 SearchLim, OUT PEXTENT_INFO Extent, IN uint8 AllocFlags)

uint32 __fastcall	UDFGetPartFreeSpace (IN PVCB Vcb, IN uint32 partNum)

OSSTATUS	UDFGetCachedAllocation (IN PVCB Vcb, IN uint32 ParentLocation, OUT PEXTENT_INFO Ext, OUT uint32 *Items, IN uint32 AllocClass)

OSSTATUS	UDFStoreCachedAllocation (IN PVCB Vcb, IN uint32 ParentLocation, IN PEXTENT_INFO Ext, IN uint32 Items, IN uint32 AllocClass)

OSSTATUS	UDFFlushAllCachedAllocations (IN PVCB Vcb, IN uint32 AllocClass)

OSSTATUS	UDFAllocateFESpace (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN uint32 PartNum, IN PEXTENT_INFO FEExtInfo, IN uint32 Len)

void	UDFFreeFESpace (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PEXTENT_INFO FEExtInfo)

void	UDFFlushFESpace (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc, IN BOOLEAN Discard=FLUSH_FE_KEEP)

void	UDFFreeFileAllocation (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PUDF_FILE_INFO FileInfo)

uint32	UDFPhysLbaToPart (IN PVCB Vcb, IN uint32 PartNum, IN uint32 Addr)

void	UDFSetUpTag (IN PVCB Vcb, IN tag *Tag, IN uint16 DataLen, IN uint32 TagLoc)

OSSTATUS	UDFBuildShortAllocDescs (IN PVCB Vcb, IN uint32 PartNum, OUT int8 **Buff, IN uint32 InitSz, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFBuildLongAllocDescs (IN PVCB Vcb, IN uint32 PartNum, OUT int8 **Buff, IN uint32 InitSz, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFBuildFileEntry (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum, IN uint16 AllocMode, IN uint32 ExtAttrSz, IN BOOLEAN Extended)

uint32 __fastcall	UDFGetPartNumByPhysLba (IN PVCB Vcb, IN uint32 Lba)

OSSTATUS	UDFAddXSpaceBitmap (IN PVCB Vcb, IN uint32 PartNum, IN PSHORT_AD bm, IN ULONG bm_type)

OSSTATUS	UDFDelXSpaceBitmap (IN PVCB Vcb, IN uint32 PartNum, IN PSHORT_AD bm)

OSSTATUS	UDFBuildFreeSpaceBitmap (IN PVCB Vcb, IN uint32 PartNdx, IN PPARTITION_HEADER_DESC phd, IN uint32 Lba)

OSSTATUS	UDFLoadExtInfo (IN PVCB Vcb, IN PFILE_ENTRY fe, IN PLONG_AD fe_loc, IN OUT PEXTENT_INFO FExtInfo, IN OUT PEXTENT_INFO AExtInfo)

void __fastcall	UDFCompressUnicode (IN PUNICODE_STRING UName, IN OUT uint8 **_CS0, IN OUT PSIZE_T Length)

OSSTATUS	UDFBuildFileIdent (IN PVCB Vcb, IN PUNICODE_STRING fn, IN PLONG_AD FileEntryIcb, IN uint32 ImpUseLen, OUT PFILE_IDENT_DESC _FileId, OUT uint32 FileIdLen)

OSSTATUS	UDFMarkAllocatedAsRecorded (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFMarkNotAllocatedAsAllocated (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFMarkAllocatedAsNotXXX (IN PVCB Vcb, IN int64 Offset, IN uint32 Length, IN PEXTENT_INFO ExtInfo, IN BOOLEAN Deallocate)

OSSTATUS	UDFWriteExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)

OSSTATUS	UDFZeroExtent (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Deallocate, IN BOOLEAN Direct, OUT PSIZE_T WrittenBytes)

uint32 __fastcall	UDFPartStart (PVCB Vcb, uint32 PartNum)

uint32 __fastcall	UDFPartEnd (PVCB Vcb, uint32 PartNum)

OSSTATUS	UDFResizeExtent (IN PVCB Vcb, IN uint32 PartNum, IN int64 Length, IN BOOLEAN AlwaysInIcb, OUT PEXTENT_INFO ExtInfo)

OSSTATUS	UDFBuildAllocDescs (IN PVCB Vcb, IN uint32 PartNum, IN OUT PUDF_FILE_INFO FileInfo, OUT int8 **AllocData)

void	UDFSetFileSize (IN PUDF_FILE_INFO FileInfo, IN int64 Size)

void	UDFSetFileSizeInDirNdx (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 *ASize)

int64	UDFGetFileSize (IN PUDF_FILE_INFO FileInfo)

int64	UDFGetFileSizeFromDirNdx (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

void	UDFSetAllocDescLen (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

void	UDFChangeFileLinkCount (IN PUDF_FILE_INFO FileInfo, IN BOOLEAN Increase)

void	UDFSetEntityID_imp_ (IN EntityID eID, IN uint8 Str, IN uint32 Len)

uint16	UDFGetFileLinkCount (IN PUDF_FILE_INFO FileInfo)

void	UDFReadEntityID_Domain (PVCB Vcb, EntityID *eID)

uint32	UDFGetFileEALength (IN PUDF_FILE_INFO FileInfo)

void	UDFSetFileUID (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

int64	UDFGetFileUID (IN PUDF_FILE_INFO FileInfo)

void	UDFChangeFileCounter (IN PVCB Vcb, IN BOOLEAN FileCounter, IN BOOLEAN Increase)

OSSTATUS	UDFWriteFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, IN int8 *Buffer, OUT PSIZE_T WrittenBytes)

OSSTATUS	UDFUnlinkFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN BOOLEAN FreeSpace)

OSSTATUS	UDFUnlinkAllFilesInDir (IN PVCB Vcb, IN PUDF_FILE_INFO DirInfo)

OSSTATUS	UDFOpenFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN BOOLEAN NotDeleted, IN PUNICODE_STRING fn, IN PUDF_FILE_INFO DirInfo, OUT PUDF_FILE_INFO _FileInfo, IN uint_di IndexToOpen)

OSSTATUS	UDFOpenRootFile__ (IN PVCB Vcb, IN lb_addr *RootLoc, OUT PUDF_FILE_INFO FileInfo)

uint32	UDFCleanUpFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFCreateFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN PUNICODE_STRING fn, IN uint32 ExtAttrSz, IN uint32 ImpUseLen, IN BOOLEAN Extended, IN BOOLEAN CreateNew, IN OUT PUDF_FILE_INFO DirInfo, OUT PUDF_FILE_INFO *_FileInfo)

__inline OSSTATUS	UDFReadFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT int8 *Buffer, OUT PSIZE_T ReadBytes)

__inline OSSTATUS	UDFReadFileLocation__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, OUT PEXTENT_MAP SubExtInfo, IN OUT uint32 SubExtInfoSz, OUT int64 *NextOffset)

__inline OSSTATUS	UDFZeroFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN Direct, OUT uint32 *ReadBytes)

__inline OSSTATUS	UDFSparseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN Direct, OUT uint32 *ReadBytes)

OSSTATUS	UDFPadLastSector (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFCloseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFPrepareXSpaceBitmap (IN PVCB Vcb, IN OUT PSHORT_AD XSpaceBitmap, IN OUT PEXTENT_INFO XSBMExtInfo, IN OUT int8 *XSBM, IN OUT uint32 XSl)

OSSTATUS	UDFUpdateXSpaceBitmaps (IN PVCB Vcb, IN uint32 PartNum, IN PPARTITION_HEADER_DESC phd)

OSSTATUS	UDFUpdatePartDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFUpdateLogicalVolInt (PVCB Vcb, BOOLEAN Close)

OSSTATUS	UDFUpdateUSpaceDesc (IN PVCB Vcb, int8 *Buf)

OSSTATUS	UDFUpdateVDS (IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, IN uint32 flags)

OSSTATUS	UDFUmount__ (IN PVCB Vcb)

OSSTATUS	UDFRenameMoveFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN OUT BOOLEAN *Replace, IN PUNICODE_STRING fn, IN OUT PUDF_FILE_INFO DirInfo1, IN OUT PUDF_FILE_INFO DirInfo2, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFResizeFile__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo, IN int64 NewLength)

OSSTATUS	UDFRecordDirectory__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO DirInfo)

OSSTATUS	UDFPackDirectory__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFReTagDirectory (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo)

OSSTATUS	UDFLoadVAT (IN PVCB Vcb, IN uint32 PartNdx)

int64 __fastcall	UDFGetFreeSpace (IN PVCB Vcb)

int64 __fastcall	UDFGetTotalSpace (IN PVCB Vcb)

PDIR_INDEX_HDR	UDFGetDirIndexByFileInfo (IN PUDF_FILE_INFO FileInfo)

BOOLEAN	UDFIsDirEmpty (IN PDIR_INDEX_HDR hCurDirNdx)

OSSTATUS	UDFFlushFE (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum)

OSSTATUS	UDFFlushFI (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint32 PartNum)

OSSTATUS	UDFFlushFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN ULONG FlushFlags=0)

BOOLEAN	UDFCompareFileInfo (IN PUDF_FILE_INFO f1, IN PUDF_FILE_INFO f2)

void __fastcall	UDFPackMapping (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

BOOLEAN	UDFIsExtentCached (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo, IN int64 Offset, IN uint32 Length, IN BOOLEAN ForWrite)

ULONG	UDFIsBlockAllocated (IN void *_Vcb, IN uint32 Lba)

OSSTATUS	UDFUpdateVolIdent (IN PVCB Vcb, IN UDF_VDS_RECORD Lba, IN PUNICODE_STRING VolIdent)

uint16 __fastcall	UDFUnicodeCksum (PWCHAR s, uint32 n)

uint16 __fastcall	UDFUnicodeCksum150 (PWCHAR s, uint32 n)

uint32 __fastcall	crc32 (IN uint8 *s, IN uint32 len)

uint16 __fastcall	UDFCrc (IN uint8 *Data, IN SIZE_T Size)

OSSTATUS	UDFReadTagged (IN PVCB Vcb, IN int8 Buf, IN uint32 Block, IN uint32 Location, OUT uint16 Ident)

uint32 __fastcall	UDFPartLbaToPhys (IN PVCB Vcb, IN lb_addr *Addr)

lba_t	UDFFindAnchor (PVCB Vcb)

uint32	UDFFindVRS (PVCB Vcb)

void	UDFLoadPVolDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFLoadLogicalVolInt (PDEVICE_OBJECT DeviceObject, PVCB Vcb, extent_ad loc)

OSSTATUS	UDFLoadLogicalVol (PDEVICE_OBJECT DeviceObject, PVCB Vcb, int8 Buf, lb_addr fileset)

OSSTATUS	UDFLoadPartDesc (PVCB Vcb, int8 *Buf)

OSSTATUS	UDFReadVDS (IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, IN PUDF_VDS_RECORD vds, IN int8 *Buf)

OSSTATUS	UDFProcessSequence (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, OUT lb_addr *fileset)

OSSTATUS	UDFVerifySequence (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, IN uint32 block, IN uint32 lastblock, OUT lb_addr *fileset)

void	UDFLoadFileset (IN PVCB Vcb, IN PFILE_SET_DESC fset, OUT lb_addr root, OUT lb_addr sysstream)

OSSTATUS	UDFLoadPartition (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb, OUT lb_addr *fileset)

OSSTATUS	UDFGetDiskInfoAndVerify (IN PDEVICE_OBJECT DeviceObject, IN PVCB Vcb)

OSSTATUS	UDFHardLinkFile__ (IN PVCB Vcb, IN BOOLEAN IgnoreCase, IN OUT BOOLEAN *Replace, IN PUNICODE_STRING fn, IN OUT PUDF_FILE_INFO DirInfo1, IN OUT PUDF_FILE_INFO DirInfo2, IN OUT PUDF_FILE_INFO FileInfo)

LONG	UDFFindDloc (IN PVCB Vcb, IN uint32 Lba)

LONG	UDFFindFreeDloc (IN PVCB Vcb, IN uint32 Lba)

OSSTATUS	UDFAcquireDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFReleaseDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFStoreDloc (IN PVCB Vcb, IN PUDF_FILE_INFO fi, IN uint32 Lba)

OSSTATUS	UDFRemoveDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

OSSTATUS	UDFUnlinkDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

void	UDFFreeDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc)

void	UDFRelocateDloc (IN PVCB Vcb, IN PUDF_DATALOC_INFO Dloc, IN uint32 NewLba)

void	UDFReleaseDlocList (IN PVCB Vcb)

PUDF_FILE_INFO	UDFLocateParallelFI (PUDF_FILE_INFO di, uint_di i, PUDF_FILE_INFO fi)

PUDF_FILE_INFO	UDFLocateAnyParallelFI (PUDF_FILE_INFO fi)

void	UDFInsertLinkedFile (PUDF_FILE_INFO fi, PUDF_FILE_INFO fi2)

OSSTATUS	UDFCreateRootFile__ (IN PVCB Vcb, IN uint32 PartNum, IN uint32 ExtAttrSz, IN uint32 ImpUseLen, IN BOOLEAN Extended, OUT PUDF_FILE_INFO *_FileInfo)

OSSTATUS	UDFCreateStreamDir__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, OUT PUDF_FILE_INFO *_SDirInfo)

OSSTATUS	UDFOpenStreamDir__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, OUT PUDF_FILE_INFO *_SDirInfo)

OSSTATUS	UDFRecordVAT (IN PVCB Vcb)

OSSTATUS	UDFModifyVAT (IN PVCB Vcb, IN uint32 Lba, IN uint32 Length)

OSSTATUS	UDFUpdateVAT (IN void _Vcb, IN uint32 Lba, IN uint32 RelocTab, IN uint32 BCount)

OSSTATUS __fastcall	UDFUnPackMapping (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)

OSSTATUS	UDFConvertFEToNonInICB (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint8 NewAllocMode)

OSSTATUS	UDFConvertFEToExtended (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

uint32 __fastcall	UDFPartLen (PVCB Vcb, uint32 PartNum)

OSSTATUS	UDFPretendFileDeleted__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

__inline PDIR_INDEX_ITEM	UDFDirIndex (IN PDIR_INDEX_HDR hDirNdx, IN uint_di i)

OSSTATUS	UDFVInit (IN PVCB Vcb)

VOID	UDFVRelease (IN PVCB Vcb)

OSSTATUS	UDFVWrite (IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

OSSTATUS	UDFVRead (IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

OSSTATUS	UDFVForget (IN PVCB Vcb, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)

VOID	UDFVVerify (IN PVCB Vcb, IN ULONG Flags)

VOID	UDFVFlush (IN PVCB Vcb)

__inline BOOLEAN __fastcall	UDFVIsStored (IN PVCB Vcb, IN lba_t lba)

BOOLEAN __fastcall	UDFCheckArea (IN PVCB Vcb, IN lba_t LBA, IN uint32 BCount)

Variables
const char	hexChar []

Macro Definition Documentation

◆ AlignDirIndex

#define AlignDirIndex ( n ) ((n+UDF_DIR_INDEX_FRAME_GRAN_MASK) & ~(UDF_DIR_INDEX_FRAME_GRAN_MASK))

Definition at line 1093 of file udf_info.h.

◆ AS_BAD

#define AS_BAD 0x04

Definition at line 329 of file udf_info.h.

◆ AS_DISCARDED

#define AS_DISCARDED 0x02

Definition at line 328 of file udf_info.h.

◆ AS_FREE

#define AS_FREE 0x00

Definition at line 326 of file udf_info.h.

◆ AS_USED

#define AS_USED 0x01

Definition at line 327 of file udf_info.h.

◆ FLUSH_FE_FOR_DEL

#define FLUSH_FE_FOR_DEL TRUE

Definition at line 396 of file udf_info.h.

◆ FLUSH_FE_KEEP

#define FLUSH_FE_KEEP FALSE

Definition at line 395 of file udf_info.h.

◆ HASH_ALL

#define HASH_ALL 0x07

Definition at line 78 of file udf_info.h.

◆ HASH_DOS

#define HASH_DOS 0x04

Definition at line 77 of file udf_info.h.

◆ HASH_KEEP_NAME

#define HASH_KEEP_NAME 0x08

Definition at line 79 of file udf_info.h.

◆ HASH_POSIX

#define HASH_POSIX 0x01

Definition at line 75 of file udf_info.h.

◆ HASH_ULFN

#define HASH_ULFN 0x02

Definition at line 76 of file udf_info.h.

◆ PH_FORGET_VERIFIED

#define PH_FORGET_VERIFIED 0x00800000

Definition at line 1270 of file udf_info.h.

◆ PH_KEEP_VERIFY_CACHE

#define PH_KEEP_VERIFY_CACHE 0x00200000

Definition at line 1272 of file udf_info.h.

◆ PH_READ_VERIFY_CACHE

#define PH_READ_VERIFY_CACHE 0x00400000

Definition at line 1271 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME

#define UDF_DIR_INDEX_FRAME ((uint_di)(1 << UDF_DIR_INDEX_FRAME_SH))

Definition at line 1089 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_GRAN

#define UDF_DIR_INDEX_FRAME_GRAN (32)

Definition at line 1091 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_GRAN_MASK

#define UDF_DIR_INDEX_FRAME_GRAN_MASK (UDF_DIR_INDEX_FRAME_GRAN-1)

Definition at line 1092 of file udf_info.h.

◆ UDF_DIR_INDEX_FRAME_SH

#define UDF_DIR_INDEX_FRAME_SH 9

Definition at line 1084 of file udf_info.h.

◆ UDF_FREE_DLOC

#define UDF_FREE_DLOC 0x02

Definition at line 650 of file udf_info.h.

◆ UDF_FREE_FILEINFO

#define UDF_FREE_FILEINFO 0x01

Definition at line 649 of file udf_info.h.

◆ UDF_FREE_NOTHING

#define UDF_FREE_NOTHING 0x00

Definition at line 648 of file udf_info.h.

◆ UDF_FSPACE_BM

#define UDF_FSPACE_BM 0x00

Definition at line 445 of file udf_info.h.

◆ UDF_MAX_VERIFY_CACHE

#define UDF_MAX_VERIFY_CACHE (8*1024*1024/2048)

Definition at line 1255 of file udf_info.h.

◆ UDF_PREALLOC_CLASS_DIR

#define UDF_PREALLOC_CLASS_DIR 0x01

Definition at line 356 of file udf_info.h.

◆ UDF_PREALLOC_CLASS_FE

#define UDF_PREALLOC_CLASS_FE 0x00

Definition at line 355 of file udf_info.h.

◆ UDF_SYS_CACHE_STOP_THR

#define UDF_SYS_CACHE_STOP_THR (10*1024*1024/2048)

Definition at line 1258 of file udf_info.h.

◆ UDF_VERIFY_CACHE_GRAN

#define UDF_VERIFY_CACHE_GRAN (512*1024/2048)

Definition at line 1257 of file udf_info.h.

◆ UDF_VERIFY_CACHE_LOW

#define UDF_VERIFY_CACHE_LOW (4*1024*1024/2048)

Definition at line 1256 of file udf_info.h.

◆ UDF_ZSPACE_BM

#define UDF_ZSPACE_BM 0x01

Definition at line 446 of file udf_info.h.

◆ UDFAllocFreeExtent

#define UDFAllocFreeExtent	(	v,
		l,
		ss,
		sl,
		e,
		af
	)	UDFAllocFreeExtent_(v, l, ss, sl, e, af)

Definition at line 347 of file udf_info.h.

◆ UDFCheckFreeBitOwner

#define UDFCheckFreeBitOwner	(	Vcb,
		i
	)

Definition at line 1238 of file udf_info.h.

◆ UDFCheckSpaceAllocation

#define UDFCheckSpaceAllocation	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	{;}

Definition at line 281 of file udf_info.h.

◆ UDFCheckUsedBitOwner

#define UDFCheckUsedBitOwner	(	Vcb,
		i,
		o
	)

Definition at line 1237 of file udf_info.h.

◆ UDFClrBit

#define UDFClrBit	(	arr,
		bit
	)	( (((uint32*)(arr))[(bit)>>5]) &= (~(((uint32)1) << ((bit)&31))) )

Definition at line 1182 of file udf_info.h.

◆ UDFClrBits

#define UDFClrBits	(	arr,
		bit,
		bc
	)

Value:

{uint32 j;                       \
    for(j=0;j<bc;j++) {          \
        UDFClrBit(arr, (bit)+j); \
}}

Definition at line 1190 of file udf_info.h.

◆ UDFClrZeroBit

#define UDFClrZeroBit	(	arr,
		bit
	)	UDFClrBit(arr,bit)

Definition at line 1209 of file udf_info.h.

◆ UDFClrZeroBits

#define UDFClrZeroBits	(	arr,
		bit,
		bc
	)	UDFClrBits(arr,bit,bc)

Definition at line 1211 of file udf_info.h.

◆ UDFDecDirCounter

#define UDFDecDirCounter ( Vcb ) UDFChangeFileCounter(Vcb, FALSE, FALSE);

Definition at line 617 of file udf_info.h.

◆ UDFDecFileCounter

#define UDFDecFileCounter ( Vcb ) UDFChangeFileCounter(Vcb, TRUE, FALSE);

Definition at line 615 of file udf_info.h.

◆ UDFDecFileLinkCount

#define UDFDecFileLinkCount ( fi ) UDFChangeFileLinkCount(fi, FALSE)

Definition at line 581 of file udf_info.h.

◆ UDFDereferenceFile__

#define UDFDereferenceFile__ ( fi )

Value:

{                                                    \
    UDFInterlockedDecrement((PLONG)&((fi)->RefCount));  \
    UDFInterlockedDecrement((PLONG)&((fi)->Dloc->LinkRefCount));  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedDecrement((PLONG)&((fi)->ParentFile->OpenCount));  \
    }                                                \
}

Definition at line 1061 of file udf_info.h.

◆ UDFDirIndexGetLastIndex

#define UDFDirIndexGetLastIndex ( di ) ((((di)->FrameCount - 1) << UDF_DIR_INDEX_FRAME_SH) + (di)->LastFrameCount)

Definition at line 1122 of file udf_info.h.

◆ UDFDOSName__

#define UDFDOSName__	(	Vcb,
		DosName,
		UdfName,
		FileInfo
	)	UDFDOSName(Vcb, DosName, UdfName, (FileInfo) && ((FileInfo)->Index < 2));

Definition at line 217 of file udf_info.h.

◆ UDFExtentToMapping

#define UDFExtentToMapping ( e ) UDFExtentToMapping_(e)

Definition at line 181 of file udf_info.h.

◆ UDFGetBadBit

#define UDFGetBadBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1205 of file udf_info.h.

◆ UDFGetBit

#define UDFGetBit	(	arr,
		bit
	)	( (BOOLEAN) ( ((((uint32*)(arr))[(bit)>>5]) >> ((bit)&31)) &1 ) )

Definition at line 1180 of file udf_info.h.

◆ UDFGetFileAllocationSize

#define UDFGetFileAllocationSize	(	Vcb,
		FileInfo
	)	(((FileInfo)->Dloc->DataLoc.Mapping) ? UDFGetExtentLength((FileInfo)->Dloc->DataLoc.Mapping) : Vcb->LBlockSize)

Definition at line 797 of file udf_info.h.

◆ UDFGetFileAllocMode__

#define UDFGetFileAllocMode__ ( fi ) ((fi)->Dloc->DataLoc.Flags & EXTENT_FLAG_ALLOC_MASK)

Definition at line 1079 of file udf_info.h.

◆ UDFGetFileICBAllocMode__

#define UDFGetFileICBAllocMode__ ( fi ) (((PFILE_ENTRY)((fi)->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK)

Definition at line 1081 of file udf_info.h.

◆ UDFGetFreeBit

#define UDFGetFreeBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1199 of file udf_info.h.

◆ UDFGetLVIDiUse

#define UDFGetLVIDiUse ( Vcb )

Value:

    ( ((Vcb) && (Vcb)->LVid) ? \
        ( (LogicalVolIntegrityDescImpUse*) \
                     ( ((int8*)(Vcb->LVid+1)) + \
                       Vcb->LVid->numOfPartitions*2*sizeof(uint32))) \
       : NULL)

Definition at line 884 of file udf_info.h.

◆ UDFGetPartNumByPartNdx

#define UDFGetPartNumByPartNdx	(	Vcb,
		pi
	)	(Vcb->Partitions[pi].PartitionNum)

Definition at line 1028 of file udf_info.h.

◆ UDFGetUsedBit

#define UDFGetUsedBit	(	arr,
		bit
	)	(!UDFGetBit(arr,bit))

Definition at line 1198 of file udf_info.h.

◆ UDFGetZeroBit

#define UDFGetZeroBit	(	arr,
		bit
	)	UDFGetBit(arr,bit)

Definition at line 1207 of file udf_info.h.

◆ UDFHasAStreamDir

#define UDFHasAStreamDir ( FI ) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_HAS_SDIR))

Definition at line 1000 of file udf_info.h.

◆ UDFIncDirCounter

#define UDFIncDirCounter ( Vcb ) UDFChangeFileCounter(Vcb, FALSE, TRUE);

Definition at line 616 of file udf_info.h.

◆ UDFIncFileCounter

#define UDFIncFileCounter ( Vcb ) UDFChangeFileCounter(Vcb, TRUE, TRUE);

Definition at line 614 of file udf_info.h.

◆ UDFIncFileLinkCount

#define UDFIncFileLinkCount ( fi ) UDFChangeFileLinkCount(fi, TRUE)

Definition at line 580 of file udf_info.h.

◆ UDFIsADirectory

#define UDFIsADirectory ( FileInfo ) (((FileInfo) && ((FileInfo)->Dloc) && ((FileInfo)->Dloc->DirIndex || ((FileInfo)->FileIdent && ((FileInfo)->FileIdent->fileCharacteristics & FILE_DIRECTORY)))) ? TRUE : FALSE)

Definition at line 792 of file udf_info.h.

◆ UDFIsAStream

#define UDFIsAStream ( FI ) ((FI) && UDFIsAStreamDir((FI)->ParentFile))

Definition at line 1002 of file udf_info.h.

◆ UDFIsAStreamDir

#define UDFIsAStreamDir ( FI ) ((FI) && ((FI)->Dloc) && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR))

Definition at line 998 of file udf_info.h.

◆ UDFIsDeleted

#define UDFIsDeleted ( DirNdx ) (((DirNdx)->FileCharacteristics & FILE_DELETED) ? TRUE : FALSE)

Definition at line 788 of file udf_info.h.

◆ UDFIsDirEmpty__

#define UDFIsDirEmpty__ ( fi ) UDFIsDirEmpty((fi)->Dloc->DirIndex)

Definition at line 1070 of file udf_info.h.

◆ UDFIsDirOpened__

#define UDFIsDirOpened__ ( fi ) (fi->OpenCount)

Definition at line 1071 of file udf_info.h.

◆ UDFIsFileCached__

#define UDFIsFileCached__	(	Vcb,
		FileInfo,
		Offset,
		Length,
		ForWrite
	)	(UDFIsExtentCached(Vcb, &((FileInfo)->Dloc->DataLoc), Offset, Length, ForWrite))

Definition at line 839 of file udf_info.h.

◆ UDFIsFlushed

#define UDFIsFlushed ( FI )

Value:

    (   FI &&                    \
      !(FI->Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) &&      \
      !(FI->Dloc->DataLoc.Modified) && \
      !(FI->Dloc->AllocLoc.Modified) &&\
      !(FI->Dloc->FELoc.Modified) &&   \
      !(UDFGetDirIndexByFileInfo(FI)[FI->Index].FI_Flags & UDF_FI_FLAG_FI_MODIFIED) )

Definition at line 814 of file udf_info.h.

◆ UDFIsSDirDeleted

#define UDFIsSDirDeleted ( FI ) ((FI) && (FI)->Dloc && ((FI)->Dloc->FE_Flags & UDF_FE_FLAG_IS_DEL_SDIR))

Definition at line 1004 of file udf_info.h.

◆ UDFMarkAllocatedAsNotAllocated

#define UDFMarkAllocatedAsNotAllocated	(	Vcb,
		Off,
		Len,
		Ext
	)	UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, TRUE)

Definition at line 503 of file udf_info.h.

◆ UDFMarkRecordedAsAllocated

#define UDFMarkRecordedAsAllocated	(	Vcb,
		Off,
		Len,
		Ext
	)	UDFMarkAllocatedAsNotXXX(Vcb, Off, Len, Ext, FALSE)

Definition at line 516 of file udf_info.h.

◆ UDFMarkSpaceAsXXX

#define UDFMarkSpaceAsXXX	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	UDFMarkSpaceAsXXX_(Vcb, Map, asXXX);

Definition at line 322 of file udf_info.h.

◆ UDFMarkSpaceAsXXXNoProtect

#define UDFMarkSpaceAsXXXNoProtect	(	Vcb,
		FileInfo,
		Map,
		asXXX
	)	UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX);

Definition at line 302 of file udf_info.h.

◆ UDFNtAclSupported

#define UDFNtAclSupported ( Vcb ) (Vcb->maxUDFWriteRev >= 0x0200)

Definition at line 1040 of file udf_info.h.

◆ UDFReferenceFile__

#define UDFReferenceFile__ ( fi )

Value:

{                                                    \
    UDFInterlockedIncrement((PLONG)&((fi)->RefCount));  \
    UDFInterlockedIncrement((PLONG)&((fi)->Dloc->LinkRefCount));  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedIncrement((PLONG)&((fi)->ParentFile->OpenCount));  \
    }                                                \
}

Definition at line 1043 of file udf_info.h.

◆ UDFReferenceFileEx__

#define UDFReferenceFileEx__	(	fi,
		i
	)

Value:

{                                                    \
    UDFInterlockedExchangeAdd((PLONG)&((fi)->RefCount),i);  \
    UDFInterlockedExchangeAdd((PLONG)&((fi)->Dloc->LinkRefCount),i);  \
    if((fi)->ParentFile) {                           \
        UDFInterlockedExchangeAdd((PLONG)&((fi)->ParentFile->OpenCount),i);  \
    }                                                \
}

Definition at line 1052 of file udf_info.h.

◆ UDFRegisterFsStructure

#define UDFRegisterFsStructure	(	Vcb,
		Lba,
		Length
	)	{NOTHING;}

Definition at line 1250 of file udf_info.h.

◆ UDFSetBit

#define UDFSetBit	(	arr,
		bit
	)	( (((uint32*)(arr))[(bit)>>5]) \|= (((uint32)1) << ((bit)&31)) )

Definition at line 1181 of file udf_info.h.

◆ UDFSetBits

#define UDFSetBits	(	arr,
		bit,
		bc
	)

Value:

{uint32 j;                       \
    for(j=0;j<bc;j++) {          \
        UDFSetBit(arr, (bit)+j); \
}}

Definition at line 1184 of file udf_info.h.

◆ UDFSetEntityID_imp

#define UDFSetEntityID_imp	(	eID,
		Str
	)	UDFSetEntityID_imp_(eID, (uint8*)(Str), sizeof(Str));

Definition at line 598 of file udf_info.h.

◆ UDFSetFileAllocMode__

#define UDFSetFileAllocMode__	(	fi,
		mode
	)

Value:

{                                       \
    (fi)->Dloc->DataLoc.Flags = \
        ((fi)->Dloc->DataLoc.Flags & ~EXTENT_FLAG_ALLOC_MASK) | (mode & EXTENT_FLAG_ALLOC_MASK);     \
}

Definition at line 1073 of file udf_info.h.

◆ UDFSetFreeBit

#define UDFSetFreeBit	(	arr,
		bit
	)	UDFSetBit(arr,bit)

Definition at line 1201 of file udf_info.h.

◆ UDFSetFreeBitOwner

#define UDFSetFreeBitOwner	(	Vcb,
		i
	)

Definition at line 1235 of file udf_info.h.

◆ UDFSetFreeBits

#define UDFSetFreeBits	(	arr,
		bit,
		bc
	)	UDFSetBits(arr,bit,bc)

Definition at line 1203 of file udf_info.h.

◆ UDFSetUsedBit

#define UDFSetUsedBit	(	arr,
		bit
	)	UDFClrBit(arr,bit)

Definition at line 1200 of file udf_info.h.

◆ UDFSetUsedBitOwner

#define UDFSetUsedBitOwner	(	Vcb,
		i,
		o
	)

Definition at line 1236 of file udf_info.h.

◆ UDFSetUsedBits

#define UDFSetUsedBits	(	arr,
		bit,
		bc
	)	UDFClrBits(arr,bit,bc)

Definition at line 1202 of file udf_info.h.

◆ UDFSetZeroBit

#define UDFSetZeroBit	(	arr,
		bit
	)	UDFSetBit(arr,bit)

Definition at line 1208 of file udf_info.h.

◆ UDFSetZeroBits

#define UDFSetZeroBits	(	arr,
		bit,
		bc
	)	UDFSetBits(arr,bit,bc)

Definition at line 1210 of file udf_info.h.

◆ UDFSparseExtent__

#define UDFSparseExtent__	(	Vcb,
		Ext,
		Off,
		Len,
		Dir,
		WB
	)	UDFZeroExtent(Vcb, Ext, Off, Len, TRUE, Dir, WB)

Definition at line 542 of file udf_info.h.

◆ UDFStreamsSupported

#define UDFStreamsSupported ( Vcb ) (Vcb->maxUDFWriteRev >= 0x0200)

Definition at line 1037 of file udf_info.h.

◆ UDFZeroExtent__

#define UDFZeroExtent__	(	Vcb,
		Ext,
		Off,
		Len,
		Dir,
		WB
	)	UDFZeroExtent(Vcb, Ext, Off, Len, FALSE, Dir, WB)

Definition at line 539 of file udf_info.h.

◆ UFD_VERIFY_FLAG_BG

#define UFD_VERIFY_FLAG_BG 0x04

Definition at line 1304 of file udf_info.h.

◆ UFD_VERIFY_FLAG_FORCE

#define UFD_VERIFY_FLAG_FORCE 0x01

Definition at line 1302 of file udf_info.h.

◆ UFD_VERIFY_FLAG_LOCKED

#define UFD_VERIFY_FLAG_LOCKED 0x10

Definition at line 1305 of file udf_info.h.

◆ UFD_VERIFY_FLAG_WAIT

#define UFD_VERIFY_FLAG_WAIT 0x02

Definition at line 1303 of file udf_info.h.

Function Documentation

◆ crc32()

uint32 __fastcall crc32	(	IN uint8 *	s,
		IN uint32	len
	)

Definition at line 4290 of file udf_info.cpp.

{
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
//    uint32 _Size = len;
 
    __asm {
        push  ebx
        push  ecx
        push  edx
        push  esi
 
        xor   eax,eax
        mov   esi,ecx  // ESI <- s
        mov   ecx,edx  // ECX <- len
 
        jecxz EO_CRC
 
        lea   ebx,[crc32_tab]
        xor   edx,edx
 
CRC_loop:
 
        mov   dl,al
        xor   dl,[esi]
        shr   eax,8
        xor   eax,[dword ptr ebx+edx*4]
        inc   esi
        loop  CRC_loop
 
EO_CRC:
 
        pop   esi
        pop   edx
        pop   ecx
        pop   ebx
 
        ret
    }
#else  // NO X86 optimization , use generic C/C++
    uint32 i;
    uint32 crc32val = 0;
 
    for(i=0; i<len; i++, s++) {
        crc32val =
            crc32_tab[(crc32val ^ (*s)) & 0xff] ^ (crc32val >> 8);
    }
    return crc32val;
#endif // _X86_
} // end crc32()

◆ UDFAcquireDloc()

OSSTATUS UDFAcquireDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1206 of file dirtree.cpp.

{
    UDFAcquireResourceExclusive(&(Vcb->DlocResource2),TRUE);
    if(Dloc->FE_Flags & UDF_FE_FLAG_UNDER_INIT) {
        UDFReleaseResource(&(Vcb->DlocResource2));
        return STATUS_SHARING_PAUSED;
    }
    Dloc->FE_Flags |= UDF_FE_FLAG_UNDER_INIT;
    UDFReleaseResource(&(Vcb->DlocResource2));
    return STATUS_SUCCESS;
} // end UDFAcquireDloc()

Referenced by UDFStoreDloc().

◆ UDFAddXSpaceBitmap()

OSSTATUS UDFAddXSpaceBitmap	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN PSHORT_AD	bm,
		IN ULONG	bm_type
	)

Definition at line 1569 of file mount.cpp.

{
    int8* tmp;
    int8* tmp_bm;
    uint32 i, lim, j, lba, l, lim2, l2, k;
    lb_addr locAddr;
    OSSTATUS status;
    uint16 Ident;
    uint32 flags;
    SIZE_T Length;
    SIZE_T ReadBytes;
    BOOLEAN bit_set;
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
    UDFPrint(("UDFAddXSpaceBitmap: at block=%x, partition=%d\n",
        bm->extPosition,
        PartNum));
 
    if(!(Length = (bm->extLength & UDF_EXTENT_LENGTH_MASK))) return STATUS_SUCCESS;
    i=UDFPartStart(Vcb, PartNum);
    flags = bm->extLength >> 30;
    if(!flags /*|| flags == EXTENT_NOT_RECORDED_ALLOCATED*/) {
        tmp = (int8*)DbgAllocatePool(NonPagedPool, max(Length, Vcb->BlockSize));
        if(!tmp) return STATUS_INSUFFICIENT_RESOURCES;
        locAddr.partitionReferenceNum = (uint16)PartNum;
        locAddr.logicalBlockNum = bm->extPosition;
        // read header of the Bitmap
        if(!OS_SUCCESS(status = UDFReadTagged(Vcb, tmp, lba = UDFPartLbaToPhys(Vcb, &(locAddr)),
                             locAddr.logicalBlockNum, &Ident)) ) {
err_addxsbm_1:
            DbgFreePool(tmp);
            return status;
        }
        if(Ident != TID_SPACE_BITMAP_DESC) {
            status = STATUS_DISK_CORRUPT_ERROR;
            goto err_addxsbm_1;
        }
        UDFRegisterFsStructure(Vcb, lba, Vcb->BlockSize);
        // read the whole Bitmap
        if(!OS_SUCCESS(status = UDFReadData(Vcb, FALSE, ((uint64)lba)<<Vcb->BlockSizeBits, Length, FALSE, tmp, &ReadBytes)))
            goto err_addxsbm_1;
        UDFRegisterFsStructure(Vcb, lba, Length);
        lim = min(i + ((lim2 = ((PSPACE_BITMAP_DESC)tmp)->numOfBits) << Vcb->LB2B_Bits), Vcb->FSBM_BitCount);
        tmp_bm = tmp + sizeof(SPACE_BITMAP_DESC);
        j = 0;
        for(;(l = UDFGetBitmapLen((uint32*)tmp_bm, j, lim2)) && (i<lim);) {
            // expand LBlocks to Sectors...
            l2 = l << Vcb->LB2B_Bits;
            // ...and mark them
            if(bm_type == UDF_FSPACE_BM) {
                bit_set = UDFGetFreeBit(tmp_bm, j);
                for(k=0;(k<l2) && (i<lim);k++) {
                    if(bit_set) {
                        // FREE block
                        UDFSetFreeBit(Vcb->FSBM_Bitmap, i);
                        UDFSetFreeBitOwner(Vcb, i);
                        UDFSetZeroBit(Vcb->ZSBM_Bitmap, i);
                    } else {
                        // USED block
                        UDFClrZeroBit(Vcb->ZSBM_Bitmap, i);
                    }
                    i++;
                }
            } else {
                bit_set = UDFGetZeroBit(tmp_bm, j);
                for(k=0;(k<l2) && (i<lim);k++) {
                    if(bit_set) {
                        // ZERO block
                        UDFSetZeroBit(Vcb->ZSBM_Bitmap, i);
                    } else {
                        // DATA block
                        UDFClrZeroBit(Vcb->ZSBM_Bitmap, i);
                    }
                    i++;
                }
            }
            j += l;
        }
        DbgFreePool(tmp);
/*    } else if((bm->extLength >> 30) == EXTENT_NOT_RECORDED_ALLOCATED) {
        i=Vcb->Partitions[PartNum].PartitionRoot;
        lim = i + Vcb->Partitions[PartNum].PartitionLen;
        for(;i<lim;i++) {
            UDFSetUsedBit(Vcb->FSBM_Bitmap, i);
        }*/
    }
    return STATUS_SUCCESS;
} // end UDFAddXSpaceBitmap()

Referenced by UDFBuildFreeSpaceBitmap().

◆ UDFAllocateFESpace()

OSSTATUS UDFAllocateFESpace	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN uint32	PartNum,
		IN PEXTENT_INFO	FEExtInfo,
		IN uint32	Len
	)

Definition at line 1563 of file extent.cpp.

{
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
    OSSTATUS status;
    PEXTENT_INFO Ext;
    EXTENT_AD Extent;
    BOOLEAN retry = FALSE;
    uint32 i, lim;
 
/*
    1. #Dir1#->*File*                ->  Dir1's FECharge
    2. #Dir1#->*Dir*                 ->  Dir1's FECharge
    3. #Dir1#->*SDir*                ->  Dir1's FECharge
    4. Dir1->#SDir#->*Stream*        ->  Dir1's FEChargeSDir
    5. Dir1->#File#->*SDir*          ->  Dir1's FEChargeSDir
    6. Dir1->#Dir#->*SDir*           ->  (see p.2)
    7. Dir1->File->#SDir#->*Stream*  ->  Dir1's FEChargeSDir
    8. Dir1->Dir->#SDir#->*Stream*   ->  (see p.4)
 
## ~ DirInfo
** ~ Object to be created
 
*/
 
//    ASSERT(!FEExtInfo->Mapping);
    // check if DirInfo we are called with is a Directory
    // (it can be a file with SDir)
    if(!DirInfo || !DirInfo->Dloc->DirIndex ||
       ((lim = ((DirInfo->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR) ? Vcb->FEChargeSDir : Vcb->FECharge)) <= 1))
#endif // UDF_FE_ALLOCATION_CHARGE
        return UDFAllocFreeExtent(Vcb, Len,
               UDFPartStart(Vcb, PartNum), UDFPartEnd(Vcb, PartNum), FEExtInfo, EXTENT_FLAG_VERIFY);
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
 
    Ext = &(DirInfo->Dloc->DirIndex->FECharge);
 
    while(TRUE) {
 
        if(!Ext->Mapping) {
            ULONG p_start;
            ULONG p_end;
            ULONG fe_loc;
            ULONG l1, l2;
 
            p_start = UDFPartStart(Vcb, PartNum);
            p_end   = UDFPartEnd(Vcb, PartNum);
            fe_loc  = DirInfo->Dloc->FELoc.Mapping[0].extLocation;
 
            status = UDFGetCachedAllocation(Vcb, fe_loc, Ext, NULL, UDF_PREALLOC_CLASS_FE);
            if(OS_SUCCESS(status)) {
                // do nothing, even do not unpack
            } else
            if(Vcb->LowFreeSpace) {
                status = UDFAllocFreeExtent(Vcb, Len << Vcb->LBlockSizeBits,p_start, p_end, FEExtInfo, EXTENT_FLAG_VERIFY);
                if(OS_SUCCESS(status)) {
                    UDFPrint(("FE @ %x (1)\n", FEExtInfo->Mapping[0].extLocation ));
                }
                return status;
            } else {
                if(fe_loc > p_start + 512*16) {
                    l1 = fe_loc - 512*16;
                } else {
                    l1 = p_start;
                }
                if(fe_loc + 512*16 < p_end) {
                    l2 = fe_loc + 512*16;
                } else {
                    l2 = p_end;
                }
                status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, l1, l2, Ext, EXTENT_FLAG_VERIFY);
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, (p_start+fe_loc)/2, (fe_loc+p_end)/2, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start, p_end, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status)) {
                    status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start+1024, p_end-1024, Ext, EXTENT_FLAG_VERIFY);
                }
                if(!OS_SUCCESS(status = UDFAllocFreeExtent(Vcb, lim << Vcb->LBlockSizeBits, p_start, p_end, Ext, EXTENT_FLAG_VERIFY) )) {
                    // can't pre-allocate space for multiple FEs. Try single FE
                    UDFPrint(("allocate single FE entry\n"));
                    status = UDFAllocFreeExtent(Vcb, Len,
                           p_start, p_end, FEExtInfo, EXTENT_FLAG_VERIFY);
                    if(OS_SUCCESS(status)) {
                        UDFPrint(("FE @ %x (2)\n", FEExtInfo->Mapping[0].extLocation ));
                    }
                    return status;
                }
                status = UDFUnPackMapping(Vcb, Ext);
                if(!OS_SUCCESS(status)) {
                    MyFreePool__(Ext->Mapping);
                    Ext->Mapping = NULL;
                    return status;
                }
            }
        }
 
        for(i=0;i<lim;i++) {
            if( (Ext->Mapping[i].extLength >> 30) == EXTENT_NOT_RECORDED_ALLOCATED ) {
                Ext->Mapping[i].extLength &= UDF_EXTENT_LENGTH_MASK; // EXTENT_RECORDED_ALLOCATED
 
                Extent.extLength = Vcb->LBlockSize | (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                Extent.extLocation = Ext->Mapping[i].extLocation;
 
                if(Vcb->BSBM_Bitmap) {
                    uint32 lba = Ext->Mapping[i].extLocation;
                    if(UDFGetBadBit((uint32*)(Vcb->BSBM_Bitmap), lba)) {
                        UDFPrint(("Remove BB @ %x from FE charge\n", lba));
                        Ext->Mapping[i].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
                        Ext->Mapping[i].extLocation = 0;
                        continue;
                    }
                }
 
                FEExtInfo->Mapping = UDFExtentToMapping(&Extent);
                if(!FEExtInfo->Mapping) {
                    ASSERT(!(Ext->Mapping[i].extLength >> 30));
                    Ext->Mapping[i].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                UDFPrint(("FE @ %x (3)\n", FEExtInfo->Mapping[0].extLocation ));
                FEExtInfo->Length = Len;
                FEExtInfo->Offset = 0;
                FEExtInfo->Modified = TRUE;
                return STATUS_SUCCESS;
            }
        }
 
        if(Vcb->LowFreeSpace) {
            status = UDFAllocFreeExtent(Vcb, Len,
                   UDFPartStart(Vcb, PartNum), UDFPartEnd(Vcb, PartNum), FEExtInfo, EXTENT_FLAG_VERIFY);
            if(OS_SUCCESS(status)) {
                UDFPrint(("FE @ %x (4)\n", FEExtInfo->Mapping[0].extLocation ));
            }
            return status;
        }
        if(retry)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        // we can get here if there are no free slots in
        // preallocated FE charge. So, we should release
        // memory and try to allocate space for new FE charge.
        MyFreePool__(Ext->Mapping);
        Ext->Mapping = NULL;
        retry = TRUE;
    }
    return STATUS_INSUFFICIENT_RESOURCES;
#endif // UDF_FE_ALLOCATION_CHARGE
 
} // end UDFAllocateFESpace()

Referenced by UDFBuildFileEntry(), and UDFFlushFE().

◆ UDFAllocFreeExtent_()

OSSTATUS UDFAllocFreeExtent_	(	IN PVCB	Vcb,
		IN int64	Length,
		IN uint32	SearchStart,
		IN uint32	SearchLim,
		OUT PEXTENT_INFO	Extent,
		IN uint8	AllocFlags
	)

Definition at line 963 of file alloc.cpp.

{
    EXTENT_AD Ext;
    PEXTENT_MAP Map = NULL;
    uint32 len, LBS, BSh, blen;
 
    LBS = Vcb->LBlockSize;
    BSh = Vcb->BlockSizeBits;
    blen = (uint32)(((Length+LBS-1) & ~((int64)LBS-1)) >> BSh);
    ExtInfo->Mapping = NULL;
    ExtInfo->Offset = 0;
 
    ASSERT(blen <= (uint32)(UDF_MAX_EXTENT_LENGTH >> BSh));
 
    UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
 
    if(blen > (SearchLim - SearchStart)) {
        goto no_free_space_err;
    }
    // walk through the free space bitmap & find a single extent or a set of
    // frags giving in sum the Length specified
    while(blen) {
        Ext.extLocation = UDFFindMinSuitableExtent(Vcb, blen, SearchStart,
                                                               SearchLim, &len, AllocFlags);
 
//        ASSERT(len <= (uint32)(UDF_MAX_EXTENT_LENGTH >> BSh));
        if(len >= blen) {
            // complete search
            Ext.extLength = blen<<BSh;
            blen = 0;
        } else if(len) {
            // we need still some frags to complete request &
            // probably we have the opportunity to do it
            Ext.extLength = len<<BSh;
            blen -= len;
        } else {
no_free_space_err:
            // no more free space. abort
            if(ExtInfo->Mapping) {
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_DISCARDED); // free
                MyFreePool__(ExtInfo->Mapping);
                ExtInfo->Mapping = NULL;
            }
            UDFReleaseResource(&(Vcb->BitMapResource1));
            ExtInfo->Length = 0;//UDFGetExtentLength(ExtInfo->Mapping);
            AdPrint(("  DISK_FULL\n"));
            return STATUS_DISK_FULL;
        }
        // append the frag found to mapping
        ASSERT(!(Ext.extLength >> 30));
        ASSERT(Ext.extLocation);
 
        // mark newly allocated blocks as zero-filled
        UDFSetZeroBits(Vcb->ZSBM_Bitmap, Ext.extLocation, (Ext.extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
 
        if(AllocFlags & EXTENT_FLAG_VERIFY) {
            if(!UDFCheckArea(Vcb, Ext.extLocation, Ext.extLength >> BSh)) {
                AdPrint(("newly allocated extent contains BB\n"));
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_DISCARDED); // free
                UDFMarkBadSpaceAsUsed(Vcb, Ext.extLocation, Ext.extLength >> BSh); // bad -> bad+used
                // roll back
                blen += Ext.extLength>>BSh;
                continue;
            }
        }
 
        Ext.extLength |= EXTENT_NOT_RECORDED_ALLOCATED << 30;
        if(!(ExtInfo->Mapping)) {
            // create new
#ifdef UDF_TRACK_ALLOC_FREE_EXTENT
            ExtInfo->Mapping = UDFExtentToMapping_(&Ext, src, line);
#else // UDF_TRACK_ALLOC_FREE_EXTENT
            ExtInfo->Mapping = UDFExtentToMapping(&Ext);
#endif // UDF_TRACK_ALLOC_FREE_EXTENT
            if(!ExtInfo->Mapping) {
                BrutePoint();
                UDFReleaseResource(&(Vcb->BitMapResource1));
                ExtInfo->Length = 0;
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, ExtInfo->Mapping, AS_USED); // used
        } else {
            // update existing
            Map = UDFExtentToMapping(&Ext);
            if(!Map) {
                BrutePoint();
                UDFReleaseResource(&(Vcb->BitMapResource1));
                ExtInfo->Length = UDFGetExtentLength(ExtInfo->Mapping);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, Map, AS_USED); // used
            ExtInfo->Mapping = UDFMergeMappings(ExtInfo->Mapping, Map);
            MyFreePool__(Map);
        }
        if(!ExtInfo->Mapping) {
            BrutePoint();
            UDFReleaseResource(&(Vcb->BitMapResource1));
            ExtInfo->Length = 0;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    UDFReleaseResource(&(Vcb->BitMapResource1));
    ExtInfo->Length = Length;
    return STATUS_SUCCESS;
} // end UDFAllocFreeExtent_()

◆ UDFAreSectorsRelocated()

BOOLEAN __fastcall UDFAreSectorsRelocated	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BlockCount
	)

Definition at line 982 of file remap.cpp.

{
 
    if(Vcb->SparingTable) {
        // use sparing table for relocation
        uint32 i, BS, orig;
        BS = Vcb->SparingBlockSize;
        PSPARING_MAP Map;
 
        Map = Vcb->SparingTable;
        for(i=0;i<Vcb->SparingCount;i++,Map++) {
            if( ((Lba >= (orig = Map->origLocation)) && (Lba < orig + BS)) ||
                ((Lba+BlockCount-1 >= orig) && (Lba+BlockCount-1 < orig + BS)) ||
                ((orig >= Lba) && (orig < Lba+BlockCount)) ||
                ((orig+BS >= Lba) && (orig+BS < Lba+BlockCount)) ) {
                return TRUE;
            }
        }
    } else if(Vcb->Vat) {
        // use VAT for relocation
        uint32 i, root, j;
        uint32* Map;
        if(Lba < (root = Vcb->Partitions[Vcb->VatPartNdx].PartitionRoot))
            return FALSE;
        if(Lba+BlockCount >= Vcb->NWA)
            return TRUE;
        Map = &(Vcb->Vat[Lba-root/*+i*/]);
        for(i=0; i<BlockCount; i++, Map++) {
            if((j = (*Map)) &&
               (j != Lba-root+i) &&
               ((j != UDF_VAT_FREE_ENTRY) || ((Lba+i) < Vcb->LastLBA)))
                return TRUE;
        }
    }
    return FALSE;
} // end UDFAreSectorsRelocated()

Referenced by UDFRelocateSectors().

◆ UDFBuildAllocDescs()

OSSTATUS UDFBuildAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN OUT PUDF_FILE_INFO	FileInfo,
		OUT int8 **	AllocData
	)

Definition at line 2628 of file extent.cpp.

{
//    PEXTENT_MAP InMap;
//    uint32 i=0;
    int8* Allocs;
    uint16 AllocMode;
    uint32 InitSz;
    OSSTATUS status;
 
    ValidateFileInfo(FileInfo);
    AdPrint(("BuildAllocDesc\n"));
    // get space available in the 1st LBlock after FE
    InitSz = Vcb->LBlockSize - FileInfo->Dloc->FileEntryLen;
    Allocs = (int8*)MyAllocatePool__(NonPagedPool, InitSz);
    if(!Allocs) {
        *AllocData = NULL;
        AdPrint(("BuildAllocDesc: cant alloc %x bytes for Allocs\n", InitSz));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    RtlZeroMemory(Allocs, InitSz);
//    InMap = FileInfo->Dloc->DataLoc.Mapping;
    UDFCheckSpaceAllocation(Vcb, 0, InMap, AS_USED); // check if used
 
    // TODO: move data from mapped locations here
 
    AllocMode = ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
    switch(AllocMode) {
    case ICB_FLAG_AD_IN_ICB: {
        MyFreePool__(Allocs);
        ASSERT(!FileInfo->Dloc->AllocLoc.Mapping);
        Allocs = NULL;
        status = STATUS_SUCCESS;
        break;
    }
    case ICB_FLAG_AD_SHORT: {
        status = UDFBuildShortAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }
    case ICB_FLAG_AD_LONG: {
        status = UDFBuildLongAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }
/*    case ICB_FLAG_AD_EXTENDED: {
        status = UDFBuildExtAllocDescs(Vcb, PartNum, &Allocs, InitSz, FileInfo);
        break;
    }*/
    default: {
        MyFreePool__(Allocs);
        Allocs = NULL;
        status = STATUS_INVALID_PARAMETER;
    }
    }
 
    *AllocData = Allocs;
    UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
 
    return status;
} // end UDFBuildAllocDescs()

Referenced by UDFFlushFE().

◆ UDFBuildFileEntry()

OSSTATUS UDFBuildFileEntry	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint32	PartNum,
		IN uint16	AllocMode,
		IN uint32	ExtAttrSz,
		IN BOOLEAN	Extended
	)

Definition at line 971 of file udf_info.cpp.

{
    PFILE_ENTRY FileEntry;
    OSSTATUS status;
//    EntityID* eID;
    uint32 l;
    EXTENT_INFO _FEExtInfo;
    uint16* lcp;
 
    ASSERT(!PartNum);
    ASSERT(!ExtAttrSz);
    // calculate the length required
    l = (Extended ? sizeof(EXTENDED_FILE_ENTRY) : sizeof(FILE_ENTRY)) + ExtAttrSz;
    if(l > Vcb->LBlockSize) return STATUS_INVALID_PARAMETER;
    // allocate block for FE
    if(!OS_SUCCESS(status = UDFAllocateFESpace(Vcb, DirInfo, PartNum, &_FEExtInfo, l) ))
        return status;
    // remember FE location for future hard link creation
    ASSERT(UDFFindDloc(Vcb, _FEExtInfo.Mapping[0].extLocation) == (-1));
    if(!OS_SUCCESS(status = UDFStoreDloc(Vcb, FileInfo, _FEExtInfo.Mapping[0].extLocation))) {
        ASSERT(status != STATUS_SHARING_PAUSED);
        UDFFreeFESpace(Vcb, DirInfo, &_FEExtInfo); // free
        MyFreePool__(_FEExtInfo.Mapping);
        return status;
    }
    FileEntry = (PFILE_ENTRY)MyAllocatePoolTag__(NonPagedPool, l, MEM_FE_TAG);
    if(!FileEntry) {
        UDFRemoveDloc(Vcb, FileInfo->Dloc);
        FileInfo->Dloc = NULL;
        UDFFreeFESpace(Vcb, DirInfo, &_FEExtInfo); // free
        MyFreePool__(_FEExtInfo.Mapping);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    FileInfo->Dloc->FELoc = _FEExtInfo;
 
    RtlZeroMemory((int8*)FileEntry, l);
    // set up in-memory FE structure
    FileEntry->icbTag.flags = AllocMode;
    FileEntry->icbTag.fileType = UDF_FILE_TYPE_REGULAR;
    FileEntry->icbTag.numEntries = 1;
//    if(DirInfo && DirInfo->Dloc && DirInfo->Dloc
    FileEntry->icbTag.strategyType = 4;
//    FileEntry->icbTag.strategyParameter = 0;
    FileEntry->descTag.tagIdent = Extended ? TID_EXTENDED_FILE_ENTRY : TID_FILE_ENTRY;
    FileEntry->descTag.tagLocation = UDFPhysLbaToPart(Vcb, PartNum, _FEExtInfo.Mapping[0].extLocation);
    FileEntry->uid = Vcb->DefaultUID;
    FileEntry->gid = Vcb->DefaultGID;
 
    if(Extended) {
//        eID = &(((PEXTENDED_FILE_ENTRY)FileEntry)->impIdent);
        lcp = &(((PEXTENDED_FILE_ENTRY)FileEntry)->fileLinkCount);
        ((PEXTENDED_FILE_ENTRY)FileEntry)->checkpoint = 1;
    } else {
//        eID = &(FileEntry->impIdent);
        lcp = &(FileEntry->fileLinkCount);
        ((PFILE_ENTRY)FileEntry)->checkpoint = 1;
    }
 
#if 0
    UDFSetEntityID_imp(eID, UDF_ID_DEVELOPER);
#endif
 
    /*RtlCopyMemory((int8*)&(eID->ident), UDF_ID_DEVELOPER, sizeof(UDF_ID_DEVELOPER) );
    iis = (impIdentSuffix*)&(eID->identSuffix);
    iis->OSClass = UDF_OS_CLASS_WINNT;
    iis->OSIdent = UDF_OS_ID_WINNT;*/
 
    *lcp = 0xffff;
 
    FileInfo->Dloc->FileEntry = (tag*)FileEntry;
    FileInfo->Dloc->FileEntryLen = l;
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
 
    return STATUS_SUCCESS;
} // end UDFBuildFileEntry()

Referenced by UDFCreateFile__(), and UDFCreateRootFile__().

◆ UDFBuildFileIdent()

OSSTATUS UDFBuildFileIdent	(	IN PVCB	Vcb,
		IN PUNICODE_STRING	fn,
		IN PLONG_AD	FileEntryIcb,
		IN uint32	ImpUseLen,
		OUT PFILE_IDENT_DESC *	_FileId,
		OUT uint32 *	FileIdLen
	)

Definition at line 1107 of file udf_info.cpp.

{
    PFILE_IDENT_DESC FileId;
    uint8* CS0;
    SIZE_T Nlen;
    uint32 l;
    // prepare filename
    UDFCompressUnicode(fn, &CS0, &Nlen);
    if(!CS0) return STATUS_INSUFFICIENT_RESOURCES;
    if(Nlen < 2) {
        Nlen = 0;
    } else
    if(Nlen > UDF_NAME_LEN) {
        if(CS0) MyFreePool__(CS0);
        return STATUS_OBJECT_NAME_INVALID;
    }
    // allocate memory for FI
    l = (sizeof(FILE_IDENT_DESC) + Nlen + ImpUseLen + 3) & ~((uint32)3);
    FileId = (PFILE_IDENT_DESC)MyAllocatePoolTag__(NonPagedPool, l, MEM_FID_TAG);
    if(!FileId) {
        if(CS0) MyFreePool__(CS0);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    // fill FI structure
    RtlZeroMemory( (int8*)FileId, l);
    RtlCopyMemory( ((int8*)(FileId+1))+ImpUseLen, CS0, Nlen);
    FileId->descTag.tagIdent = TID_FILE_IDENT_DESC;
    FileId->fileVersionNum = 1;
    FileId->lengthOfImpUse = (uint16)ImpUseLen;
    FileId->lengthFileIdent = (uint8)Nlen;
    FileId->icb = *FileEntryIcb;
    *_FileId = FileId;
    *FileIdLen = l;
 
    if(CS0) MyFreePool__(CS0);
    return STATUS_SUCCESS;
} // end UDFBuildFileIdent()

Referenced by UDFCreateFile__(), and UDFRecordDirectory__().

◆ UDFBuildFreeSpaceBitmap()

OSSTATUS UDFBuildFreeSpaceBitmap	(	IN PVCB	Vcb,
		IN uint32	PartNdx,
		IN PPARTITION_HEADER_DESC	phd,
		IN uint32	Lba
	)

Definition at line 1910 of file mount.cpp.

{
    OSSTATUS status;
    uint32 i, l;
    uint16 Ident;
    int8* AllocDesc;
    PEXTENT_MAP Extent;
    lb_addr locAddr;
    uint32 PartNum;
 
    PartNum = UDFGetPartNumByPartNdx(Vcb, PartNdx);
    if(!(Vcb->FSBM_Bitmap)) {
        // init Bitmap buffer if necessary
        Vcb->FSBM_Bitmap = (int8*)DbgAllocatePool(NonPagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3) );
        if(!(Vcb->FSBM_Bitmap)) return STATUS_INSUFFICIENT_RESOURCES;
 
        Vcb->ZSBM_Bitmap = (int8*)DbgAllocatePool(NonPagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3) );
        if(!(Vcb->ZSBM_Bitmap)) {
#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS
free_fsbm:
#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS
            MyFreePool__(Vcb->FSBM_Bitmap);
            Vcb->FSBM_Bitmap = NULL;
            return STATUS_INSUFFICIENT_RESOURCES;
        }
 
        RtlZeroMemory(Vcb->FSBM_Bitmap, i);
        RtlZeroMemory(Vcb->ZSBM_Bitmap, i);
#ifdef UDF_TRACK_ONDISK_ALLOCATION_OWNERS
        Vcb->FSBM_Bitmap_owners = (uint32*)DbgAllocatePool(NonPagedPool, (Vcb->LastPossibleLBA+1)*sizeof(uint32));
        if(!(Vcb->FSBM_Bitmap_owners)) {
            MyFreePool__(Vcb->ZSBM_Bitmap);
            Vcb->ZSBM_Bitmap = NULL;
            goto free_fsbm;
        }
        RtlFillMemory(Vcb->FSBM_Bitmap_owners, (Vcb->LastPossibleLBA+1)*sizeof(uint32), 0xff);
#endif //UDF_TRACK_ONDISK_ALLOCATION_OWNERS
        Vcb->FSBM_ByteCount = i;
        Vcb->FSBM_BitCount = Vcb->LastPossibleLBA+1;
    }
    // read info for partition header (if any)
    if(phd) {
        // read unallocated Bitmap
        if(!OS_SUCCESS(status = UDFAddXSpaceBitmap(Vcb, PartNum, &(phd->unallocatedSpaceBitmap), UDF_FSPACE_BM)))
            return status;
        // read freed Bitmap
        if(!OS_SUCCESS(status = UDFAddXSpaceBitmap(Vcb, PartNum, &(phd->freedSpaceBitmap), UDF_ZSPACE_BM)))
            return status;
    }
    // read UnallocatedSpaceDesc & convert to Bitmap
    if(Lba) {
        if(!(AllocDesc = (int8*)MyAllocatePool__(NonPagedPool, Vcb->LBlockSize + sizeof(EXTENT_AD) )))
            return STATUS_INSUFFICIENT_RESOURCES;
        RtlZeroMemory(((int8*)AllocDesc) + Vcb->LBlockSize, sizeof(EXTENT_AD));
        if(!OS_SUCCESS(status = UDFReadTagged(Vcb, AllocDesc, Lba, Lba, &Ident)) ||
           !(Extent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, l = (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) ))) {
            MyFreePool__(AllocDesc);
            return status;
        }
        UDFRegisterFsStructure(Vcb, Lba, Vcb->BlockSize);
        RtlCopyMemory((int8*)Extent, AllocDesc+sizeof(UNALLOC_SPACE_DESC), (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) );
        locAddr.partitionReferenceNum = (uint16)PartNum;
        // read extent is recorded with relative addresses
        // so, we should convert it to suitable form
        for(i=0; Extent[i].extLength; i++) {
            locAddr.logicalBlockNum = Extent[i].extLocation;
            Extent[i].extLocation = UDFPartLbaToPhys(Vcb, &locAddr);
            if(Extent[i].extLocation == LBA_OUT_OF_EXTENT) {
                BrutePoint();
                MyFreePool__(AllocDesc);
                return STATUS_DISK_CORRUPT_ERROR;
            }
            if((Extent[i].extLocation >> 30) == EXTENT_NEXT_EXTENT_ALLOCDESC) {
                // load continuation
                Lba = Extent[i].extLocation & UDF_EXTENT_LENGTH_MASK;
                if(!OS_SUCCESS(status = UDFReadTagged(Vcb, AllocDesc, Lba, Lba, &Ident)) ||
                   !(Extent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, (((PUNALLOC_SPACE_DESC)AllocDesc)->numAllocDescs+1) * sizeof(EXTENT_AD) ))) {
                    MyFreePool__(AllocDesc);
                    return status;
                }
                if(Ident == TID_UNALLOC_SPACE_DESC) {
                    UDFRegisterFsStructure(Vcb, Lba, Vcb->BlockSize);
                    if(!(l = MyReallocPool__((int8*)Extent, l, (int8**)&Extent, i*sizeof(EXTENT_MAP)))) {
                        MyFreePool__(Extent);
                        MyFreePool__(AllocDesc);
                        return STATUS_INSUFFICIENT_RESOURCES;
                    }
                    Extent[i].extLength =
                    Extent[i].extLocation = 0;
                    Extent = UDFMergeMappings(Extent, (PEXTENT_MAP)(AllocDesc+sizeof(UNALLOC_SPACE_DESC)) );
#ifdef UDF_DBG
                } else {
                    UDFPrint(("Broken unallocated space descriptor sequence\n"));
#endif // UDF_DBG
                }
            }
        }
        UDFMarkSpaceAsXXX(Vcb, (-1), Extent, AS_USED); // mark as used
        MyFreePool__(Extent);
        MyFreePool__(AllocDesc);
    }
    return status;
} // end UDFVerifyFreeSpaceBitmap()

Referenced by UDFLoadPartDesc(), and UDFProcessSequence().

◆ UDFBuildHashEntry()

uint8 UDFBuildHashEntry	(	IN PVCB	Vcb,
		IN PUNICODE_STRING	Name,
		OUT PHASH_ENTRY	hashes,
		IN uint8	Mask
	)

Definition at line 429 of file dirtree.cpp.

{
    UNICODE_STRING UName;
    WCHAR ShortNameBuffer[13];
    uint8 RetFlags = 0;
 
    if(!Name->Buffer) return 0;
 
    if(Mask & HASH_POSIX)
        hashes->hPosix = crc32((uint8*)(Name->Buffer), Name->Length);
 
    if(Mask & HASH_ULFN) {
/*        if(OS_SUCCESS(MyInitUnicodeString(&UName, L"")) &&
           OS_SUCCESS(MyAppendUnicodeStringToStringTag(&UName, Name, MEM_USDIRHASH_TAG))) {*/
        if(OS_SUCCESS(MyCloneUnicodeString(&UName, Name))) {
            RtlUpcaseUnicodeString(&UName, &UName, FALSE);
    /*        if(!RtlCompareUnicodeString(Name, &UName, FALSE)) {
                RetFlags |= UDF_FI_FLAG_LFN;
            }*/
            hashes->hLfn = crc32((uint8*)(UName.Buffer), UName.Length);
        } else {
            BrutePoint();
        }
        MyFreePool__(UName.Buffer);
    }
 
    if(Mask & HASH_DOS) {
        UName.Buffer = (PWCHAR)(&ShortNameBuffer);
        UName.MaximumLength = 13*sizeof(WCHAR);
        UDFDOSName(Vcb, &UName, Name, (Mask & HASH_KEEP_NAME) ? TRUE : FALSE);
        if(!RtlCompareUnicodeString(Name, &UName, TRUE)) {
            RetFlags |= UDF_FI_FLAG_DOS;
        }
        hashes->hDos = crc32((uint8*)(UName.Buffer), UName.Length);
    }
    return RetFlags;
} // UDFBuildHashEntry()

Referenced by UDFBlankMount(), UDFCreateFile__(), UDFFindFile(), UDFIndexDirectory(), UDFQueryDirectory(), and UDFRenameMoveFile__().

◆ UDFBuildLongAllocDescs()

OSSTATUS UDFBuildLongAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		OUT int8 **	Buff,
		IN uint32	InitSz,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 1012 of file extent.cpp.

{
    uint32 i, j;
    uint32 len=0;
    PEXTENT_MAP Extent = FileInfo->Dloc->DataLoc.Mapping;
    PEXTENT_INFO AllocExtent = &(FileInfo->Dloc->AllocLoc);
    PLONG_AD Alloc;
    uint32 NewLen;
    OSSTATUS status;
    uint32 ph_len=0; // in general, this should be uint64,
                     // but we need its lower part only
#ifdef UDF_ALLOW_FRAG_AD
    uint32 ac, len2, ts;
    uint32 TagLoc, prevTagLoc;
    uint32 LBS = Vcb->LBlockSize;
    uint32 LBSh = Vcb->BlockSizeBits;
    uint32 BufOffs;
    uint32 ExtOffs = AllocExtent->Offset;
    PLONG_AD saved_Alloc;
    uint32 TagLen = 0;
    tag* Tag = NULL;
#endif //UDF_ALLOW_FRAG_AD
 
    ValidateFileInfo(FileInfo);
    ExtPrint(("UDFBuildLongAllocDescs: FE %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    // calculate length
    //for(len=0; i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK); len++, ph_len+=i);
    for(len=0; (i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK)); len++, ph_len+=i) {
        ExtPrint(("bLnExt: type %x, loc %x, len %x\n",
            Extent[len].extLength >> 30, Extent[len].extLocation, Extent[len].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc = (PLONG_AD)MyAllocatePoolTag__(NonPagedPool, (len+1)*sizeof(LONG_AD), MEM_LNGAD_TAG);
    if(!Alloc) return STATUS_INSUFFICIENT_RESOURCES;
    // fill contiguous AllocDesc buffer (decribing UserData)
    for(i=0;i<len;i++) {
        Alloc[i].extLength = Extent[i].extLength;
        Alloc[i].extLocation.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, Extent[i].extLocation);
        Alloc[i].extLocation.partitionReferenceNum = (uint16)PartNum;
        RtlZeroMemory(&(Alloc[i].impUse), sizeof(Alloc[i].impUse));
    }
    if((Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) && i) {
        Alloc[i-1].extLength -= (ph_len - (ULONG)(FileInfo->Dloc->DataLoc.Length)) &
                                (Vcb->LBlockSize-1);
        ExtPrint(("bLnExt: cut tail -> %x\n",
            Alloc[i-1].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    RtlZeroMemory(&(Alloc[i]), sizeof(LONG_AD));
    j = len*sizeof(LONG_AD); // required space
    len = (InitSz & ~(sizeof(LONG_AD)-1)); // space available in 1st block
    ASSERT(len == InitSz);
 
    // Ok. Let's init AllocLoc
    if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
        FileInfo->Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool, 2 * sizeof(EXTENT_MAP), MEM_EXTMAP_TAG);
        if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
            MyFreePool__(Alloc);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        // allocation descriptors are located in the same sector as FileEntry
        // (at least their 1st part), just after it
        FileInfo->Dloc->AllocLoc.Mapping[0] = FileInfo->Dloc->FELoc.Mapping[0];
        FileInfo->Dloc->AllocLoc.Offset = FileInfo->Dloc->FileEntryLen;
        FileInfo->Dloc->AllocLoc.Length = 0;
        // set terminator
        FileInfo->Dloc->AllocLoc.Mapping[1].extLength =
        FileInfo->Dloc->AllocLoc.Mapping[1].extLocation = 0;
    }
 
    if(j <= len) {
        // we needn't allocating additional blocks to store AllocDescs
        RtlCopyMemory(*Buff, (int8*)Alloc, j);
        NewLen = j;
        MyFreePool__(Alloc);
    } else {
#ifndef UDF_ALLOW_FRAG_AD
        AdPrint(("  DISK_FULL\n"));
        return STATUS_DISK_FULL;
#else //UDF_ALLOW_FRAG_AD
        BufOffs = 0;
        TagLoc = prevTagLoc = 0;
        // calculate the space available for LONG_ADs in each block
        ac = (LBS - (sizeof(ALLOC_EXT_DESC) + sizeof(LONG_AD))) & ~(sizeof(LONG_AD)-1);
        len2 = len;
        // tail size
        ts = InitSz - len2;
        len -= sizeof(LONG_AD);
        // calculate actual AllocSequence length (in LBlocks)
        NewLen = ( ((j - len + ac - 1) / ac) << LBSh) + InitSz + sizeof(LONG_AD);
        MyFreePool__(*Buff);
        (*Buff) = (int8*)MyAllocatePoolTag__(NonPagedPool, NewLen, MEM_LNGAD_TAG);
        if(!(*Buff)) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            goto lad_alloc_err;
        }
        if(UDFGetExtentLength(AllocExtent->Mapping) < NewLen) {
            status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
            if(!OS_SUCCESS(status)) {
lad_alloc_err:
                MyFreePool__(Alloc);
                return status;
            }
        }
        ExtOffs = AllocExtent->Offset;
        RtlZeroMemory(*Buff, NewLen);
        NewLen = 0; // recorded length
        saved_Alloc = Alloc;
        len2 = len+sizeof(LONG_AD);
        // fill buffer sector by sector (adding links at the end of each one)
        while(TRUE) {
 
            // j - remained AllocDescs length (in bytes)
            // len - bytes available for in AllocDescs each block
 
            // leave space for terminator or pointer to next part of sequence
            if(j == len2) {
                // if we have only 1 LONG_AD that we can fit in last sector
                // we shall do it instead of recording link & allocating new block
                len =
                TagLen = len2;
            }
            RtlCopyMemory( (*Buff)+BufOffs, (int8*)Alloc, len);
            Alloc = (PLONG_AD)((int8*)Alloc + len);
            j -= len;
            BufOffs += len;
            if(Tag) {
                // Set up Tag for AllocDesc
                Tag->tagIdent = TID_ALLOC_EXTENT_DESC;
                UDFSetUpTag(Vcb, Tag, (uint16)TagLen, TagLoc);
                prevTagLoc = TagLoc;
            }
            if(!j) {
                // terminate loop
                NewLen = BufOffs;
                break;
            }
            len = ac;
            if(j <= (len + sizeof(LONG_AD)))
                len = j - sizeof(LONG_AD);
            len2 = len+sizeof(LONG_AD);
            // we have more than 1 LONG_AD that we can't fit in current block
            // so we shall set up pointer to the next block
            ((PLONG_AD)((*Buff)+BufOffs))->extLength = /*LBS*/ len2 |
                (((uint32)EXTENT_NEXT_EXTENT_ALLOCDESC) << 30) ;
            ((PLONG_AD)((*Buff)+BufOffs))->extLocation.logicalBlockNum = TagLoc =
                UDFPhysLbaToPart(Vcb, PartNum,
                    UDFExtentOffsetToLba(Vcb, AllocExtent->Mapping,
                        ExtOffs+BufOffs+sizeof(LONG_AD)+ts,
                        NULL, NULL, NULL, NULL) );
            ((PLONG_AD)((*Buff)+BufOffs))->extLocation.partitionReferenceNum = (uint16)PartNum;
            // reflect additional (link) block & LBlock tail (if any)
            BufOffs += ts+sizeof(LONG_AD);
            // init AllocDesc
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->lengthAllocDescs = len2;
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->previousAllocExtLocation = prevTagLoc;
            Tag = (tag*)((*Buff)+BufOffs);
            TagLen = len2;
            ts = LBS-len2-sizeof(ALLOC_EXT_DESC);
            BufOffs += sizeof(ALLOC_EXT_DESC);
        }
        MyFreePool__(saved_Alloc);
#endif //UDF_ALLOW_FRAG_AD
    }
    status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
    return status;
} // end UDFBuildLongAllocDescs()

Referenced by UDFBuildAllocDescs().

◆ UDFBuildShortAllocDescs()

OSSTATUS UDFBuildShortAllocDescs	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		OUT int8 **	Buff,
		IN uint32	InitSz,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 825 of file extent.cpp.

{
    uint32 i, j;
    uint32 len=0;
    PEXTENT_MAP Extent = FileInfo->Dloc->DataLoc.Mapping;
    PEXTENT_INFO AllocExtent = &(FileInfo->Dloc->AllocLoc);
    PSHORT_AD Alloc;
    uint32 NewLen;
    OSSTATUS status;
    uint32 ph_len=0; // in general, this should be uint64,
                     // but we need its lower part only
#ifdef UDF_ALLOW_FRAG_AD
    uint32 ts, ac, len2;
    uint32 LBS = Vcb->LBlockSize;
    uint32 LBSh = Vcb->BlockSizeBits;
    uint32 TagLen = 0;
    tag* Tag = NULL;
    PSHORT_AD saved_Alloc;
    uint32 TagLoc, prevTagLoc;
    uint32 BufOffs;
    uint32 ExtOffs;
    uint32 saved_NewLen;
#endif //UDF_ALLOW_FRAG_AD
 
    ValidateFileInfo(FileInfo);
    ExtPrint(("UDFBuildShortAllocDescs: FE %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    // calculate length
    for(len=0; (i=(Extent[len].extLength & UDF_EXTENT_LENGTH_MASK)); len++, ph_len+=i) {
        ExtPrint(("bShExt: type %x, loc %x, len %x\n",
            Extent[len].extLength >> 30, Extent[len].extLocation, Extent[len].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc = (PSHORT_AD)MyAllocatePoolTag__(NonPagedPool, (len+1)*sizeof(SHORT_AD), MEM_SHAD_TAG);
    if(!Alloc) {
        BrutePoint();
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    // fill contiguous AllocDesc buffer (decribing UserData)
    for(i=0;i<len;i++) {
        Alloc[i].extLength = Extent[i].extLength;
        Alloc[i].extPosition = UDFPhysLbaToPart(Vcb, PartNum, Extent[i].extLocation);
    }
    if((Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) && i) {
        Alloc[i-1].extLength -= (ph_len - (ULONG)(FileInfo->Dloc->DataLoc.Length)) &
                                (Vcb->LBlockSize-1);
        ExtPrint(("bShExt: cut tail -> %x\n",
            Alloc[i-1].extLength & UDF_EXTENT_LENGTH_MASK));
    }
    Alloc[i].extLength =
    Alloc[i].extPosition = 0;
    j = len*sizeof(SHORT_AD); // required space
    len = (InitSz & ~(sizeof(SHORT_AD)-1)); // space available in 1st block
    ASSERT(len == InitSz);
 
    // Ok. Let's init AllocLoc
    if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
        FileInfo->Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool, 2 * sizeof(EXTENT_MAP), MEM_EXTMAP_TAG);
        if(!(FileInfo->Dloc->AllocLoc.Mapping)) {
            BrutePoint();
            MyFreePool__(Alloc);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        // allocation descriptors are located in the same sector as FileEntry
        // (at least their 1st part), just after it
        FileInfo->Dloc->AllocLoc.Mapping[0] = FileInfo->Dloc->FELoc.Mapping[0];
        FileInfo->Dloc->AllocLoc.Offset = FileInfo->Dloc->FileEntryLen;
        FileInfo->Dloc->AllocLoc.Length = 0;
        // set terminator
        FileInfo->Dloc->AllocLoc.Mapping[1].extLength =
        FileInfo->Dloc->AllocLoc.Mapping[1].extLocation = 0;
    }
 
    if(j <= len) {
        // we needn't allocating additional blocks to store AllocDescs
        AdPrint(("in-ICB AllocDescs, j=%x\n",j));
        RtlCopyMemory(*Buff, (int8*)Alloc, j);
        NewLen = j;
        MyFreePool__(Alloc);
    } else {
#ifndef UDF_ALLOW_FRAG_AD
        AdPrint(("  DISK_FULL\n"));
        return STATUS_DISK_FULL;
#else //UDF_ALLOW_FRAG_AD
        AdPrint(("multi-block AllocDescs, j=%x\n",j));
        BufOffs = 0;
        TagLoc = prevTagLoc = 0;
        // calculate the space available for SHORT_ADs in each block
        ac = (LBS - (sizeof(ALLOC_EXT_DESC) + sizeof(SHORT_AD))) & ~(sizeof(SHORT_AD)-1);
        len2 = len;
        // tail size
        ts = InitSz - len2;
        len -= sizeof(SHORT_AD);
        // calculate actual AllocSequence length (in bytes)
        NewLen = ( ((j - len + ac - 1) / ac) << LBSh) + InitSz + sizeof(SHORT_AD);
        MyFreePool__(*Buff);
        (*Buff) = (int8*)MyAllocatePoolTag__(NonPagedPool, NewLen, MEM_SHAD_TAG);
        if(!(*Buff)) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            UDFPrint(("UDFResizeExtent() failed (%x)\n",status));
            BrutePoint();
            goto sh_alloc_err;
        }
        if(UDFGetExtentLength(AllocExtent->Mapping) < NewLen) {
            status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
            if(!OS_SUCCESS(status)) {
                UDFPrint(("UDFResizeExtent(2) failed (%x)\n",status));
                BrutePoint();
sh_alloc_err:
                MyFreePool__(Alloc);
                return status;
            }
        }
        ExtOffs = AllocExtent->Offset;
        RtlZeroMemory(*Buff, NewLen);
        saved_NewLen = NewLen;
        NewLen = 0; // recorded length
        saved_Alloc = Alloc;
        // fill buffer sector by sector (adding links at the end of each one)
        while(TRUE) {
 
            // j - remained AllocDescs length (in bytes)
            // len - bytes available for AllocDescs in current block
            // ac - bytes available for AllocDescs in each block
 
            // leave space for terminator or pointer to next part of sequence
            if(j == len2) {
                // if we have only 1 SHORT_AD that we can fit in last sector
                // we shall do it instead of recording link & allocating new block
                len =
                TagLen = len2;
            }
            ASSERT(saved_NewLen >= (BufOffs + len));
            RtlCopyMemory( (*Buff)+BufOffs, (int8*)Alloc, len);
            Alloc = (PSHORT_AD)((int8*)Alloc + len);
            j -= len;
            BufOffs += len;
            if(Tag) {
                // Set up Tag for AllocDesc
                Tag->tagIdent = TID_ALLOC_EXTENT_DESC;
                UDFSetUpTag(Vcb, Tag, (uint16)TagLen, TagLoc);
                prevTagLoc = TagLoc;
            }
            if(!j) {
                // terminate loop
                NewLen = BufOffs;
                break;
            }
            len = ac;
            if(j <= (len + sizeof(SHORT_AD)))
                len = j - sizeof(SHORT_AD);
            len2 = len + sizeof(SHORT_AD);
            // we have more than 1 SHORT_AD that we can't fit in current block
            // so we shall set up pointer to the next block
            ((PSHORT_AD)((*Buff)+BufOffs))->extLength = /*LBS*/ len2 |
                (((uint32)EXTENT_NEXT_EXTENT_ALLOCDESC) << 30) ;
            ((PSHORT_AD)((*Buff)+BufOffs))->extPosition = TagLoc =
                UDFPhysLbaToPart(Vcb, PartNum,
                    UDFExtentOffsetToLba(Vcb, AllocExtent->Mapping,
                        ExtOffs+BufOffs+sizeof(SHORT_AD)+ts,
                        NULL, NULL, NULL, NULL) );
            // reflect additional (link) block & LBlock tail (if any)
            BufOffs += ts+sizeof(SHORT_AD);
            // init AllocDesc
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->lengthAllocDescs = len2;
            ( (PALLOC_EXT_DESC) ((*Buff)+BufOffs))->previousAllocExtLocation = prevTagLoc;
            Tag = (tag*)((*Buff)+BufOffs);
            TagLen = len2;
            ts = LBS-len2-sizeof(ALLOC_EXT_DESC);
            BufOffs += sizeof(ALLOC_EXT_DESC);
        }
        MyFreePool__(saved_Alloc);
#endif //UDF_ALLOW_FRAG_AD
    }
    status = UDFResizeExtent(Vcb, PartNum, NewLen, TRUE, AllocExtent);
    return status;
} // end UDFBuildShortAllocDescs()

Referenced by UDFBuildAllocDescs().

◆ UDFChangeFileCounter()

void UDFChangeFileCounter	(	IN PVCB	Vcb,
		IN BOOLEAN	FileCounter,
		IN BOOLEAN	Increase
	)

Definition at line 1520 of file udf_info.cpp.

{
    uint32* counter;
 
    counter = FileCounter ?
        &(Vcb->numFiles) :
        &(Vcb->numDirs);
    if(*counter == (ULONG)-1)
        return;
    if(Increase) {
        UDFInterlockedIncrement((int32*)counter);
    } else {
        UDFInterlockedDecrement((int32*)counter);
    }
 
} // end UDFChangeFileCounter()

Referenced by UDFUnlinkFile__().

◆ UDFChangeFileLinkCount()

void UDFChangeFileLinkCount	(	IN PUDF_FILE_INFO	FileInfo,
		IN BOOLEAN	Increase
	)

Definition at line 1315 of file udf_info.cpp.

{
    uint16 Ident;
 
    ValidateFileInfo(FileInfo);
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(Increase) {
            fe->fileLinkCount++;
        } else {
            fe->fileLinkCount--;
        }
        if(fe->fileLinkCount & 0x8000)
            fe->fileLinkCount = 0xffff;
        return;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(Increase) {
            fe->fileLinkCount++;
        } else {
            fe->fileLinkCount--;
        }
        if(fe->fileLinkCount & 0x8000)
            fe->fileLinkCount = 0xffff;
        return;
    }
    return;
} // end UDFChangeFileLinkCount()

◆ UDFCheckArea()

BOOLEAN __fastcall UDFCheckArea	(	IN PVCB	Vcb,
		IN lba_t	LBA,
		IN uint32	BCount
	)

Definition at line 763 of file remap.cpp.

{
    uint8* buff;
    OSSTATUS RC;
    SIZE_T ReadBytes;
    uint32 i, d;
    BOOLEAN ext_ok = TRUE;
    EXTENT_MAP Map[2];
    uint32 PS = Vcb->WriteBlockSize >> Vcb->BlockSizeBits;
 
    buff = (uint8*)DbgAllocatePoolWithTag(NonPagedPool, Vcb->WriteBlockSize, 'bNWD' );
    if(buff) {
        for(i=0; i<BCount; i+=d) {
            if(!((LBA+i) & (PS-1)) &&
               (i+PS <= BCount)) {
                d = PS;
            } else {
                d = 1;
            }
            RC = UDFTRead(Vcb,
                           buff,
                           d << Vcb->BlockSizeBits,
                           LBA+i,
                           &ReadBytes,
                           PH_TMP_BUFFER);
 
            if(RC != STATUS_SUCCESS) {
                Map[0].extLocation = LBA+i;
                Map[0].extLength = d << Vcb->BlockSizeBits;
                UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &(Map[0]), AS_DISCARDED | AS_BAD); // free
                ext_ok = FALSE;
            }
        }
        DbgFreePool(buff);
    }
    return ext_ok;
} // end UDFCheckArea()

Referenced by UDFAllocFreeExtent_(), and UDFRemapPacket().

◆ UDFCleanUpFile__()

uint32 UDFCleanUpFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 2276 of file udf_info.cpp.

{
    PUDF_DATALOC_INFO Dloc;
    uint32 lc = 0;
    BOOLEAN IsASDir;
    BOOLEAN KeepDloc;
    PDIR_INDEX_ITEM DirNdx, DirNdx2;
    BOOLEAN Parallel = FALSE;
    BOOLEAN Linked = FALSE;
#ifdef UDF_DBG
    BOOLEAN Modified = FALSE;
    PDIR_INDEX_HDR hDirNdx;
    uint_di Index;
    PUDF_FILE_INFO DirInfo;
#endif // UDF_DBG
 
    if(!FileInfo) return UDF_FREE_FILEINFO;
 
    ValidateFileInfo(FileInfo);
 
    if(FileInfo->OpenCount || FileInfo->RefCount) {
        UDFPrint(("UDF: not all references are closed\n"));
        UDFPrint(("     Skipping cleanup\n"));
        UDFPrint(("UDF: OpenCount = %x, RefCount = %x, LinkRefCount = %x\n",
                              FileInfo->OpenCount,FileInfo->RefCount,FileInfo->Dloc->LinkRefCount));
        return UDF_FREE_NOTHING;
    }
    if(FileInfo->Fcb) {
        UDFPrint(("Operating System still has references to this file\n"));
        UDFPrint(("     Skipping cleanup\n"));
//        BrutePoint();
        return UDF_FREE_NOTHING;
    }
 
    IsASDir = UDFIsAStreamDir(FileInfo);
 
    if((Dloc = FileInfo->Dloc)) {
 
#ifdef UDF_DBG
        DirInfo = FileInfo->ParentFile;
        if(DirInfo) {
            hDirNdx = DirInfo->Dloc->DirIndex;
            Index = FileInfo->Index;
            // we can't delete modified file
            // it should be closed & reopened (or flushed) before deletion
            DirNdx = UDFDirIndex(hDirNdx,Index);
            UDFPrint(("Cleanup Mod: %s%s%s%s%s%s\n",
                                 (Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ? "FE "       : "",
                                 (Dloc->DataLoc.Modified)                   ? "DataLoc "  : "",
                                 (Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) ? "Data-PreAlloc " : "",
                                 (Dloc->AllocLoc.Modified)                  ? "AllocLoc " : "",
                                 (Dloc->FELoc.Modified)                     ? "FELoc "    : "",
                                 (DirNdx && (DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) ? "FI " : ""
                                 ));
            Modified = ((Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ||
                         Dloc->DataLoc.Modified ||
                        (Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) ||
                         Dloc->AllocLoc.Modified ||
                         Dloc->FELoc.Modified ||
                        (DirNdx && (DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) );
        }
#endif // UDF_DBG
 
        PUDF_FILE_INFO ParFileInfo = UDFLocateAnyParallelFI(FileInfo);
 
        Parallel = (ParFileInfo != NULL);
        Linked = (FileInfo->NextLinkedFile != FileInfo);
 
//        Parallel = (FileInfo->NextLinkedFile != FileInfo);
        ASSERT(FileInfo->NextLinkedFile);
//        ASSERT(!Parallel);
        KeepDloc = (Dloc->LinkRefCount ||
                    Dloc->CommonFcb ||
                    Linked ) ?
                    TRUE : FALSE;
 
        if(Dloc->DirIndex) {
            uint_di i;
            for(i=2; (DirNdx = UDFDirIndex(Dloc->DirIndex,i)); i++) {
                if(DirNdx->FileInfo) {
                    if(!KeepDloc) {
                        BrutePoint();
                        UDFPrint(("UDF: Found not cleaned up reference.\n"));
                        UDFPrint(("     Skipping cleanup (1)\n"));
//                        BrutePoint();
                        return UDF_FREE_NOTHING;
                    }
                    // The file being cleaned up may have not closed Dirs
                    // (linked Dir). In this case each of them may have
                    // reference to FileInfo in DirIndex[1]
                    // Here we'll check it and change for valid value if
                    // necessary (Update Child Objects - I)
                    if(DirNdx->FileInfo->Dloc) {
                        // we can get here only when (Parallel == TRUE)
                        DirNdx2 = UDFDirIndex(DirNdx->FileInfo->Dloc->DirIndex, 1);
                        // It is enough to check DirNdx2->FileInfo only.
                        // If one of Parallel FI's has reference (and equal)
                        // to the FI being removed, it'll be removed from
                        // the chain & nothing wrong will happen.
                        if(DirNdx2 && (DirNdx2->FileInfo == FileInfo)) {
                            if(FileInfo->PrevLinkedFile == FileInfo) {
                                BrutePoint();
                                DirNdx2->FileInfo = NULL;
                            } else {
                                DirNdx2->FileInfo = Parallel ?
                                    ParFileInfo : FileInfo->PrevLinkedFile;
                            }
                            ASSERT(!DirNdx2->FileInfo->RefCount);
                        }
                    }
                }
            }
        }
        if(Dloc->SDirInfo) {
            UDFPrint(("UDF: Found not cleaned up reference (SDir).\n"));
 
            // (Update Child Objects - II)
            if(Dloc->SDirInfo->ParentFile == FileInfo) {
                BrutePoint();
                ASSERT(ParFileInfo);
                Dloc->SDirInfo->ParentFile = ParFileInfo;
            }
            // We should break Cleanup process if alive reference detected
            // and there is no possibility to store pointer in some other
            // place (in parallel object)
            if(!KeepDloc) {
                BrutePoint();
                UDFPrint(("     Skipping cleanup\n"));
                return UDF_FREE_NOTHING;
            }
 
            if(!UDFIsSDirDeleted(Dloc->SDirInfo) &&
               Dloc->SDirInfo->Dloc) {
                DirNdx2 = UDFDirIndex(Dloc->SDirInfo->Dloc->DirIndex, 1);
                if(DirNdx2 && (DirNdx2->FileInfo == FileInfo)) {
                    DirNdx2->FileInfo =
                        Parallel ? ParFileInfo : NULL;
                    ASSERT(!DirNdx2->FileInfo->RefCount);
                }
            }
        }
 
        if(!KeepDloc) {
 
#ifdef UDF_DBG
            ASSERT(!Modified);
#endif
 
#ifndef UDF_TRACK_ONDISK_ALLOCATION
            if(Dloc->DataLoc.Mapping)  MyFreePool__(Dloc->DataLoc.Mapping);
            if(Dloc->AllocLoc.Mapping) MyFreePool__(Dloc->AllocLoc.Mapping);
            if(Dloc->FELoc.Mapping)    MyFreePool__(Dloc->FELoc.Mapping);
            if(Dloc->FileEntry) {
                // plain file
                lc = UDFGetFileLinkCount(FileInfo);
                MyFreePool__(Dloc->FileEntry);
                Dloc->FileEntry = NULL;
            } else if(FileInfo->Index >= 2) {
                // error durring open operation
                lc = UDF_INVALID_LINK_COUNT;
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
            if(FileInfo->Dloc->DirIndex) {
                uint_di i;
                for(i=2; (DirNdx = UDFDirIndex(Dloc->DirIndex,i)); i++) {
                    ASSERT(!DirNdx->FileInfo);
                    if(DirNdx->FName.Buffer)
                        MyFreePool__(DirNdx->FName.Buffer);
                }
                // The only place where we can free FE_Charge extent is here
                UDFFlushFESpace(Vcb, Dloc);
                UDFDirIndexFree(Dloc->DirIndex);
                Dloc->DirIndex = NULL;
#ifdef UDF_TRACK_ONDISK_ALLOCATION
                UDFIndexDirectory(Vcb, FileInfo);
                if(FileInfo->Dloc->DirIndex) {
                    for(i=2; DirNdx = UDFDirIndex(Dloc->DirIndex,i); i++) {
                        ASSERT(!DirNdx->FileInfo);
                        if(DirNdx->FName.Buffer)
                            MyFreePool__(DirNdx->FName.Buffer);
                    }
                    UDFDirIndexFree(Dloc->DirIndex);
                    Dloc->DirIndex = NULL;
                }
#endif //UDF_TRACK_ONDISK_ALLOCATION
            }
 
#ifdef UDF_TRACK_ONDISK_ALLOCATION
            if(Dloc->AllocLoc.Mapping) MyFreePool__(Dloc->AllocLoc.Mapping);
            if(Dloc->FELoc.Mapping)    MyFreePool__(Dloc->FELoc.Mapping);
            if(Dloc->FileEntry) {
                // plain file
                lc = UDFGetFileLinkCount(FileInfo);
                MyFreePool__(Dloc->FileEntry);
                Dloc->FileEntry = NULL;
            } else if(FileInfo->Index >= 2) {
                // error durring open operation
                lc = UDF_INVALID_LINK_COUNT;
            }
            if(Dloc->DataLoc.Mapping) {
                if(lc && (lc != UDF_INVALID_LINK_COUNT)) {
                    UDFCheckSpaceAllocation(Vcb, 0, Dloc->DataLoc.Mapping, AS_USED); // check if used
                } else {
                    UDFCheckSpaceAllocation(Vcb, 0, Dloc->DataLoc.Mapping, AS_FREE); // check if free
                }
                MyFreePool__(Dloc->DataLoc.Mapping);
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
            if(lc && (lc != UDF_INVALID_LINK_COUNT)) {
                UDFRemoveDloc(Vcb, Dloc);
            } else {
                UDFFreeDloc(Vcb, Dloc);
            }
        } else // KeepDloc cannot be FALSE if (Linked == TRUE)
        if(Linked) {
//            BrutePoint();
            // Update pointers in ParentObject (if any)
            if(FileInfo->ParentFile->Dloc->SDirInfo == FileInfo)
                FileInfo->ParentFile->Dloc->SDirInfo = FileInfo->PrevLinkedFile;
            DirNdx = UDFDirIndex(FileInfo->Dloc->DirIndex, 0);
            if(DirNdx && (DirNdx->FileInfo == FileInfo))
                DirNdx->FileInfo = FileInfo->PrevLinkedFile;
            DirNdx = UDFDirIndex(FileInfo->ParentFile->Dloc->DirIndex, FileInfo->Index);
            if(DirNdx && (DirNdx->FileInfo == FileInfo))
                DirNdx->FileInfo = ParFileInfo;
            // remove from linked chain
            FileInfo->NextLinkedFile->PrevLinkedFile = FileInfo->PrevLinkedFile;
            FileInfo->PrevLinkedFile->NextLinkedFile = FileInfo->NextLinkedFile;
            // update pointer in Dloc
            if(FileInfo->Dloc->LinkedFileInfo == FileInfo)
                FileInfo->Dloc->LinkedFileInfo = FileInfo->PrevLinkedFile;
        }
        FileInfo->Dloc = NULL;
    } else {
        KeepDloc = FALSE;
    }
 
    // Cleanup pointers in ParentObject (if any)
    if(IsASDir) {
        if(FileInfo->ParentFile->Dloc->SDirInfo == FileInfo) {
            ASSERT(!Linked);
            FileInfo->ParentFile->Dloc->SDirInfo = NULL;
            FileInfo->ParentFile->Dloc->FE_Flags &= ~UDF_FE_FLAG_HAS_DEL_SDIR;
        }
    } else
    if(FileInfo->ParentFile) {
        ASSERT(FileInfo->ParentFile->Dloc);
        DirNdx = UDFDirIndex(FileInfo->ParentFile->Dloc->DirIndex, FileInfo->Index);
        ASSERT(DirNdx);
#ifdef UDF_DBG
        PUDF_FILE_INFO OldFI;
        if(Parallel) {
            ASSERT(!DirNdx || !(OldFI = DirNdx->FileInfo) ||
                    !(OldFI == FileInfo));
        } else {
            ASSERT(!DirNdx || !(OldFI = DirNdx->FileInfo) ||
                     (OldFI == FileInfo));
        }
#endif
        if( DirNdx && (DirNdx->FileInfo == FileInfo) ) {
            if(!Parallel)
                DirNdx->FileInfo = NULL;
#ifdef UDF_DBG
        } else {
            // We can get here after incomplete Open
            if(!Parallel && DirNdx->FileInfo)
                BrutePoint();
#endif
        }
#ifdef UDF_DBG
    } else {
//        BrutePoint();
#endif
    }
 
    if(!Parallel && FileInfo->FileIdent)
        MyFreePool__(FileInfo->FileIdent);
    FileInfo->FileIdent = NULL;
    // Kill reference to parent object
    FileInfo->ParentFile = NULL;
    // Kill references to parallel object(s) since it has no reference to
    // this one now
    FileInfo->NextLinkedFile =
    FileInfo->PrevLinkedFile = FileInfo;
    if(FileInfo->ListPtr)
        FileInfo->ListPtr->FileInfo = NULL;;
    return KeepDloc ? UDF_FREE_FILEINFO : (UDF_FREE_FILEINFO | UDF_FREE_DLOC);
} // end UDFCleanUpFile__()

Referenced by UDFBlankMount(), UDFCleanUpFcbChain(), UDFCloseResidual(), UDFCommonCreate(), UDFCompareVcb(), UDFCompleteMount(), UDFCreateFile__(), UDFCreateStreamDir__(), UDFHardLinkFile__(), UDFLoadVAT(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFRenameMoveFile__(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFCloseFile__()

OSSTATUS UDFCloseFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 2994 of file udf_info.cpp.

{
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo) return STATUS_SUCCESS;
    if(FileInfo->Index<2 && (FileInfo->ParentFile) && !UDFIsAStreamDir(FileInfo)) {
        UDFPrint(("Closing Current or Parent Directory... :-\\\n"));
        if(FileInfo->RefCount) {
            UDFInterlockedDecrement((PLONG)&(FileInfo->RefCount));
            ASSERT(FileInfo->Dloc);
            if(FileInfo->Dloc)
                UDFInterlockedDecrement((PLONG)&(FileInfo->Dloc->LinkRefCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unreferenced file!\n"));
#endif // UDF_DBG
        }
        if(FileInfo->ParentFile->OpenCount) {
            UDFInterlockedDecrement((PLONG)&(FileInfo->ParentFile->OpenCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unopened file!\n"));
#endif // UDF_DBG
        }
        return STATUS_SUCCESS;
    }
    PUDF_FILE_INFO DirInfo = FileInfo->ParentFile;
    OSSTATUS status;
    uint32 PartNum;
    if(FileInfo->RefCount) {
        UDFInterlockedDecrement((PLONG)&(FileInfo->RefCount));
        ASSERT(FileInfo->Dloc);
        if(FileInfo->Dloc)
            UDFInterlockedDecrement((PLONG)&(FileInfo->Dloc->LinkRefCount));
#ifdef UDF_DBG
    } else {
        BrutePoint();
        UDFPrint(("ERROR: Closing unreferenced file!\n"));
#endif // UDF_DBG
    }
    if(DirInfo) {
        // validate DirInfo
        ValidateFileInfo(DirInfo);
 
        if(DirInfo->OpenCount) {
            UDFInterlockedDecrement((PLONG)&(DirInfo->OpenCount));
#ifdef UDF_DBG
        } else {
            BrutePoint();
            UDFPrint(("ERROR: Closing unopened file!\n"));
#endif // UDF_DBG
        }
    }
    // If the file has gone (unlinked) we should return STATUS_SUCCESS here.
    if(!FileInfo->Dloc) return STATUS_SUCCESS;
 
    if(FileInfo->RefCount ||
       FileInfo->OpenCount ||
       !(FileInfo->Dloc->FELoc.Mapping)) return STATUS_SUCCESS;
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(PartNum == (uint32)-1) {
        UDFPrint(("  Is DELETED ?\n"));
        if(DirInfo) {
            PartNum = UDFGetPartNumByPhysLba(Vcb, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        } else {
            BrutePoint();
        }
    }
#ifdef UDF_CHECK_DISK_ALLOCATION
    if(  FileInfo->Fcb &&
         UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
 
        //ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        if(UDFIsAStreamDir(FileInfo)) {
            if(!UDFIsSDirDeleted(FileInfo)) {
                UDFPrint(("  Not DELETED SDir\n"));
                BrutePoint();
            }
            ASSERT(!FileInfo->Dloc->FELoc.Modified);
        } else
        if(!FileInfo->FileIdent ||
           !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED)) {
            if(!FileInfo->FileIdent) {
                AdPrint(("  No FileIdent\n"));
            }
            if(FileInfo->FileIdent &&
               !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED))
                AdPrint(("  Not DELETED\n"));
            ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
            AdPrint(("Flushing to Discarded block %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
            BrutePoint();
        } else {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_FREE); // check if free
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->FELoc.Mapping, AS_FREE); // check if free
        }
    } else {
        if(!FileInfo->Dloc->FELoc.Mapping[0].extLocation ||
            UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_FREE); // check if free
        } else {
            UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
        }
    }
#endif // UDF_CHECK_DISK_ALLOCATION
    // check if we should update parentICBLocation
    if( !((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum &&
        !((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum &&
        DirInfo &&
        !Vcb->CDR_Mode &&
        Vcb->Modified &&
        UDFGetFileLinkCount(FileInfo) ) {
        ASSERT(DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum =
             UDFPhysLbaToPart(Vcb, PartNum, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum = (uint16)PartNum;
        FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    }
 
    // we needn't flushing FE & Allocs untill all links are closed...
    if(!FileInfo->Dloc->LinkRefCount) {
 
        // flush FE and pre-allocation charge for directories
        if(FileInfo->Dloc &&
           FileInfo->Dloc->DirIndex) {
 
            UDFFlushFESpace(Vcb, FileInfo->Dloc);
            if(FileInfo->Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) {
                FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_CUT_PREALLOCATED;
                status = UDFResizeExtent(Vcb, PartNum, UDFGetFileSize(FileInfo), FALSE, &(FileInfo->Dloc->DataLoc));
                FileInfo->Dloc->DataLoc.Flags &= ~(EXTENT_FLAG_PREALLOCATED | EXTENT_FLAG_CUT_PREALLOCATED);
                if(OS_SUCCESS(status)) {
                    AdPrint(("Dir pre-alloc truncated (Close)\n"));
                    FileInfo->Dloc->DataLoc.Modified = TRUE;
                }
            }
        }
 
        if(!OS_SUCCESS(status = UDFFlushFE(Vcb, FileInfo, PartNum))) {
            UDFPrint(("Error flushing FE\n"));
//flush_recovery:
            BrutePoint();
            if(FileInfo->Index >= 2) {
                PDIR_INDEX_ITEM DirNdx;
                DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index);
                if(DirNdx) {
                    UDFPrint(("Recovery: mark as deleted & flush FI\n"));
                    DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
                    DirNdx->FileCharacteristics |= FILE_DELETED;
                    FileInfo->FileIdent->fileCharacteristics |= FILE_DELETED;
                    UDFFlushFI(Vcb, FileInfo, PartNum);
                }
            }
            return status;
        }
    }
    // ... but FI must be updated (if any)
    if(!OS_SUCCESS(status = UDFFlushFI(Vcb, FileInfo, PartNum))) {
        UDFPrint(("Error flushing FI\n"));
        return status;
    }
#ifdef UDF_DBG
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if((FileInfo->Dloc->FileEntry->descVersion != 2) &&
       (FileInfo->Dloc->FileEntry->descVersion != 3)) {
        ASSERT(UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    }
#endif // UDF_DBG
    return STATUS_SUCCESS;
} // end UDFCloseFile__()

Referenced by UDFCleanUpFcbChain(), UDFCloseFileInfoChain(), UDFCloseResidual(), UDFCommonCreate(), UDFCompareVcb(), UDFCompleteMount(), UDFCreateFile__(), UDFCreateStreamDir__(), UDFHardLinkFile__(), UDFLoadVAT(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFRename(), UDFRenameMoveFile__(), UDFSetEOF(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFCompareFileInfo()

BOOLEAN UDFCompareFileInfo	(	IN PUDF_FILE_INFO	f1,
		IN PUDF_FILE_INFO	f2
	)

Definition at line 4218 of file udf_info.cpp.

{
    uint_di i;
    PDIR_INDEX_HDR hDirIndex1;
    PDIR_INDEX_HDR hDirIndex2;
    PDIR_INDEX_ITEM DirIndex1;
    PDIR_INDEX_ITEM DirIndex2;
 
    if(!f1 || !f2) return FALSE;
    if(f1->Dloc->FileEntryLen != f2->Dloc->FileEntryLen) return FALSE;
//    if(f1->FileIdentLen != f2->FileIdentLen) return FALSE;
/*    if(f1->Dloc->DirIndex && !f2->Dloc->DirIndex) return FALSE;
    if(f2->Dloc->DirIndex && !f1->Dloc->DirIndex) return FALSE;
    if((f1->Dloc->DirIndex) &&
       (f1->Dloc->DirIndex->LastFrameCount != f2->Dloc->DirIndex->LastFrameCount)) return FALSE;*/
    if(f1->Index != f2->Index) return FALSE;
    if(!(f1->Dloc->DataLoc.Mapping)) return FALSE;
    if(!(f2->Dloc->DataLoc.Mapping)) return FALSE;
    if(f1->Dloc->DataLoc.Mapping[0].extLocation != f2->Dloc->DataLoc.Mapping[0].extLocation) return FALSE;
    if(f1->Dloc->DataLoc.Mapping[0].extLength != f2->Dloc->DataLoc.Mapping[0].extLength) return FALSE;
//    if(f1-> != f2->) return FALSE;
//    if(f1-> != f2->) return FALSE;
//    if(f1-> != f2->) return FALSE;
    if(!(f1->Dloc->FileEntry)) return FALSE;
    if(!(f2->Dloc->FileEntry)) return FALSE;
    if(RtlCompareMemory(f1->Dloc->FileEntry, f2->Dloc->FileEntry, f2->Dloc->FileEntryLen) != f2->Dloc->FileEntryLen)
        return FALSE;
    if(!(hDirIndex1 = f1->Dloc->DirIndex)) return FALSE;
    if(!(hDirIndex2 = f2->Dloc->DirIndex)) return FALSE;
 
    for(i=2; (DirIndex1 = UDFDirIndex(hDirIndex1,i)) &&
             (DirIndex2 = UDFDirIndex(hDirIndex2,i)); i++) {
        if( DirIndex1->FName.Buffer &&
           !DirIndex2->FName.Buffer)
            return FALSE;
        if( DirIndex2->FName.Buffer &&
           !DirIndex1->FName.Buffer)
            return FALSE;
        if(!DirIndex2->FName.Buffer &&
           !DirIndex1->FName.Buffer)
            continue;
        if(RtlCompareUnicodeString(&(DirIndex1->FName),
                                   &(DirIndex2->FName),FALSE)) {
            return FALSE;
        }
//        if(DirIndex1[i].FileEntry != DirIndex2[i].FileEntry)
//            return FALSE;
        if(RtlCompareMemory(&(DirIndex1->FileEntryLoc),
                            &(DirIndex2->FileEntryLoc), sizeof(lb_addr)) != sizeof(lb_addr))
            return FALSE;
    }
 
    return TRUE;
} // end UDFCompareFileInfo()

Referenced by UDFCompareVcb().

◆ UDFCompressUnicode()

void __fastcall UDFCompressUnicode	(	IN PUNICODE_STRING	UName,
		IN OUT uint8 **	_CS0,
		IN OUT PSIZE_T	Length
	)

Definition at line 240 of file udf_info.cpp.

{
    uint8* CS0;
    uint8 compID;
    uint16 unicodeIndex;
    uint32 i, len;
    PWCHAR Buff;
 
    len = (UName->Length) / sizeof(WCHAR);
    compID = (!len) ? 0 : UDF_COMP_ID_8;
    // check for uncompressable characters
    Buff = UName->Buffer;
    for(i=0; i<len; i++, Buff++) {
        if((*Buff) & 0xff00) {
            compID = UDF_COMP_ID_16;
            break;
        }
    }
 
    CS0 = (uint8*)MyAllocatePool__(NonPagedPool, *Length = (((compID==UDF_COMP_ID_8) ? 1 : 2)*len + 1) );
    if(!CS0) return;
 
    CS0[0] = compID;
    *_CS0 = CS0;
    // init loop
    CS0++;
    unicodeIndex = 0;
    Buff = UName->Buffer;
    if(compID == UDF_COMP_ID_16) {
        // Loop through all the bytes.
        while (unicodeIndex < len) {
            // Move the 2nd byte to the low bits of the compressed unicode char.
            *CS0 = (uint8)((*Buff) >> 8);
            CS0++;
            *CS0 = (uint8)(*Buff);
            CS0++;
            Buff++;
            unicodeIndex++;
        }
    } else {
        // Loop through all the bytes.
        while (unicodeIndex < len) {
            *CS0 = (uint8)(*Buff);
            CS0++;
            Buff++;
            unicodeIndex++;
        }
    }
} // end UDFCompressUnicode()

Referenced by UDFBuildFileIdent(), UDFRenameMoveFile__(), and UDFSetDstring().

◆ UDFConvertFEToExtended()

OSSTATUS UDFConvertFEToExtended	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 5458 of file udf_info.cpp.

{
    PEXTENDED_FILE_ENTRY ExFileEntry;
    PFILE_ENTRY FileEntry;
    uint32 Length, NewLength, l;
    OSSTATUS status;
    SIZE_T ReadBytes;
 
    if(!FileInfo) return STATUS_INVALID_PARAMETER;
    ValidateFileInfo(FileInfo);
    if(FileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY) return STATUS_SUCCESS;
    if(FileInfo->Dloc->FileEntry->tagIdent != TID_FILE_ENTRY) return STATUS_INVALID_PARAMETER;
 
/*    if(!OS_SUCCESS(status = UDFFlushFile__(Vcb, FileInfo)))
        return status;*/
 
    Length = FileInfo->Dloc->FileEntryLen;
    NewLength = Length - sizeof(FILE_ENTRY) + sizeof(EXTENDED_FILE_ENTRY);
    ExFileEntry = (PEXTENDED_FILE_ENTRY)MyAllocatePoolTag__(NonPagedPool, NewLength, MEM_XFE_TAG);
    if(!ExFileEntry) return STATUS_INSUFFICIENT_RESOURCES;
    FileEntry = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
    RtlZeroMemory(ExFileEntry, NewLength);
 
    ExFileEntry->descTag.tagIdent = TID_EXTENDED_FILE_ENTRY;
    ExFileEntry->icbTag = FileEntry->icbTag;
    ExFileEntry->uid = FileEntry->uid;
    ExFileEntry->gid = FileEntry->gid;
    ExFileEntry->permissions = FileEntry->permissions;
    ExFileEntry->fileLinkCount = FileEntry->fileLinkCount;
    ExFileEntry->recordFormat = FileEntry->recordFormat;
    ExFileEntry->recordDisplayAttr = FileEntry->recordDisplayAttr;
    ExFileEntry->recordLength = FileEntry->recordLength;
    ExFileEntry->informationLength = FileEntry->informationLength;
    ExFileEntry->logicalBlocksRecorded = FileEntry->logicalBlocksRecorded;
    ExFileEntry->accessTime = FileEntry->accessTime;
    ExFileEntry->modificationTime = FileEntry->modificationTime;
    ExFileEntry->attrTime = FileEntry->attrTime;
    ExFileEntry->checkpoint = FileEntry->checkpoint;
    ExFileEntry->extendedAttrICB = FileEntry->extendedAttrICB;
    ExFileEntry->impIdent = FileEntry->impIdent;
    ExFileEntry->uniqueID = FileEntry->uniqueID;
    ExFileEntry->lengthExtendedAttr = FileEntry->lengthExtendedAttr;
    ExFileEntry->lengthAllocDescs = FileEntry->lengthAllocDescs;
    RtlCopyMemory(ExFileEntry+1, FileEntry+1, FileEntry->lengthExtendedAttr);
    RtlCopyMemory((int8*)(ExFileEntry+1)+FileEntry->lengthExtendedAttr, (int8*)(ExFileEntry+1)+FileEntry->lengthExtendedAttr, FileEntry->lengthAllocDescs);
 
    if((((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) {
 
        if((l = (uint32)(FileInfo->Dloc->DataLoc.Length))) {
 
            int8* tmp_buff = (int8*)MyAllocatePool__(NonPagedPool, l);
            if(!tmp_buff) {
                MyFreePool__(ExFileEntry);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            if(!OS_SUCCESS(status = UDFReadFile__(Vcb, FileInfo, 0, l, FALSE, tmp_buff, &ReadBytes)) ||
               !OS_SUCCESS(status = UDFResizeFile__(Vcb, FileInfo, 0)) ) {
                MyFreePool__(ExFileEntry);
                MyFreePool__(tmp_buff);
                return status;
            }
            FileInfo->Dloc->FELoc.Length =
            FileInfo->Dloc->DataLoc.Offset = NewLength;
            FileInfo->Dloc->FELoc.Modified =
            FileInfo->Dloc->DataLoc.Modified = TRUE;
            MyFreePool__(FileInfo->Dloc->FileEntry);
            FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
            if(!OS_SUCCESS(status = UDFResizeFile__(Vcb, FileInfo, l)) ||
               !OS_SUCCESS(status = UDFWriteFile__(Vcb, FileInfo, 0, l, FALSE, tmp_buff, &ReadBytes)) ) {
                MyFreePool__(ExFileEntry);
                MyFreePool__(tmp_buff);
                return status;
            }
            MyFreePool__(tmp_buff);
        } else {
            FileInfo->Dloc->FELoc.Length =
            FileInfo->Dloc->DataLoc.Offset = NewLength;
            FileInfo->Dloc->FELoc.Modified =
            FileInfo->Dloc->DataLoc.Modified = TRUE;
            MyFreePool__(FileInfo->Dloc->FileEntry);
            FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
        }
    } else {
        FileInfo->Dloc->FELoc.Length =
        FileInfo->Dloc->AllocLoc.Offset = NewLength;
        FileInfo->Dloc->FELoc.Modified =
        FileInfo->Dloc->AllocLoc.Modified = TRUE;
        MyFreePool__(FileInfo->Dloc->FileEntry);
        FileInfo->Dloc->FileEntry = (tag*)ExFileEntry;
    }
    FileInfo->Dloc->FileEntryLen = NewLength;
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    if(Vcb->minUDFReadRev < 0x0200)
        Vcb->minUDFReadRev = 0x0200;
    return STATUS_SUCCESS;
} // end UDFConvertFEToExtended()

Referenced by UDFCreateStreamDir__().

◆ UDFConvertFEToNonInICB()

OSSTATUS UDFConvertFEToNonInICB	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint8	NewAllocMode
	)

Definition at line 5358 of file udf_info.cpp.

{
    OSSTATUS status;
    int8* OldInIcb = NULL;
    uint32 OldLen;
    ValidateFileInfo(FileInfo);
    SIZE_T ReadBytes;
    SIZE_T _WrittenBytes;
    PUDF_DATALOC_INFO Dloc;
 
//    ASSERT(FileInfo->RefCount >= 1);
 
    Dloc = FileInfo->Dloc;
    ASSERT(Dloc->FELoc.Mapping[0].extLocation);
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, Dloc->FELoc.Mapping[0].extLocation);
 
    if(NewAllocMode == ICB_FLAG_AD_DEFAULT_ALLOC_MODE) {
        NewAllocMode = (uint8)(Vcb->DefaultAllocMode);
    }
    // we do not support recording of extended AD now
    if(NewAllocMode != ICB_FLAG_AD_SHORT &&
       NewAllocMode != ICB_FLAG_AD_LONG)
        return STATUS_INVALID_PARAMETER;
    if(!Dloc->DataLoc.Offset || !Dloc->DataLoc.Length)
        return STATUS_SUCCESS;
    ASSERT(!Dloc->AllocLoc.Mapping);
    // read in-icb data. it'll be replaced after resize
    OldInIcb = (int8*)MyAllocatePool__(NonPagedPool, (uint32)(Dloc->DataLoc.Length));
    if(!OldInIcb)
        return STATUS_INSUFFICIENT_RESOURCES;
    OldLen = (uint32)(Dloc->DataLoc.Length);
    status = UDFReadExtent(Vcb, &(Dloc->DataLoc), 0, OldLen, FALSE, OldInIcb, &ReadBytes);
    if(!OS_SUCCESS(status)) {
        MyFreePool__(OldInIcb);
        return status;
    }
/*    if(!Dloc->AllocLoc.Mapping) {
        Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, sizeof(EXTENT_MAP)*2);
        if(!Dloc->AllocLoc.Mapping) {
            MyFreePool__(OldInIcb);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    }
    // init Alloc mode
    if((((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) {
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags &= ~ICB_FLAG_ALLOC_MASK;
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags |= Vcb->DefaultAllocMode;
    } else {
        BrutePoint();
    }
    RtlZeroMemory(Dloc->AllocLoc.Mapping, sizeof(EXTENT_MAP)*2);
//    Dloc->AllocLoc.Mapping[0].extLocation = 0;
    Dloc->AllocLoc.Mapping[0].extLength   = Vcb->LBlockSize | EXTENT_NOT_RECORDED_NOT_ALLOCATED;
//    Dloc->AllocLoc.Mapping[1].extLocation = 0;
//    Dloc->AllocLoc.Mapping[1].extLength = 0;
*/
 
    // grow extent in order to force space allocation
    status = UDFResizeExtent(Vcb, PartNum, Vcb->LBlockSize, FALSE, &Dloc->DataLoc);
    if(!OS_SUCCESS(status)) {
        MyFreePool__(OldInIcb);
        return status;
    }
 
    // set Alloc mode
    if((((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) {
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags &= ~ICB_FLAG_ALLOC_MASK;
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags |= NewAllocMode;
    } else {
        BrutePoint();
    }
 
    // revert to initial extent size. This will not cause NonInICB->InICB transform
    status = UDFResizeExtent(Vcb, PartNum, OldLen, FALSE, &Dloc->DataLoc);
    if(!OS_SUCCESS(status)) {
        MyFreePool__(OldInIcb);
        return status;
    }
 
    // replace data from ICB (if any) & free buffer
    status = UDFWriteExtent(Vcb, &(Dloc->DataLoc), 0, OldLen, FALSE, OldInIcb, &_WrittenBytes);
    MyFreePool__(OldInIcb);
    if(!OS_SUCCESS(status)) {
        return status;
    }
    // inform UdfInfo, that AllocDesc's must be rebuilt on flush/close
    Dloc->AllocLoc.Modified = TRUE;
    Dloc->DataLoc.Modified = TRUE;
    return STATUS_SUCCESS;
} // end UDFConvertFEToNonInICB()

Referenced by UDFSetFileAllocModeFromICB().

◆ UDFCrc()

uint16 __fastcall UDFCrc	(	IN uint8 *	Data,
		IN SIZE_T	Size
	)

Definition at line 4527 of file udf_info.cpp.

{
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
//    uint32 _Size = Size;
 
    __asm {
        push  ebx
        push  ecx
        push  edx
        push  esi
 
        mov   esi,ecx
        mov   ecx,edx
        xor   eax,eax
 
        jecxz EO_CRC
 
        lea   ebx,[CrcTable]
        xor   edx,edx
 
CRC_loop:
 
        mov   dl,ah
        xor   dl,[esi]
        mov   ah,al
        mov   al,dh
        xor   ax,[word ptr ebx+edx*2]
        inc   esi
        loop  CRC_loop
 
EO_CRC:
 
        pop   esi
        pop   edx
        pop   ecx
        pop   ebx
 
        ret
    }
#else  // NO X86 optimization , use generic C/C++
    uint16 Crc = 0;
    while (Size--)
        Crc = CrcTable[(Crc >> 8 ^ *Data++) & 0xff] ^ (Crc << 8);
    return Crc;
#endif // _X86_
 
} // end UDFCrc()

Referenced by UDFDecompressUnicode(), UDFReadTagged(), and UDFSetUpTag().

◆ UDFCreateFile__()

OSSTATUS UDFCreateFile__	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN PUNICODE_STRING	fn,
		IN uint32	ExtAttrSz,
		IN uint32	ImpUseLen,
		IN BOOLEAN	Extended,
		IN BOOLEAN	CreateNew,
		IN OUT PUDF_FILE_INFO	DirInfo,
		OUT PUDF_FILE_INFO *	_FileInfo
	)

Definition at line 2577 of file udf_info.cpp.

{
    uint32 l, d;
    uint_di i, j;
    OSSTATUS status;
    LONG_AD FEicb;
    UDF_DIR_SCAN_CONTEXT ScanContext;
    PDIR_INDEX_HDR hDirNdx = DirInfo->Dloc->DirIndex;
    PDIR_INDEX_ITEM DirNdx;
    uint32 LBS = Vcb->LBlockSize;
    PUDF_FILE_INFO FileInfo;
    *_FileInfo = NULL;
    BOOLEAN undel = FALSE;
    SIZE_T ReadBytes;
//    BOOLEAN PackDir = FALSE;
    BOOLEAN FEAllocated = FALSE;
 
    ValidateFileInfo(DirInfo);
    *_FileInfo = NULL;
 
    ASSERT(DirInfo->Dloc->FELoc.Mapping[0].extLocation);
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(!hDirNdx) return STATUS_NOT_A_DIRECTORY;
    i = 0;
 
    _SEH2_TRY {
 
        // check if exists
        status = UDFFindFile(Vcb, IgnoreCase, FALSE, _fn, DirInfo, &i);
        DirNdx = UDFDirIndex(hDirNdx,i);
        if(OS_SUCCESS(status)) {
            // file is a Cur(Parent)Dir
            if(i<2) try_return (status = STATUS_ACCESS_DENIED);
            // file deleted
            if(UDFIsDeleted(DirNdx)) {
                j=0;
                if(OS_SUCCESS(UDFFindFile(Vcb, IgnoreCase, TRUE, _fn, DirInfo, &j))) {
                   i=j;
                   DirNdx = UDFDirIndex(hDirNdx,i);
                   goto CreateBothFound;
                }
                // we needn't allocating new FileIdent inside Dir stream
                // perform 'undel'
                if(DirNdx->FileInfo) {
    //                BrutePoint();
                    status = UDFPretendFileDeleted__(Vcb, DirNdx->FileInfo);
                    if(!OS_SUCCESS(status))
                        try_return (status = STATUS_FILE_DELETED);
                } else {
                    undel = TRUE;
                }
    //            BrutePoint();
                goto CreateUndel;
            }
CreateBothFound:
            // file already exists
            if(CreateNew) try_return (status = STATUS_ACCESS_DENIED);
            // try to open it
            BrutePoint();
            status = UDFOpenFile__(Vcb, IgnoreCase, TRUE, _fn, DirInfo, _FileInfo,&i);
    //        *_FileInfo = FileInfo; // OpenFile__ has already done it, so update it...
            DirNdx = UDFDirIndex(hDirNdx,i);
            DirNdx->FI_Flags &= ~UDF_FI_FLAG_SYS_ATTR;
            FileInfo = *_FileInfo;
            if(!OS_SUCCESS(status)) {
                // :(( can't open....
                if(FileInfo && UDFCleanUpFile__(Vcb, FileInfo)) {
                    MyFreePool__(FileInfo);
                    *_FileInfo = NULL;
                }
                BrutePoint();
                try_return (status);
            }
            // check if we can delete this file
            if(FileInfo->OpenCount || (FileInfo->RefCount > 1)) {
                BrutePoint();
                UDFCloseFile__(Vcb, FileInfo);
                try_return (status = STATUS_CANNOT_DELETE);
            }
            BrutePoint();
            // remove DIRECTORY flag
            DirNdx->FileCharacteristics &= ~FILE_DIRECTORY;
            FileInfo->FileIdent->fileCharacteristics &= ~FILE_DIRECTORY;
            DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
            // truncate file size to ZERO
            status = UDFResizeFile__(Vcb, FileInfo, 0);
            if(!OS_SUCCESS(status)) {
                BrutePoint();
                UDFCloseFile__(Vcb, FileInfo);
            }
            // set NORMAL flag
            FileInfo->FileIdent->fileCharacteristics = 0;
            DirNdx->FileCharacteristics = 0;
            // update DeletedFiles counter in Directory... (for PackDir)
            if(undel && OS_SUCCESS(status))
                hDirNdx->DelCount--;
            try_return (status);
        }
 
CreateUndel:
 
        // allocate FileInfo
        FileInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_FE_TAG);
        *_FileInfo = FileInfo;
        if(!FileInfo)
            try_return (status = STATUS_INSUFFICIENT_RESOURCES);
        ImpUseLen = (ImpUseLen + 3) & ~((uint16)3);
 
        RtlZeroMemory(FileInfo, sizeof(UDF_FILE_INFO));
        // init horizontal links
        FileInfo->NextLinkedFile =
        FileInfo->PrevLinkedFile = FileInfo;
        // allocate space for FileEntry
        if(!OS_SUCCESS(status =
            UDFBuildFileEntry(Vcb, DirInfo, FileInfo, PartNum, ICB_FLAG_AD_IN_ICB, ExtAttrSz, Extended) )) {
            BrutePoint();
            try_return (status);
        }
        FEAllocated = TRUE;
        FEicb.extLength = LBS;
        ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        FEicb.extLocation.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        FEicb.extLocation.partitionReferenceNum = (uint16)PartNum;
        RtlZeroMemory(&(FEicb.impUse), sizeof(FEicb.impUse));
 
        if(!undel) {
            // build FileIdent
            if(!OS_SUCCESS(status =
                UDFBuildFileIdent(Vcb, _fn, &FEicb, ImpUseLen,
                        &(FileInfo->FileIdent), &(FileInfo->FileIdentLen)) ))
                try_return (status);
        } else {
            // read FileIdent
            FileInfo->FileIdent = (PFILE_IDENT_DESC)MyAllocatePoolTag__(NonPagedPool, DirNdx->Length, MEM_FID_TAG);
            if(!(FileInfo->FileIdent)) try_return (status = STATUS_INSUFFICIENT_RESOURCES);
            FileInfo->FileIdentLen = DirNdx->Length;
            if(!OS_SUCCESS(status = UDFReadExtent(Vcb, &(DirInfo->Dloc->DataLoc), DirNdx->Offset,
                                     DirNdx->Length, FALSE, (int8*)(FileInfo->FileIdent), &ReadBytes) ))
                try_return (status);
            FileInfo->FileIdent->fileCharacteristics = 0;
            FileInfo->FileIdent->icb = FEicb;
            ImpUseLen = FileInfo->FileIdent->lengthOfImpUse;
            DirNdx->FileCharacteristics = 0;
        }
        // init 'parentICBLocation' & so on in FE
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum =
             UDFPhysLbaToPart(Vcb, PartNum, DirInfo->Dloc->FELoc.Mapping[0].extLocation);
        ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum = (uint16)PartNum;
    //    ((icbtag*)(FileInfo->Dloc->FileEntry+1))->strategyType = 4;
    //    ((icbtag*)(FileInfo->Dloc->FileEntry+1))->numEntries = 1;
        // try to find suitable unused FileIdent in DirIndex
        l = FileInfo->FileIdentLen;
        if(undel) goto CrF__2;
#ifndef UDF_LIMIT_DIR_SIZE
        if(Vcb->CDR_Mode) {
#endif // UDF_LIMIT_DIR_SIZE
            // search for suitable unused entry
            if(UDFDirIndexInitScan(DirInfo, &ScanContext, 2)) {
                while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
                    if((DirNdx->Length == l) && UDFIsDeleted(DirNdx) &&
                       !DirNdx->FileInfo ) {
                        // free unicode-buffer with old name
                        if(DirNdx->FName.Buffer) {
                            MyFreePool__(DirNdx->FName.Buffer);
                            DirNdx->FName.Buffer = NULL;
                        }
                        i = ScanContext.i;
                        goto CrF__1;
                    }
                }
            }
#ifndef UDF_LIMIT_DIR_SIZE
        } else {
#endif // UDF_LIMIT_DIR_SIZE
            i = UDFDirIndexGetLastIndex(hDirNdx); // 'i' points beyond EO DirIndex
#ifndef UDF_LIMIT_DIR_SIZE
        }
#endif // UDF_LIMIT_DIR_SIZE
 
        // append entry
        if(!OS_SUCCESS(status = UDFDirIndexGrow(&(DirInfo->Dloc->DirIndex), 1))) {
            try_return (status);
        }
 
        // init offset of new FileIdent in directory Data extent
        hDirNdx = DirInfo->Dloc->DirIndex;
        if(i-1) {
            DirNdx = UDFDirIndex(hDirNdx,i-1);
            UDFDirIndex(hDirNdx,i)->Offset = DirNdx->Offset + DirNdx->Length;
            DirNdx = UDFDirIndex(hDirNdx,i);
        } else {
            DirNdx = UDFDirIndex(hDirNdx,i);
            DirNdx->Offset = 0;
        }
        // new terminator is recorded by UDFDirIndexGrow()
        if( ((d = ((LBS - (DirNdx->Offset + l + DirInfo->Dloc->DataLoc.Offset)) & (LBS-1) )) < sizeof(FILE_IDENT_DESC)) &&
              d ) {
            // insufficient space at the end of last sector for
            // next FileIdent's tag. fill it with ImpUse data
 
            // generally, all data should be DWORD-aligned, but if it is not so
            // this opearation will help us to avoid glitches
            d = (d+3) & ~((uint32)3);
 
            uint32 IUl, FIl;
            if(!MyReallocPool__((int8*)(FileInfo->FileIdent), l,
                         (int8**)&(FileInfo->FileIdent), (l+d+3) & ~((uint32)(3)) ))
                try_return (status = STATUS_INSUFFICIENT_RESOURCES);
            l += d;
            IUl = FileInfo->FileIdent->lengthOfImpUse;
            FIl = FileInfo->FileIdent->lengthFileIdent;
            // move filename to higher addr
            RtlMoveMemory(((int8*)(FileInfo->FileIdent+1))+IUl+d,
                          ((int8*)(FileInfo->FileIdent+1))+IUl, FIl);
            RtlZeroMemory(((int8*)(FileInfo->FileIdent+1))+IUl, d);
            FileInfo->FileIdent->lengthOfImpUse += (uint16)d;
            FileInfo->FileIdentLen = l;
        }
        DirNdx->Length = l;
CrF__1:
        // clone unicode string
        // it  **<<MUST>>**  be allocated with internal memory manager
        DirNdx->FName.Buffer = (PWCHAR)MyAllocatePoolTag__(UDF_FILENAME_MT, (DirNdx->FName.MaximumLength = _fn->Length + sizeof(WCHAR)), MEM_FNAMECPY_TAG);
        DirNdx->FName.Length = _fn->Length;
        if(!DirNdx->FName.Buffer)
            try_return (status = STATUS_INSUFFICIENT_RESOURCES);
        RtlCopyMemory(DirNdx->FName.Buffer, _fn->Buffer, _fn->Length);
        DirNdx->FName.Buffer[_fn->Length/sizeof(WCHAR)] = 0;
CrF__2:
        DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes), HASH_ALL);
        // we get here immediately when 'undel' occured
        FileInfo->Index = i;
        DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
        DirNdx->FI_Flags &= ~UDF_FI_FLAG_SYS_ATTR;
        ASSERT(!DirNdx->FileInfo);
        DirNdx->FileInfo = FileInfo;
        DirNdx->FileEntryLoc = FEicb.extLocation;
        // mark file as 'deleted' for now
        DirNdx->FileCharacteristics = FILE_DELETED;
        FileInfo->FileIdent->fileCharacteristics |= FILE_DELETED;
        FileInfo->Dloc->DataLoc.Mapping = UDFExtentToMapping(&(FileInfo->Dloc->FELoc.Mapping[0]));
        if(!(FileInfo->Dloc->DataLoc.Mapping)) {
            UDFFlushFI(Vcb, FileInfo, PartNum);
            try_return (status = STATUS_INSUFFICIENT_RESOURCES);
        }
        FileInfo->Dloc->DataLoc.Length = 0;
        FileInfo->Dloc->DataLoc.Offset = FileInfo->Dloc->FileEntryLen;
        FileInfo->ParentFile = DirInfo;
        // init FileEntry
        UDFSetFileUID(Vcb, FileInfo);
        UDFSetFileSize(FileInfo, 0);
        UDFIncFileLinkCount(FileInfo); // increase to 1
        UDFUpdateCreateTime(Vcb, FileInfo);
        UDFAttributesToUDF(UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo),FileInfo->Index),
                             FileInfo->Dloc->FileEntry, Vcb->DefaultAttr);
        FileInfo->Dloc->DataLoc.Mapping[0].extLength &= UDF_EXTENT_LENGTH_MASK;
        FileInfo->Dloc->DataLoc.Modified = TRUE;
        FileInfo->Dloc->FELoc.Mapping[0].extLength &= UDF_EXTENT_LENGTH_MASK;
        // zero sector for FileEntry
        if(!Vcb->CDR_Mode) {
            status = UDFWriteData(Vcb, TRUE, ((int64)(FileInfo->Dloc->FELoc.Mapping[0].extLocation)) << Vcb->BlockSizeBits, LBS, FALSE, Vcb->ZBuffer, &ReadBytes);
            if(!OS_SUCCESS(status)) {
                UDFFlushFI(Vcb, FileInfo, PartNum);
                try_return (status);
            }
        }
#if 0
        if((i >= 2) && (DirNdx->FName.Buffer[0] == L'.')) {
            BrutePoint();
        }
#endif
 
#ifdef UDF_CHECK_DISK_ALLOCATION
        if(  /*FileInfo->Fcb &&*/
             UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
 
            if(!FileInfo->FileIdent ||
               !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED)) {
                AdPrint(("Flushing to Discarded block %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
                BrutePoint();
            }
        }
#endif // UDF_CHECK_DISK_ALLOCATION
 
        // make FileIdent valid
        FileInfo->FileIdent->fileCharacteristics = 0;
        DirNdx->FileCharacteristics = 0;
        UDFReferenceFile__(FileInfo);
        UDFFlushFE(Vcb, FileInfo, PartNum);
        if(undel)
            hDirNdx->DelCount--;
        UDFReleaseDloc(Vcb, FileInfo->Dloc);
        UDFIncFileCounter(Vcb);
 
        UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
 
        try_return (status = STATUS_SUCCESS);
 
try_exit:   NOTHING;
 
    } _SEH2_FINALLY {
        if(!OS_SUCCESS(status)) {
            if(FEAllocated)
                UDFFreeFESpace(Vcb, DirInfo, &(FileInfo->Dloc->FELoc));
        }
    } _SEH2_END
    return status;
 
} // end UDFCreateFile__()

Referenced by UDFCommonCreate(), UDFHardLinkFile__(), UDFRenameMoveFile__(), and UDFWriteSecurity().

◆ UDFCreateRootFile__()

OSSTATUS UDFCreateRootFile__	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN uint32	ExtAttrSz,
		IN uint32	ImpUseLen,
		IN BOOLEAN	Extended,
		OUT PUDF_FILE_INFO *	_FileInfo
	)

Definition at line 4827 of file udf_info.cpp.

{
    OSSTATUS status;
    LONG_AD FEicb;
    PUDF_FILE_INFO FileInfo;
    *_FileInfo = NULL;
    SIZE_T ReadBytes;
 
    FileInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_FINF_TAG);
    *_FileInfo = FileInfo;
    if(!FileInfo)
        return STATUS_INSUFFICIENT_RESOURCES;
    ImpUseLen = (ImpUseLen + 3) & ~((uint16)3);
 
    RtlZeroMemory(FileInfo, sizeof(UDF_FILE_INFO));
    // init horizontal links
    FileInfo->NextLinkedFile =
    FileInfo->PrevLinkedFile = FileInfo;
    // allocate space for FileEntry
    if(!OS_SUCCESS(status =
        UDFBuildFileEntry(Vcb, NULL, FileInfo, PartNum, ICB_FLAG_AD_IN_ICB, ExtAttrSz, Extended) ))
        return status;
    FEicb.extLength = Vcb->LBlockSize;
    FEicb.extLocation.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    FEicb.extLocation.partitionReferenceNum = (uint16)PartNum;
    RtlZeroMemory(&(FEicb.impUse), sizeof(FEicb.impUse));
 
    FileInfo->Dloc->DataLoc.Mapping = UDFExtentToMapping(&(FileInfo->Dloc->FELoc.Mapping[0]));
    if(!(FileInfo->Dloc->DataLoc.Mapping)) return STATUS_INSUFFICIENT_RESOURCES;
    FileInfo->Dloc->DataLoc.Length = 0;
    FileInfo->Dloc->DataLoc.Offset = FileInfo->Dloc->FileEntryLen;
    // init FileEntry
    UDFSetFileUID(Vcb, FileInfo);
    UDFSetFileSize(FileInfo, 0);
    UDFIncFileLinkCount(FileInfo); // increase to 1
    UDFUpdateCreateTime(Vcb, FileInfo);
    // zero sector for FileEntry
    FileInfo->Dloc->DataLoc.Mapping[0].extLength &= UDF_EXTENT_LENGTH_MASK;
    FileInfo->Dloc->FELoc.Mapping[0].extLength &= UDF_EXTENT_LENGTH_MASK;
    status = UDFWriteData(Vcb, TRUE, ((int64)(FileInfo->Dloc->FELoc.Mapping[0].extLocation)) << Vcb->BlockSizeBits, Vcb->LBlockSize, FALSE, Vcb->ZBuffer, &ReadBytes);
    if(!OS_SUCCESS(status))
        return status;
 
    UDFReferenceFile__(FileInfo);
    UDFReleaseDloc(Vcb, FileInfo->Dloc);
    return STATUS_SUCCESS;
} // end UDFCreateRootFile__()

Referenced by UDFCreateStreamDir__().

◆ UDFCreateStreamDir__()

OSSTATUS UDFCreateStreamDir__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		OUT PUDF_FILE_INFO *	_SDirInfo
	)

Definition at line 4888 of file udf_info.cpp.

{
    OSSTATUS status;
    PUDF_FILE_INFO SDirInfo;
    uint16 Ident;
 
    *_SDirInfo = NULL;
    ValidateFileInfo(FileInfo);
    // check currently recorded UDF revision
    if(!UDFStreamsSupported(Vcb))
        return STATUS_INVALID_PARAMETER;
    // check if we are allowed to associate Stream Dir with this file
    if((FileInfo->ParentFile && UDFIsAStreamDir(FileInfo->ParentFile)) ||
        UDFHasAStreamDir(FileInfo))
        return STATUS_FILE_DELETED;
    // check if we have Deleted SDir
    if(FileInfo->Dloc->SDirInfo &&
       UDFIsSDirDeleted(FileInfo->Dloc->SDirInfo))
        return STATUS_ACCESS_DENIED;
    // check if this file has ExtendedFileEntry
    if((Ident = FileInfo->Dloc->FileEntry->tagIdent) != TID_EXTENDED_FILE_ENTRY) {
        if(!OS_SUCCESS(status = UDFConvertFEToExtended(Vcb, FileInfo)))
            return status;
    }
 
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    // create stream directory file
    if(!OS_SUCCESS(status = UDFCreateRootFile__(Vcb, PartNum, 0,0,FALSE, &SDirInfo)))
        return status;
    // link objects
    SDirInfo->ParentFile = FileInfo;
    // record directory structure
    SDirInfo->Dloc->FE_Flags |= (UDF_FE_FLAG_FE_MODIFIED | UDF_FE_FLAG_IS_SDIR);
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_HAS_SDIR;
    UDFIncFileLinkCount(FileInfo);
    FileInfo->Dloc->FE_Flags &= ~UDF_FE_FLAG_HAS_SDIR;
 
    status = UDFRecordDirectory__(Vcb, SDirInfo);
    UDFDecDirCounter(Vcb);
 
    UDFInterlockedIncrement((PLONG)&(FileInfo->OpenCount));
    if(!OS_SUCCESS(status)) {
        UDFUnlinkFile__(Vcb, SDirInfo, TRUE);
        UDFCloseFile__(Vcb, SDirInfo);
        UDFCleanUpFile__(Vcb, SDirInfo);
        MyFreePool__(SDirInfo);
        ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLength = 0;
        ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLocation.partitionReferenceNum = 0;
        ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLocation.logicalBlockNum = 0;
        return status;
    }
    *_SDirInfo = SDirInfo;
    // do some init
    ((PEXTENDED_FILE_ENTRY)(SDirInfo->Dloc->FileEntry))->icbTag.fileType = UDF_FILE_TYPE_STREAMDIR;
    ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLength = Vcb->LBlockSize;
    ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLocation.partitionReferenceNum = (uint16)PartNum;
    ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLocation.logicalBlockNum =
        UDFPhysLbaToPart(Vcb, PartNum, SDirInfo->Dloc->FELoc.Mapping[0].extLocation);
    ((PEXTENDED_FILE_ENTRY)(SDirInfo->Dloc->FileEntry))->uniqueID =
        ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->uniqueID;
    FileInfo->Dloc->FE_Flags |= (UDF_FE_FLAG_FE_MODIFIED | UDF_FE_FLAG_HAS_SDIR);
    // open & finalize linkage
    FileInfo->Dloc->SDirInfo = SDirInfo;
    return STATUS_SUCCESS;
} // end UDFCreateStreamDir__()

Referenced by UDFCommonCreate(), and UDFWriteSecurity().

◆ UDFDecompressUnicode()

void __fastcall UDFDecompressUnicode	(	IN OUT PUNICODE_STRING	UName,
		IN uint8 *	CS0,
		IN SIZE_T	Length,
		OUT uint16 *	valueCRC
	)

Definition at line 170 of file udf_info.cpp.

{
    uint16 compID = CS0[0];
    uint32 unicodeIndex = 0;
    uint32 byteIndex = 1;
    PWCHAR buff;
    uint8* _CS0 = CS0+1;
 
    if(!Length) goto return_empty_str;
    // First check for valid compID.
    switch(compID) {
    case UDF_COMP_ID_8: {
 
        buff = (PWCHAR)MyAllocatePoolTag__(UDF_FILENAME_MT, (Length)*sizeof(WCHAR), MEM_FNAME_TAG);
        if(!buff) goto return_empty_str;
        UName->Buffer = buff;
 
        // Loop through all the bytes.
        while (byteIndex < Length) {
            (*buff) = (*_CS0);
            _CS0++;
            byteIndex++;
            buff++;
        }
        unicodeIndex = byteIndex-1;
        break;
    }
    case UDF_COMP_ID_16: {
 
        buff = (PWCHAR)MyAllocatePoolTag__(UDF_FILENAME_MT, (Length-1)+sizeof(WCHAR), MEM_FNAME16_TAG);
        if(!buff) goto return_empty_str;
        UName->Buffer = buff;
 
        // Loop through all the bytes.
        while (byteIndex < Length) {
            // Move the first byte to the high bits of the unicode char.
            *buff = ((*_CS0) << 8) | (*(_CS0+1));
            _CS0+=2;
            byteIndex+=2;
            unicodeIndex++;
            buff++;
            ASSERT(byteIndex <= Length);
        }
        break;
    }
    default: {
return_empty_str:
        UName->Buffer = NULL;
        UName->MaximumLength =
        UName->Length = 0;
        return;
    }
    }
    UName->MaximumLength = (UName->Length = (((uint16)unicodeIndex)*sizeof(WCHAR))) + sizeof(WCHAR);
    UName->Buffer[unicodeIndex] = 0;
    if(valueCRC) {
        *valueCRC = UDFCrc(CS0+1, Length-1);
    }
} // end UDFDecompressUnicode()

Referenced by UDFGetDstring(), and UDFIndexDirectory().

◆ UDFDelXSpaceBitmap()

OSSTATUS UDFDelXSpaceBitmap	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN PSHORT_AD	bm
	)

◆ UDFDirIndex()

__inline PDIR_INDEX_ITEM UDFDirIndex	(	IN PDIR_INDEX_HDR	hDirNdx,
		IN uint_di	i
	)

Definition at line 1105 of file udf_info.h.

{
#ifdef UDF_LIMIT_DIR_SIZE
    if( hDirNdx && (i < hDirNdx->LastFrameCount))
        return &( (((PDIR_INDEX_ITEM*)(hDirNdx+1))[0])[i] );
#else //UDF_LIMIT_DIR_SIZE
    uint_di j, k;
    if( hDirNdx &&
        ((j = (i >> UDF_DIR_INDEX_FRAME_SH)) < (k = hDirNdx->FrameCount) ) &&
        ((i = (i & (UDF_DIR_INDEX_FRAME-1))) < ((j < (k-1)) ? UDF_DIR_INDEX_FRAME : hDirNdx->LastFrameCount)) )
        return &( (((PDIR_INDEX_ITEM*)(hDirNdx+1))[j])[i] );
#endif // UDF_LIMIT_DIR_SIZE
    return NULL;
}

Referenced by UDFBlankMount(), UDFCleanUpFile__(), UDFCloseFile__(), UDFCommonCleanup(), UDFCommonClose(), UDFCommonCreate(), UDFCompareFileInfo(), UDFCompleteMount(), UDFCreateFile__(), UDFDoesOSAllowFilePretendDeleted__(), UDFDoesOSAllowFileToBeTargetForRename__(), UDFDoesOSAllowFileToBeUnlinked__(), UDFFindNextMatch(), UDFFirstOpenFile(), UDFFlushAFile(), UDFFlushFE(), UDFFlushFI(), UDFFlushFile__(), UDFGetAltNameInformation(), UDFGetBasicInformation(), UDFGetFileSizeFromDirNdx(), UDFGetFileStreamInformation(), UDFGetNetworkInformation(), UDFHardLinkFile__(), UDFIndexDirectory(), UDFIsDirEmpty(), UDFIsDirInfoCached(), UDFOpenFile__(), UDFPackDirectory__(), UDFPretendFileDeleted__(), UDFQueryDirectory(), UDFRecordDirectory__(), UDFRename(), UDFRenameMoveFile__(), UDFResizeFile__(), UDFReTagDirectory(), UDFSetBasicInformation(), UDFSetEOF(), UDFSetFileSizeInDirNdx(), UDFSetFileXTime(), UDFUnlinkAllFilesInDir(), and UDFUnlinkFile__().

◆ UDFDirIndexFree()

void UDFDirIndexFree ( PDIR_INDEX_HDR hDirNdx )

Definition at line 98 of file dirtree.cpp.

{
    uint32 k;
    PDIR_INDEX_ITEM* FrameList;
 
    FrameList = (PDIR_INDEX_ITEM*)(hDirNdx+1);
    if(!hDirNdx) return;
    for(k=0; k<hDirNdx->FrameCount; k++, FrameList++) {
        if(*FrameList) MyFreePool__(*FrameList);
    }
    MyFreePool__(hDirNdx);
} // UDFDirIndexFree();

Referenced by UDFCleanUpFile__(), and UDFIndexDirectory().

◆ UDFDirIndexGetFrame()

PDIR_INDEX_ITEM UDFDirIndexGetFrame	(	IN PDIR_INDEX_HDR	hDirNdx,
		IN uint32	Frame,
		OUT uint32 *	FrameLen,
		OUT uint_di *	Index,
		IN uint_di	Rel
	)

Definition at line 316 of file dirtree.cpp.

{
    if(Frame >= hDirNdx->FrameCount)
        return NULL;
    if(Index) {
#ifdef UDF_LIMIT_DIR_SIZE
        (*Index) = Rel;
//    if(FrameLen)
        (*FrameLen) = hDirNdx->LastFrameCount;
#else //UDF_LIMIT_DIR_SIZE
        (*Index) = Frame*UDF_DIR_INDEX_FRAME+Rel;
//    if(FrameLen)
        (*FrameLen) = (Frame < (hDirNdx->FrameCount-1)) ? UDF_DIR_INDEX_FRAME :
                                                          hDirNdx->LastFrameCount;
#endif //UDF_LIMIT_DIR_SIZE
    }
    return ((PDIR_INDEX_ITEM*)(hDirNdx+1))[Frame]+Rel;
} // end UDFDirIndexGetFrame()

Referenced by UDFDirIndexInitScan(), and UDFDirIndexScan().

◆ UDFDirIndexGrow()

OSSTATUS UDFDirIndexGrow	(	IN PDIR_INDEX_HDR *	_hDirNdx,
		IN uint_di	d
	)

Definition at line 117 of file dirtree.cpp.

{
    uint_di j,k;
    PDIR_INDEX_HDR hDirNdx = *_hDirNdx;
    PDIR_INDEX_ITEM* FrameList;
 
    if(d > UDF_DIR_INDEX_FRAME)
        return STATUS_INVALID_PARAMETER;
 
    j = hDirNdx->LastFrameCount+d;
 
    if(j > UDF_DIR_INDEX_FRAME) {
#ifndef UDF_LIMIT_DIR_SIZE // release
        // Grow header
        k = hDirNdx->FrameCount;
        if(!MyReallocPool__((int8*)hDirNdx, sizeof(DIR_INDEX_HDR) + k*sizeof(PDIR_INDEX_ITEM),
                       (int8**)(&hDirNdx), sizeof(DIR_INDEX_HDR) + (k+1)*sizeof(PDIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
        FrameList = (PDIR_INDEX_ITEM*)(hDirNdx+1);
        // Grow last frame
        if(!MyReallocPool__((int8*)(FrameList[k-1]), AlignDirIndex(hDirNdx->LastFrameCount)*sizeof(DIR_INDEX_ITEM),
                       (int8**)(&(FrameList[k-1])), UDF_DIR_INDEX_FRAME*sizeof(DIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
        RtlZeroMemory(&(FrameList[k-1][hDirNdx->LastFrameCount]),
                       (UDF_DIR_INDEX_FRAME-hDirNdx->LastFrameCount)*sizeof(DIR_INDEX_ITEM));
        hDirNdx->LastFrameCount = UDF_DIR_INDEX_FRAME;
        // Allocate new frame
        FrameList[k] = (PDIR_INDEX_ITEM)MyAllocatePoolTag__(UDF_DIR_INDEX_MT, AlignDirIndex(j-UDF_DIR_INDEX_FRAME)*sizeof(DIR_INDEX_ITEM), MEM_DIR_NDX_TAG );
        if(!FrameList[k])
            return STATUS_INSUFFICIENT_RESOURCES;
        hDirNdx->FrameCount++;
        RtlZeroMemory(FrameList[k], (j-UDF_DIR_INDEX_FRAME)*sizeof(DIR_INDEX_ITEM));
        hDirNdx->LastFrameCount = j-UDF_DIR_INDEX_FRAME;
        (*_hDirNdx) = hDirNdx;
#else   // UDF_LIMIT_DIR_SIZE
        return STATUS_INSUFFICIENT_RESOURCES;
#endif  // UDF_LIMIT_DIR_SIZE
    } else {
        k = hDirNdx->FrameCount;
        FrameList = (PDIR_INDEX_ITEM*)(hDirNdx+1);
        if(!MyReallocPool__((int8*)(FrameList[k-1]), AlignDirIndex(hDirNdx->LastFrameCount)*sizeof(DIR_INDEX_ITEM),
                       (int8**)(&(FrameList[k-1])), AlignDirIndex(j)*sizeof(DIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
        RtlZeroMemory(&(FrameList[k-1][hDirNdx->LastFrameCount]),
                       (j-hDirNdx->LastFrameCount)*sizeof(DIR_INDEX_ITEM));
        hDirNdx->LastFrameCount = j;
    }
    return STATUS_SUCCESS;
} // end UDFDirIndexGrow()

Referenced by UDFCreateFile__().

◆ UDFDirIndexInitScan()

BOOLEAN UDFDirIndexInitScan	(	IN PUDF_FILE_INFO	DirInfo,
		OUT PUDF_DIR_SCAN_CONTEXT	Context,
		IN uint_di	Index
	)

Definition at line 347 of file dirtree.cpp.

{
    Context->DirInfo = DirInfo;
    Context->hDirNdx = DirInfo->Dloc->DirIndex;
    if( (Context->frame = (Index >> UDF_DIR_INDEX_FRAME_SH)) >=
                                                 Context->hDirNdx->FrameCount) {
        return FALSE;
    }
    if( (Context->j = Index & (UDF_DIR_INDEX_FRAME-1)) >=
               ((Context->frame < (Context->hDirNdx->FrameCount-1))
                                    ?
                                 UDF_DIR_INDEX_FRAME : Context->hDirNdx->LastFrameCount) ) {
        return FALSE;
    }
    Context->DirNdx = UDFDirIndexGetFrame(Context->hDirNdx,
                                          Context->frame,
                                          &(Context->d),
                                          &(Context->i),
                                          Context->j);
    Context->i--;
    Context->j--;
    Context->DirNdx--;
 
    return TRUE;
} // end UDFDirIndexInitScan()

Referenced by UDFBuildTreeItemsList(), UDFCreateFile__(), UDFFindFile(), UDFFlushADirectory(), UDFMarkStreamsForDeletion(), UDFPackDirectory__(), and UDFReTagDirectory().

◆ UDFDirIndexScan()

PDIR_INDEX_ITEM UDFDirIndexScan	(	PUDF_DIR_SCAN_CONTEXT	Context,
		PUDF_FILE_INFO *	_FileInfo
	)

Definition at line 378 of file dirtree.cpp.

{
    PUDF_FILE_INFO FileInfo;
    PUDF_FILE_INFO ParFileInfo;
 
    Context->i++;
    Context->j++;
    Context->DirNdx++;
 
    if(Context->j >= Context->d) {
        Context->j=0;
        Context->frame++;
        Context->DirNdx = UDFDirIndexGetFrame(Context->hDirNdx,
                                              Context->frame,
                                              &(Context->d),
                                              &(Context->i),
                                              Context->j);
    }
    if(!Context->DirNdx) {
        if(_FileInfo)
            (*_FileInfo) = NULL;
        return NULL;
    }
 
    if(_FileInfo) {
        if((FileInfo = Context->DirNdx->FileInfo)) {
            if(FileInfo->ParentFile != Context->DirInfo) {
                ParFileInfo = UDFLocateParallelFI(Context->DirInfo,
                                                  Context->i,
                                                  FileInfo);
#ifdef UDF_DBG
                if(ParFileInfo->ParentFile != Context->DirInfo) {
                    BrutePoint();
                }
#endif // UDF_DBG
                FileInfo = ParFileInfo;
            }
        }
        (*_FileInfo) = FileInfo;
    }
 
    return (Context->DirNdx);
} // end UDFDirIndexScan()

Referenced by UDFBuildTreeItemsList(), UDFCreateFile__(), UDFFindFile(), UDFFlushADirectory(), UDFMarkStreamsForDeletion(), UDFPackDirectory__(), and UDFReTagDirectory().

◆ UDFDirIndexTrunc()

OSSTATUS UDFDirIndexTrunc	(	IN PDIR_INDEX_HDR *	_hDirNdx,
		IN uint_di	d
	)

Definition at line 174 of file dirtree.cpp.

{
    uint_di j,k;
 
    if(d > UDF_DIR_INDEX_FRAME) {
        OSSTATUS status;
        while(d) {
            k = (d > UDF_DIR_INDEX_FRAME) ? UDF_DIR_INDEX_FRAME : d;
            if(!OS_SUCCESS(status = UDFDirIndexTrunc(_hDirNdx, k))) {
                return status;
            }
            d -= k;
        }
        return STATUS_SUCCESS;
    }
 
    PDIR_INDEX_HDR hDirNdx = *_hDirNdx;
    PDIR_INDEX_ITEM* FrameList;
 
    j = UDF_DIR_INDEX_FRAME+hDirNdx->LastFrameCount-d;
    FrameList = (PDIR_INDEX_ITEM*)(hDirNdx+1);
    k = hDirNdx->FrameCount-1;
 
    if(j <= UDF_DIR_INDEX_FRAME) {
        // free last frame
        if(!k && (j < 2)) {
            // someone tries to trunc. residual entries...
            return STATUS_INVALID_PARAMETER;
        }
        MyFreePool__(FrameList[k]);
        FrameList[k] = NULL;
        hDirNdx->LastFrameCount = UDF_DIR_INDEX_FRAME;
        hDirNdx->FrameCount--;
        // Truncate new last frame
        if(!MyReallocPool__((int8*)(FrameList[k-1]), UDF_DIR_INDEX_FRAME*sizeof(DIR_INDEX_ITEM),
                       (int8**)(&(FrameList[k-1])), AlignDirIndex(j)*sizeof(DIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
        hDirNdx->LastFrameCount = j;
        // Truncate header
        if(!MyReallocPool__((int8*)hDirNdx, sizeof(DIR_INDEX_HDR) + (k+1)*sizeof(PDIR_INDEX_ITEM),
                       (int8**)(&hDirNdx), sizeof(DIR_INDEX_HDR) + k*sizeof(PDIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
 
        (*_hDirNdx) = hDirNdx;
 
    } else {
 
        j -= UDF_DIR_INDEX_FRAME;
        if(!k && (j < 2)) {
            // someone tries to trunc. residual entries...
            return STATUS_INVALID_PARAMETER;
        }
 
        if(!MyReallocPool__((int8*)(FrameList[k]), AlignDirIndex(hDirNdx->LastFrameCount)*sizeof(DIR_INDEX_ITEM),
                       (int8**)(&(FrameList[k])), AlignDirIndex(j)*sizeof(DIR_INDEX_ITEM) ) )
            return STATUS_INSUFFICIENT_RESOURCES;
        hDirNdx->LastFrameCount = j;
    }
    return STATUS_SUCCESS;
} // end UDFDirIndexTrunc()

Referenced by UDFDirIndexTrunc(), and UDFPackDirectory__().

◆ UDFDOSName()

void __fastcall UDFDOSName	(	IN PVCB	Vcb,
		IN OUT PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	UdfName,
		IN BOOLEAN	KeepIntact
	)

Definition at line 427 of file udf_info.cpp.

{
#ifndef _CONSOLE
    if(Vcb->CompatFlags & UDF_VCB_IC_OS_NATIVE_DOS_NAME) {
        UDFDOSNameOsNative(DosName, UdfName, KeepIntact);
        return;
    }
#endif //_CONSOLE
 
    switch(Vcb->CurrentUDFRev) {
    case 0x0100:
    case 0x0101:
    case 0x0102:
        UDFDOSName100(DosName, UdfName, KeepIntact);
        break;
 
    case 0x0150:
        // in general, we need bytes-from-media to
        // create valid UDF 1.50 name.
        // Curently it is impossible, thus,  we'll use
        // UDF 2.00 translation algorithm
    case 0x0200:
        UDFDOSName200(DosName, UdfName, KeepIntact, Vcb->CurrentUDFRev == 0x0150);
        break;
 
    case 0x0201:
    default:
        UDFDOSName201(DosName, UdfName, KeepIntact);
    }
}

Referenced by UDFBuildHashEntry(), UDFFileDirInfoToNT(), UDFFindFile(), and UDFIsNameInExpression().

◆ UDFDOSName100()

void __fastcall UDFDOSName100	(	IN OUT PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	UdfName,
		IN BOOLEAN	KeepIntact
	)

Definition at line 465 of file udf_info.cpp.

{
    PWCHAR dosName = DosName->Buffer;
    PWCHAR udfName = UdfName->Buffer;
    uint32 udfLen = UdfName->Length / sizeof(WCHAR);
 
    uint32 index, dosIndex = 0, extIndex = 0, lastPeriodIndex;
    BOOLEAN needsCRC = FALSE, hasExt = FALSE, writingExt = FALSE, isParent = FALSE;
    uint32 valueCRC;
    WCHAR ext[DOS_EXT_LEN], current;
 
    if(KeepIntact &&
       (udfLen <= 2) && (udfName[0] == UNICODE_PERIOD)) {
        isParent = TRUE;
        if((udfLen == 2) && (udfName[1] != UNICODE_PERIOD))
            isParent = FALSE;
    }
 
    for (index = 0 ; index < udfLen ; index++) {
        current = udfName[index];
        if (current == UNICODE_PERIOD && !isParent) {
            if (dosIndex==0 || hasExt) {
                // Ignore leading periods or any other than used for extension.
                needsCRC = TRUE;
            } else {
                // First, find last character which is NOT a period or space.
                lastPeriodIndex = udfLen - 1;
                while(lastPeriodIndex >=0 &&
                     (udfName[lastPeriodIndex] == UNICODE_PERIOD ||
                      udfName[lastPeriodIndex] == UNICODE_SPACE))
                    lastPeriodIndex--;
                // Now search for last remaining period.
                while(lastPeriodIndex >= 0 &&
                      udfName[lastPeriodIndex] != UNICODE_PERIOD)
                    lastPeriodIndex--;
                // See if the period we found was the last or not.
                if (lastPeriodIndex != index)
                    needsCRC = TRUE; // If not, name needs translation.
                // As long as the period was not trailing,
                // the file name has an extension.
                if (lastPeriodIndex >= 0) hasExt = TRUE;
            }
        } else {
            if ((!hasExt && dosIndex == DOS_NAME_LEN) ||
                 extIndex == DOS_EXT_LEN) {
                // File name or extension is too long for DOS.
                needsCRC = TRUE;
            } else {
                if (current == UNICODE_SPACE) { // Ignore spaces.
                    needsCRC = TRUE;
                } else {
                    // Look for illegal or unprintable characters.
                    if (UDFIsIllegalChar(current) /*|| !UnicodeIsPrint(current)*/) {
                        needsCRC = TRUE;
                        current = ILLEGAL_CHAR_MARK;
                        /* Skip Illegal characters(even spaces),
                        * but not periods.
                        */
                        while(index+1 < udfLen &&
                              (UDFIsIllegalChar(udfName[index+1]) /*||
                              !UnicodeIsPrint(udfName[index+1])*/) &&
                              udfName[index+1] != UNICODE_PERIOD)
                            index++;
                    }
                    // Add current char to either file name or ext.
                    if (writingExt) {
                        ext[extIndex] = current;
                        extIndex++;
                    } else {
                        dosName[dosIndex] = current;
                        dosIndex++;
                    }
                }
            }
        }
        // See if we are done with file name, either because we reached
        // the end of the file name length, or the final period.
        if (!writingExt && hasExt && (dosIndex == DOS_NAME_LEN ||
            index == lastPeriodIndex)) {
            // If so, and the name has an extension, start reading it.
            writingExt = TRUE;
            // Extension starts after last period.
            index = lastPeriodIndex;
        }
    }
    //
    if (needsCRC) {
        // Add CRC to end of file name or at position 4.
        if (dosIndex >4) dosIndex = 4;
        valueCRC = UDFUnicodeCksum(udfName, udfLen);
        // set CRC prefix
        dosName[dosIndex] = UNICODE_CRC_MARK;
        // Convert 12-bit CRC to hex characters.
        dosName[dosIndex+1] = hexChar[(valueCRC & 0x0f00) >> 8];
        dosName[dosIndex+2] = hexChar[(valueCRC & 0x00f0) >> 4];
        dosName[dosIndex+3] = hexChar[(valueCRC & 0x000f)];
        dosIndex+=4;
    }
    // Add extension, if any.
    if (extIndex != 0) {
        dosName[dosIndex] = UNICODE_PERIOD;
        dosIndex++;
        for (index = 0; index < extIndex; index++) {
            dosName[dosIndex] = ext[index];
            dosIndex++;
        }
    }
    DosName->Length = (uint16)dosIndex*sizeof(WCHAR);
    RtlUpcaseUnicodeString(DosName, DosName, FALSE);
} // end UDFDOSName100()

Referenced by UDFDOSName().

◆ UDFDOSName200()

void __fastcall UDFDOSName200	(	IN OUT PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	UdfName,
		IN BOOLEAN	KeepIntact,
		IN BOOLEAN	Mode150
	)

Definition at line 582 of file udf_info.cpp.

{
    PWCHAR dosName = DosName->Buffer;
    PWCHAR udfName = UdfName->Buffer;
    uint32 udfLen = UdfName->Length / sizeof(WCHAR);
 
    uint32 index, dosIndex = 0, extIndex = 0, lastPeriodIndex;
    BOOLEAN needsCRC = FALSE, hasExt = FALSE, writingExt = FALSE, isParent = FALSE;
    uint32 valueCRC;
    WCHAR ext[DOS_EXT_LEN], current;
 
    if(KeepIntact &&
       (udfLen <= 2) && (udfName[0] == UNICODE_PERIOD)) {
        isParent = TRUE;
        if((udfLen == 2) && (udfName[1] != UNICODE_PERIOD))
            isParent = FALSE;
    }
 
    for (index = 0 ; index < udfLen ; index++) {
        current = udfName[index];
        if (current == UNICODE_PERIOD && !isParent) {
            if (dosIndex==0 || hasExt) {
                // Ignore leading periods or any other than used for extension.
                needsCRC = TRUE;
            } else {
                // First, find last character which is NOT a period or space.
                lastPeriodIndex = udfLen - 1;
                while(lastPeriodIndex >=0 &&
                     (udfName[lastPeriodIndex] == UNICODE_PERIOD ||
                      udfName[lastPeriodIndex] == UNICODE_SPACE))
                    lastPeriodIndex--;
                // Now search for last remaining period.
                while(lastPeriodIndex >= 0 &&
                      udfName[lastPeriodIndex] != UNICODE_PERIOD)
                    lastPeriodIndex--;
                // See if the period we found was the last or not.
                if (lastPeriodIndex != index)
                    needsCRC = TRUE; // If not, name needs translation.
                // As long as the period was not trailing,
                // the file name has an extension.
                if (lastPeriodIndex >= 0) hasExt = TRUE;
            }
        } else {
            if ((!hasExt && dosIndex == DOS_NAME_LEN) ||
                 extIndex == DOS_EXT_LEN) {
                // File name or extension is too long for DOS.
                needsCRC = TRUE;
            } else {
                if (current == UNICODE_SPACE) { // Ignore spaces.
                    needsCRC = TRUE;
                } else {
                    // Look for illegal or unprintable characters.
                    if (UDFIsIllegalChar(current) /*|| !UnicodeIsPrint(current)*/) {
                        needsCRC = TRUE;
                        current = ILLEGAL_CHAR_MARK;
                        /* Skip Illegal characters(even spaces),
                        * but not periods.
                        */
                        while(index+1 < udfLen &&
                              (UDFIsIllegalChar(udfName[index+1]) /*||
                              !UnicodeIsPrint(udfName[index+1])*/) &&
                              udfName[index+1] != UNICODE_PERIOD)
                            index++;
                    }
                    // Add current char to either file name or ext.
                    if (writingExt) {
                        ext[extIndex] = current;
                        extIndex++;
                    } else {
                        dosName[dosIndex] = current;
                        dosIndex++;
                    }
                }
            }
        }
        // See if we are done with file name, either because we reached
        // the end of the file name length, or the final period.
        if (!writingExt && hasExt && (dosIndex == DOS_NAME_LEN ||
            index == lastPeriodIndex)) {
            // If so, and the name has an extension, start reading it.
            writingExt = TRUE;
            // Extension starts after last period.
            index = lastPeriodIndex;
        }
    }
    // Now handle CRC if needed.
    if (needsCRC) {
        // Add CRC to end of file name or at position 4.
        if (dosIndex >4) dosIndex = 4;
        valueCRC = Mode150 ? UDFUnicodeCksum150(udfName, udfLen) : UDFUnicodeCksum(udfName, udfLen);
        // Convert 16-bit CRC to hex characters.
        dosName[dosIndex] = hexChar[(valueCRC & 0xf000) >> 12];
        dosName[dosIndex+1] = hexChar[(valueCRC & 0x0f00) >> 8];
        dosName[dosIndex+2] = hexChar[(valueCRC & 0x00f0) >> 4];
        dosName[dosIndex+3] = hexChar[(valueCRC & 0x000f)];
        dosIndex+=4;
    }
    // Add extension, if any.
    if (extIndex != 0) {
        dosName[dosIndex] = UNICODE_PERIOD;
        dosIndex++;
        for (index = 0; index < extIndex; index++) {
            dosName[dosIndex] = ext[index];
            dosIndex++;
        }
    }
    DosName->Length = (uint16)dosIndex*sizeof(WCHAR);
    RtlUpcaseUnicodeString(DosName, DosName, FALSE);
} // end UDFDOSName200()

Referenced by UDFDOSName().

◆ UDFDOSName201()

void __fastcall UDFDOSName201	(	IN OUT PUNICODE_STRING	DosName,
		IN PUNICODE_STRING	UdfName,
		IN BOOLEAN	KeepIntact
	)

Definition at line 700 of file udf_info.cpp.

{
    PWCHAR dosName = DosName->Buffer;
    PWCHAR udfName = UdfName->Buffer;
    uint16 udfLen = UdfName->Length / sizeof(WCHAR);
 
    uint16 index, dosIndex = 0;
    //uint16 extIndex = 0;
    BOOLEAN needsCRC = FALSE, isParent = FALSE;
    //BOOLEAN hasExt = FALSE, writingExt = FALSE;
    uint16 valueCRC;
    WCHAR ext[DOS_EXT_LEN];
    WCHAR current;
 
    if(KeepIntact &&
       (udfLen <= 2) && (udfName[0] == UNICODE_PERIOD)) {
        isParent = TRUE;
        if((udfLen == 2) && (udfName[1] != UNICODE_PERIOD))
            isParent = FALSE;
    }
 
    #define DOS_CRC_LEN 4
    #define DOS_CRC_MODULUS 41
 
    int16 crcIndex;
    uint16 extLen;
    uint16 nameLen;
    uint16 charLen;
    int16 overlayBytes;
    int16 bytesLeft;
 
    /* Start at the end of the UDF file name and scan for a period */
    /* ('.'). This will be where the DOS extension starts (if */
    /* any). */
    index = udfLen;
    while (index-- > 0) {
        if (udfName[index] == '.')
            break;
    }
    if ((index < 0) || isParent) {
        /* There name was scanned to the beginning of the buffer */
        /* and no extension was found. */
        extLen = 0;
        nameLen = udfLen;
    } else {
        /* A DOS extension was found, process it first. */
        extLen = udfLen - index - 1;
        nameLen = index;
        dosIndex = 0;
        bytesLeft = DOS_EXT_LEN;
        while (++index < udfLen && bytesLeft > 0) {
            /* Get the current character and convert it to upper */
            /* case. */
            current = udfName[index];
            if (current == ' ') {
                /* If a space is found, a CRC must be appended to */
                /* the mangled file name. */
                needsCRC = TRUE;
            } else {
                /* Determine if this is a valid file name char and */
                /* calculate its corresponding BCS character byte */
                /* length (zero if the char is not legal or */
                /* undisplayable on this system). */
 
                charLen = (UDFIsIllegalChar(current)
                           /*|| !UnicodeIsPrint(current)*/) ? 0 : 1;
 
                /* If the char is larger than the available space */
                /* in the buffer, pretend it is undisplayable. */
                if (charLen > bytesLeft)
                    charLen = 0;
                if (charLen == 0) {
                /* Undisplayable or illegal characters are */
                /* substituted with an underscore ("_"), and */
                /* required a CRC code appended to the mangled */
                /* file name. */
                needsCRC = TRUE;
                charLen = 1;
                current = '_';
                /* Skip over any following undiplayable or */
                /* illegal chars. */
                while (index +1 <udfLen &&
                        (UDFIsIllegalChar(udfName[index+1])
                       /*|| !UnicodeIsPrint(udfName[index+1])*/))
                    index++;
                }
                /* Assign the resulting char to the next index in */
                /* the extension buffer and determine how many BCS */
                /* bytes are left. */
                ext[dosIndex++] = current;
                bytesLeft -= charLen;
            }
        }
        /* Save the number of Unicode characters in the extension */
        extLen = dosIndex;
        /* If the extension was too large, or it was zero length */
        /* (i.e. the name ended in a period), a CRC code must be */
        /* appended to the mangled name. */
        if (index < udfLen || extLen == 0)
            needsCRC = TRUE;
    }
    /* Now process the actual file name. */
    index = 0;
    dosIndex = 0;
    crcIndex = 0;
    overlayBytes = -1;
    bytesLeft = DOS_NAME_LEN;
    while (index < nameLen && bytesLeft > 0) {
        /* Get the current character and convert it to upper case. */
        current = udfName[index];
        if (current ==' ' || (current == '.' && !isParent) ) {
            /* Spaces and periods are just skipped, a CRC code */
            /* must be added to the mangled file name. */
            needsCRC = TRUE;
        } else {
            /* Determine if this is a valid file name char and */
            /* calculate its corresponding BCS character byte */
            /* length (zero if the char is not legal or */
            /* undisplayable on this system). */
 
            charLen = (UDFIsIllegalChar(current)
                       /*|| !UnicodeIsPrint(current)*/) ? 0 : 1;
 
            /* If the char is larger than the available space in */
            /* the buffer, pretend it is undisplayable. */
            if (charLen > bytesLeft)
                charLen = 0;
 
            if (charLen == 0) {
                /* Undisplayable or illegal characters are */
                /* substituted with an underscore ("_"), and */
                /* required a CRC code appended to the mangled */
                /* file name. */
                needsCRC = TRUE;
                charLen = 1;
                current = '_';
                /* Skip over any following undisplayable or illegal */
                /* chars. */
                while (index +1 <nameLen &&
                       (UDFIsIllegalChar(udfName[index+1])
                        /*|| !UnicodeIsPrint(udfName[index+1])*/))
                    index++;
                /* Terminate loop if at the end of the file name. */
                if (index >= nameLen)
                    break;
            }
            /* Assign the resulting char to the next index in the */
            /* file name buffer and determine how many BCS bytes */
            /* are left. */
            dosName[dosIndex++] = current;
            bytesLeft -= charLen;
            /* This figures out where the CRC code needs to start */
            /* in the file name buffer. */
            if (bytesLeft >= DOS_CRC_LEN) {
                /* If there is enough space left, just tack it */
                /* onto the end. */
                crcIndex = dosIndex;
            } else {
                /* If there is not enough space left, the CRC */
                /* must overlay a character already in the file */
                /* name buffer. Once this condition has been */
                /* met, the value will not change. */
                if (overlayBytes < 0) {
                    /* Determine the index and save the length of */
                    /* the BCS character that is overlayed. It */
                    /* is possible that the CRC might overlay */
                    /* half of a two-byte BCS character depending */
                    /* upon how the character boundaries line up. */
                    overlayBytes = (bytesLeft + charLen > DOS_CRC_LEN)?1 :0;
                    crcIndex = dosIndex - 1;
                }
            }
        }
        /* Advance to the next character. */
        index++;
    }
    /* If the scan did not reach the end of the file name, or the */
    /* length of the file name is zero, a CRC code is needed. */
    if (index < nameLen || index == 0)
        needsCRC = TRUE;
 
    /* If the name has illegal characters or and extension, it */
    /* is not a DOS device name. */
 
/*    if (needsCRC == FALSE && extLen == 0) { */
        /* If this is the name of a DOS device, a CRC code should */
        /* be appended to the file name.
        if (IsDeviceName(udfName, udfLen))
            needsCRC = TRUE;
    }*/
 
    /* Append the CRC code to the file name, if needed. */
    if (needsCRC) {
        /* Get the CRC value for the original Unicode string */
        valueCRC = UDFUnicodeCksum(udfName, udfLen);
 
        /* begin. */
        dosIndex = crcIndex;
        /* If the character being overlayed is a two-byte BCS */
        /* character, replace the first byte with an underscore. */
        if (overlayBytes > 0)
            dosName[dosIndex++] = '_';
        /* Append the encoded CRC value with delimiter. */
        dosName[dosIndex++] = '#';
        dosName[dosIndex++] =
            crcChar[valueCRC / (DOS_CRC_MODULUS * DOS_CRC_MODULUS)];
        valueCRC %= DOS_CRC_MODULUS * DOS_CRC_MODULUS;
            dosName[dosIndex++] =
        crcChar[valueCRC / DOS_CRC_MODULUS];
            valueCRC %= DOS_CRC_MODULUS;
        dosName[dosIndex++] = crcChar[valueCRC];
    }
    /* Append the extension, if any. */
    if (extLen > 0) {
        /* Tack on a period and each successive byte in the */
        /* extension buffer. */
        dosName[dosIndex++] = '.';
        for (index = 0; index < extLen; index++)
            dosName[dosIndex++] = ext[index];
    }
    /* Return the length of the resulting Unicode string. */
    DosName->Length = (uint16)dosIndex*sizeof(WCHAR);
    RtlUpcaseUnicodeString(DosName, DosName, FALSE);
 
} // end UDFDOSName201()

Referenced by UDFDOSName().

◆ UDFExtAllocDescToMapping()

PEXTENT_MAP UDFExtAllocDescToMapping	(	IN PVCB	Vcb,
		IN PLONG_AD	AllocDesc,
		IN uint32	AllocDescLength,
		IN uint32	SubCallCount,
		OUT PEXTENT_INFO	AllocLoc
	)

◆ UDFExtentOffsetToLba()

uint32 UDFExtentOffsetToLba	(	IN PVCB	Vcb,
		IN PEXTENT_AD	Extent,
		IN int64	Offset,
		OUT uint32 *	SectorOffset,
		OUT PSIZE_T	AvailLength,
		OUT uint32 *	Flags,
		OUT uint32 *	Index
	)

Definition at line 28 of file extent.cpp.

{
    uint32 j=0, l, d, BSh = Vcb->BlockSizeBits;
    uint32 Offs;
    uint32 i=0, BOffset; // block nums
 
    BOffset = (uint32)(Offset >> BSh);
    // scan extent table for suitable range (frag)
    ExtPrint(("ExtLen %x\n", Extent->extLength));
    while(i+(d = (l = (Extent->extLength & UDF_EXTENT_LENGTH_MASK)) >> BSh) <= BOffset) {
 
        if(!l) {
            if(Index) (*Index) = j-1;
            if(Flags) {
                Extent--;
                (*Flags) = (Extent->extLength >> 30);
            }
            return LBA_OUT_OF_EXTENT;
        }
        if(!d)
            break;
        i += d; //frag offset
        j++; // frag index
        Extent++;
    }
    BOffset -= i;
    Offs = (*((uint32*)&Offset)) - (i << BSh); // offset in frag
 
    if(SectorOffset)
        (*SectorOffset) = Offs & (Vcb->BlockSize-1);// offset in 1st Lba
    if(AvailLength)
        (*AvailLength) = l - Offs;// bytes to EO frag
    if(Flags)
        (*Flags) = (Extent->extLength >> 30);
    if(Index)
        (*Index) = j;
 
    ASSERT(((Extent->extLength >> 30) == EXTENT_NOT_RECORDED_NOT_ALLOCATED) || Extent->extLocation);
 
    return Extent->extLocation + BOffset;// 1st Lba
} // end UDFExtentOffsetToLba()

Referenced by UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFFlushFI(), UDFIndexDirectory(), UDFIsExtentCached(), UDFMarkAllocatedAsNotXXX(), UDFMarkAllocatedAsRecorded(), UDFMarkNotAllocatedAsAllocated(), UDFPackDirectory__(), UDFPadLastSector(), UDFReadExtent(), UDFReadExtentLocation(), UDFResizeExtent(), UDFReTagDirectory(), UDFWriteExtent(), and UDFZeroExtent().

◆ UDFExtentToMapping_()

PEXTENT_MAP __fastcall UDFExtentToMapping_ ( IN PEXTENT_AD Extent )

Definition at line 189 of file extent.cpp.

{
    PEXTENT_MAP Map;
 
#ifdef UDF_TRACK_EXTENT_TO_MAPPING
#define UDF_EXT_MAP_MULT 4
#else //UDF_TRACK_EXTENT_TO_MAPPING
#define UDF_EXT_MAP_MULT 2
#endif //UDF_TRACK_EXTENT_TO_MAPPING
 
    Map = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , UDF_EXT_MAP_MULT *
                                                       sizeof(EXTENT_MAP), MEM_EXTMAP_TAG);
    if(!Map) return NULL;
    RtlZeroMemory((int8*)(Map+1), sizeof(EXTENT_MAP));
    Map[0].extLength = Extent->extLength;
    Map[0].extLocation = Extent->extLocation;
#ifdef UDF_TRACK_EXTENT_TO_MAPPING
    Map[2].extLength = src;
    Map[2].extLocation = line;
#endif //UDF_TRACK_EXTENT_TO_MAPPING
    return Map;
} // end UDFExtentToMapping()

Referenced by UDFAllocFreeExtent_().

◆ UDFFindAnchor()

lba_t UDFFindAnchor ( PVCB Vcb )

Definition at line 1011 of file mount.cpp.

{
//    OSSTATUS    RC = STATUS_SUCCESS;
 
    uint16 ident;
    uint32 i;
    uint32 LastBlock;
    OSSTATUS status;
    int8* Buf = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
    BOOLEAN MRW_candidate;
    BOOLEAN IsMRW = (Vcb->MRWStatus != 0);
    if(!Buf)
        return 0;
 
    UDFPrint(("UDFFindAnchor\n"));
    // init probable locations...
    RtlZeroMemory(&(Vcb->Anchor), sizeof(Vcb->Anchor));
    Vcb->Anchor[0] = 256 + Vcb->FirstLBALastSes;
    Vcb->Anchor[1] = 512 + Vcb->FirstLBALastSes;
    Vcb->Anchor[2] = 256 + Vcb->TrackMap[Vcb->LastTrackNum].FirstLba;
    Vcb->Anchor[3] = 512 + Vcb->TrackMap[Vcb->LastTrackNum].FirstLba;
    Vcb->Anchor[4] = Vcb->LastLBA - 256;
    Vcb->Anchor[5] = Vcb->LastLBA - 256 + 1;
    Vcb->Anchor[6] = Vcb->LastLBA - 256 - 2;
    // vat locations
    Vcb->Anchor[7] = Vcb->LastLBA - 2;
    Vcb->Anchor[8] = Vcb->LastLBA;
    Vcb->Anchor[9] = Vcb->LastLBA - 512;
//    Vcb->Anchor[7] = Vcb->LastLBA - 256 - 7;
//    Vcb->Anchor[8] = Vcb->LastLBA - 512 - 2;
//    Vcb->Anchor[9] = Vcb->LastLBA - 512 - 7;
 
    LastBlock = 0;
    // ... and check them
    for (i=0; i<sizeof(Vcb->Anchor)/sizeof(int); i++) {
        if(Vcb->Anchor[i] > Vcb->LastLBA)
            Vcb->Anchor[i] = 0;
        MRW_candidate = FALSE;
        if(Vcb->Anchor[i]) {
            UDFPrint(("check Anchor %x\n", Vcb->Anchor[i]));
            if(!OS_SUCCESS(status = UDFReadTagged(Vcb,Buf,
                Vcb->Anchor[i], Vcb->Anchor[i], &ident))) {
 
                // Fucking MRW...
                if(!IsMRW && (i<2) &&
                   (Vcb->CompatFlags & UDF_VCB_IC_MRW_ADDR_PROBLEM)) {
                    if(OS_SUCCESS(status = UDFReadTagged(Vcb,Buf,
                        Vcb->Anchor[i]+MRW_DMA_OFFSET, Vcb->Anchor[i], &ident))) {
                        // do MRW workaround.....
                        UDFPrint(("UDF: looks like we have MRW....\n"));
                        MRW_candidate = TRUE;
                        goto MRW_workaround;
                    }
                }
 
                Vcb->Anchor[i] = 0;
                if(status == STATUS_NONEXISTENT_SECTOR) {
                    UDFPrint(("UDF: disk seems to be incomplete\n"));
                    break;
                }
            } else {
MRW_workaround:
                if((ident != TID_ANCHOR_VOL_DESC_PTR) && ((i<6) ||
                    (ident != TID_FILE_ENTRY && ident != TID_EXTENDED_FILE_ENTRY))) {
                    Vcb->Anchor[i] = 0;
                } else {
                    UDFPrint(("UDF: Found AVD at %x (point %d)\n",Vcb->Anchor[i], i));
                    if(!LastBlock)
                        LastBlock = Vcb->LastLBA;
                    if(MRW_candidate) {
                        UDFPrint(("UDF: looks like we _*really*_ have MRW....\n"));
                        IsMRW = TRUE;
                        ASSERT(Vcb->LastReadTrack == 1);
                        Vcb->TrackMap[Vcb->LastReadTrack].Flags |= TrackMap_FixMRWAddressing;
                        WCachePurgeAll__(&(Vcb->FastCache), Vcb);
                        UDFPrint(("UDF: MRW on non-MRW drive => ReadOnly"));
                        Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
 
                        UDFRegisterFsStructure(Vcb, Vcb->Anchor[i], Vcb->BlockSize);
 
                    }
                }
            }
        }
    }
 
    UDFPrint(("UDF: -----------------\nUDF: Last block %x\n",LastBlock));
    MyFreePool__(Buf);
    return LastBlock;
} // end UDFFindAnchor()

Referenced by UDFGetDiskInfoAndVerify().

◆ UDFFindDloc()

LONG UDFFindDloc	(	IN PVCB	Vcb,
		IN uint32	Lba
	)

Definition at line 1127 of file dirtree.cpp.

{
    PUDF_DATALOC_INDEX DlocList;
    uint32 l;
 
    if(!(DlocList = Vcb->DlocList) || !Lba) return (-1);
    // scan FE location cache
    l = Vcb->DlocCount;
    for(uint32 i=0; i<l; i++, DlocList++) {
        if(DlocList->Lba == Lba)
            return i;
    }
    return (-1);
} // end UDFFindDloc()

Referenced by UDFBuildFileEntry(), and UDFStoreDloc().

◆ UDFFindFile()

OSSTATUS UDFFindFile	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN BOOLEAN	NotDeleted,
		IN PUNICODE_STRING	Name,
		IN PUDF_FILE_INFO	DirInfo,
		IN OUT uint_di *	Index
	)

Definition at line 982 of file dirtree.cpp.

{
//    PDIR_INDEX_HDR hDirIndex = DirInfo->Dloc->DirIndex;
    UNICODE_STRING ShortName;
    WCHAR ShortNameBuffer[13];
    PDIR_INDEX_ITEM DirNdx;
    UDF_DIR_SCAN_CONTEXT ScanContext;
    uint_di j=(-1), k=(-1);
    HASH_ENTRY hashes;
    BOOLEAN CanBe8d3;
 
    UDFBuildHashEntry(Vcb, Name, &hashes, HASH_POSIX | HASH_ULFN);
 
    if((CanBe8d3 = UDFCanNameBeA8dot3(Name))) {
        ShortName.MaximumLength = 13 * sizeof(WCHAR);
        ShortName.Buffer = (PWCHAR)&ShortNameBuffer;
    }
 
    if(!UDFDirIndexInitScan(DirInfo, &ScanContext, (*Index)))
        return STATUS_OBJECT_NAME_NOT_FOUND;
 
    if(!IgnoreCase && !CanBe8d3) {
        // perform case sensetive sequential directory scan
 
        while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
            if( (DirNdx->hashes.hPosix == hashes.hPosix) &&
                 DirNdx->FName.Buffer &&
                (!RtlCompareUnicodeString(&(DirNdx->FName), Name, FALSE)) &&
               ( (!UDFIsDeleted(DirNdx)) || (!NotDeleted) ) ) {
                (*Index) = ScanContext.i;
                return STATUS_SUCCESS;
            }
        }
        return STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    if(hashes.hPosix == hashes.hLfn) {
 
        while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
            if(!DirNdx->FName.Buffer ||
               (NotDeleted && UDFIsDeleted(DirNdx)) )
                continue;
            if( (DirNdx->hashes.hLfn == hashes.hLfn) &&
                (!RtlCompareUnicodeString(&(DirNdx->FName), Name, IgnoreCase)) ) {
                (*Index) = ScanContext.i;
                return STATUS_SUCCESS;
            } else
            if( CanBe8d3 &&
                !(DirNdx->FI_Flags & UDF_FI_FLAG_DOS) &&
                (DirNdx->hashes.hDos == hashes.hLfn) &&
                (k == (uint_di)(-1))) {
                UDFDOSName(Vcb, &ShortName, &(DirNdx->FName), ScanContext.i < 2) ;
                if(!RtlCompareUnicodeString(&ShortName, Name, IgnoreCase))
                    k = ScanContext.i;
            }
        }
 
    } else {
 
        while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
            // perform sequential directory scan
            if(!DirNdx->FName.Buffer ||
               (NotDeleted && UDFIsDeleted(DirNdx)) )
                continue;
            if( (DirNdx->hashes.hPosix == hashes.hPosix) &&
                (!RtlCompareUnicodeString(&(DirNdx->FName), Name, FALSE)) ) {
                (*Index) = ScanContext.i;
                return STATUS_SUCCESS;
            } else
            if( (DirNdx->hashes.hLfn == hashes.hLfn) &&
                (j == (uint_di)(-1)) &&
                (!RtlCompareUnicodeString(&(DirNdx->FName), Name, IgnoreCase)) ) {
                j = ScanContext.i;
            } else
            if( CanBe8d3 &&
                !(DirNdx->FI_Flags & UDF_FI_FLAG_DOS) &&
                (DirNdx->hashes.hDos == hashes.hLfn) &&
                (k == (uint_di)(-1))) {
                UDFDOSName(Vcb, &ShortName, &(DirNdx->FName), ScanContext.i < 2 );
                if(!RtlCompareUnicodeString(&ShortName, Name, IgnoreCase)) {
                    k = ScanContext.i;
                }
            }
        }
    }
 
    if(j != (uint_di)(-1)) {
        (*Index) = j;
        return STATUS_SUCCESS;
    } else
    if(k != (uint_di)(-1)) {
        (*Index) = k;
        return STATUS_SUCCESS;
    }
 
    return STATUS_OBJECT_NAME_NOT_FOUND;
 
} // end UDFFindFile()

Referenced by UDFCreateFile__(), UDFFindFile__(), UDFHardLinkFile__(), UDFOpenFile__(), and UDFRenameMoveFile__().

◆ UDFFindFile__()

__inline OSSTATUS UDFFindFile__	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN PUNICODE_STRING	Name,
		IN PUDF_FILE_INFO	DirInfo
	)

Definition at line 114 of file udf_info.h.

{
    if(!DirInfo->Dloc->DirIndex)
        return STATUS_NOT_A_DIRECTORY;
    uint_di i=0;
    return UDFFindFile(Vcb, IgnoreCase, TRUE, Name, DirInfo, &i);
}

Referenced by UDFCommonCreate(), and UDFRename().

◆ UDFFindFreeDloc()

LONG UDFFindFreeDloc	(	IN PVCB	Vcb,
		IN uint32	Lba
	)

Definition at line 1171 of file dirtree.cpp.

{
    PUDF_DATALOC_INDEX DlocList;
    uint32 l;
 
    if(!Vcb->DlocList) {
        // init FE location cache
        if(!(Vcb->DlocList = (PUDF_DATALOC_INDEX)MyAllocatePoolTag__(NonPagedPool, sizeof(UDF_DATALOC_INDEX)*DLOC_LIST_GRANULARITY, MEM_DLOC_NDX_TAG)))
            return (-1);
        RtlZeroMemory(Vcb->DlocList, DLOC_LIST_GRANULARITY*sizeof(UDF_DATALOC_INDEX));
        Vcb->DlocCount = DLOC_LIST_GRANULARITY;
    }
    // scan for free entry
    DlocList = Vcb->DlocList;
    l = Vcb->DlocCount;
    for(uint32 i=0; i<l; i++, DlocList++) {
        if(!DlocList->Dloc)
            return i;
    }
    // alloc some free entries
    if(!MyReallocPool__((int8*)(Vcb->DlocList), Vcb->DlocCount*sizeof(UDF_DATALOC_INDEX),
                     (int8**)&(Vcb->DlocList), (Vcb->DlocCount+DLOC_LIST_GRANULARITY)*sizeof(UDF_DATALOC_INDEX))) {
        return (-1);
    }
    RtlZeroMemory(&(Vcb->DlocList[Vcb->DlocCount]), DLOC_LIST_GRANULARITY*sizeof(UDF_DATALOC_INDEX));
    Vcb->DlocCount += DLOC_LIST_GRANULARITY;
    return (Vcb->DlocCount - DLOC_LIST_GRANULARITY);
} // end UDFFindFreeDloc()

Referenced by UDFStoreDloc().

◆ UDFFindLastFileSet()

OSSTATUS UDFFindLastFileSet	(	IN PVCB	Vcb,
		IN lb_addr *	Addr,
		IN OUT PFILE_SET_DESC	FileSetDesc
	)

Definition at line 2739 of file mount.cpp.

{
    OSSTATUS status;
    uint32 relLocExt = Addr->logicalBlockNum;
    uint32 locExt = UDFPartLbaToPhys(Vcb, Addr);
    uint16 Ident;
    uint32 relPrevExt, prevExt;
 
    relPrevExt, prevExt = NULL;
    FileSetDesc->nextExt.extLength = 1;  // ;)
    // walk through FileSet chain
    // we've just pre-init'd extent length to read 1st FileSet
    while(FileSetDesc->nextExt.extLength) {
        status = UDFReadTagged(Vcb, (int8*)FileSetDesc, locExt, relLocExt, &Ident);
        if(!OS_SUCCESS(status)) {
            FileSetDesc->nextExt.extLength = 0;
            return status;
        }
        UDFRegisterFsStructure(Vcb, locExt, Vcb->BlockSize);
        if((locExt == LBA_OUT_OF_EXTENT) || (Ident != TID_FILE_SET_DESC)) {
            // try to read previous FileSet
            if(!prevExt) return STATUS_UNRECOGNIZED_VOLUME;
            status = UDFReadTagged(Vcb, (int8*)FileSetDesc, prevExt, relLocExt, &Ident);
            if(OS_SUCCESS(status)) {
                UDFRegisterFsStructure(Vcb, prevExt, Vcb->BlockSize);
            }
            return status;
        }
        prevExt = locExt;
        relPrevExt = relLocExt;
        locExt = UDFPartLbaToPhys(Vcb, &(FileSetDesc->nextExt.extLocation));
    }
    return STATUS_SUCCESS;
} // end UDFFindLastFileSet()

Referenced by UDFGetDiskInfoAndVerify().

◆ UDFFindMinSuitableExtent()

SIZE_T UDFFindMinSuitableExtent	(	IN PVCB	Vcb,
		IN uint32	Length,
		IN uint32	SearchStart,
		IN uint32	SearchLim,
		OUT uint32 *	MaxExtLen,
		IN uint8	AllocFlags
	)

Definition at line 556 of file alloc.cpp.

{
    SIZE_T i, len;
    uint32* cur;
    SIZE_T best_lba=0;
    SIZE_T best_len=0;
    SIZE_T max_lba=0;
    SIZE_T max_len=0;
    BOOLEAN align = FALSE;
    SIZE_T PS = Vcb->WriteBlockSize >> Vcb->BlockSizeBits;
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
 
    // we'll try to allocate packet-aligned block at first
    if(!(Length & (PS-1)) && !Vcb->CDR_Mode && (Length >= PS*2))
        align = TRUE;
    if(AllocFlags & EXTENT_FLAG_ALLOC_SEQUENTIAL)
        align = TRUE;
    if(Length > (uint32)(UDF_MAX_EXTENT_LENGTH >> Vcb->BlockSizeBits))
        Length = (UDF_MAX_EXTENT_LENGTH >> Vcb->BlockSizeBits);
    // align Length according to _Logical_ block size & convert it to BCount
    i = (1<<Vcb->LB2B_Bits)-1;
    Length = (Length+i) & ~i;
    cur = (uint32*)(Vcb->FSBM_Bitmap);
 
retry_no_align:
 
    i=SearchStart;
    // scan Bitmap
    while(i<SearchLim) {
        ASSERT(i <= SearchLim);
        if(align) {
            i = (i+PS-1) & ~(PS-1);
            ASSERT(i <= SearchLim);
            if(i >= SearchLim)
                break;
        }
        len = UDFGetBitmapLen(cur, i, SearchLim);
        if(UDFGetFreeBit(cur, i)) { // is the extent found free or used ?
            // wow! it is free!
            if(len >= Length) {
                // minimize extent length
                if(!best_len || (best_len > len)) {
                    best_lba = i;
                    best_len = len;
                }
                if(len == Length)
                    break;
            } else {
                // remember max extent
                if(max_len < len) {
                    max_lba = i;
                    max_len = len;
                }
            }
            // if this is CD-R mode, we should not think about fragmentation
            // due to CD-R nature file will be fragmented in any case
            if(Vcb->CDR_Mode) break;
        }
        i += len;
    }
    // if we can't find suitable Packet-size aligned block,
    // retry without any alignment requirements
    if(!best_len && align) {
        align = FALSE;
        goto retry_no_align;
    }
    if(best_len) {
        // minimal suitable block
        (*MaxExtLen) = best_len;
        return best_lba;
    }
    // maximal available
    (*MaxExtLen) = max_len;
    return max_lba;
} // end UDFFindMinSuitableExtent()

Referenced by UDFAllocFreeExtent_().

◆ UDFFindVRS()

uint32 UDFFindVRS ( PVCB Vcb )

Definition at line 1108 of file mount.cpp.

{
    VolStructDesc  *vsd = NULL;
    uint32       offset;
    uint32       retStat = 0;
    uint32       BeginOffset = Vcb->FirstLBA;
    OSSTATUS     RC;
    int8*        buffer = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
    SIZE_T       ReadBytes;
 
    if(!buffer) return 0;
    // Relative to First LBA in Last Session
    offset = Vcb->FirstLBA + 0x10;
 
    UDFPrint(("UDFFindVRS:\n"));
 
    // Process the sequence (if applicable)
    for (;(offset-BeginOffset <=0x20); offset ++) {
        // Read a block
        RC = UDFReadSectors(Vcb, FALSE, offset, 1, FALSE, buffer, &ReadBytes);
        if(!OS_SUCCESS(RC)) continue;
 
        // Look for ISO descriptors
        vsd = (VolStructDesc *)(buffer);
 
        if(vsd->stdIdent[0]) {
            if(!strncmp((int8*)(&vsd->stdIdent), STD_ID_CD001, STD_ID_LEN))
            {
                retStat |= VRS_ISO9660_FOUND;
                switch (vsd->structType)
                {
                    case 0:
                        UDFPrint(("UDF: ISO9660 Boot Record found\n"));
                        break;
                    case 1:
                        UDFPrint(("UDF: ISO9660 Primary Volume Descriptor found\n"));
                        break;
                    case 2:
                        UDFPrint(("UDF: ISO9660 Supplementary Volume Descriptor found\n"));
                        break;
                    case 3:
                        UDFPrint(("UDF: ISO9660 Volume Partition Descriptor found\n"));
                        break;
                    case 255:
                        UDFPrint(("UDF: ISO9660 Volume Descriptor Set Terminator found\n"));
                        break;
                    default:
                        UDFPrint(("UDF: ISO9660 VRS (%u) found\n", vsd->structType));
                        break;
                }
            }
            else if(!strncmp((int8*)(&vsd->stdIdent), STD_ID_BEA01, STD_ID_LEN))
            {
                UDFPrint(("UDF: BEA01 Found\n"));
            }
            else if(!strncmp((int8*)(&vsd->stdIdent), STD_ID_TEA01, STD_ID_LEN))
            {
                UDFPrint(("UDF: TEA01 Found\n"));
                break;
            }
            else if(!strncmp((int8*)(&vsd->stdIdent), STD_ID_NSR02, STD_ID_LEN))
            {
                retStat |= VRS_NSR02_FOUND;
                UDFPrint(("UDF: NSR02 Found\n"));
                break;
            }
            else if(!strncmp((int8*)(&vsd->stdIdent), STD_ID_NSR03, STD_ID_LEN))
            {
                retStat |= VRS_NSR03_FOUND;
                UDFPrint(("UDF: NSR03 Found\n"));
                break;
            }
        }
    }
 
    MyFreePool__(buffer);
 
    return retStat;
} // end UDFFindVRS()

Referenced by UDFGetDiskInfoAndVerify().

◆ UDFFlushAllCachedAllocations()

OSSTATUS UDFFlushAllCachedAllocations	(	IN PVCB	Vcb,
		IN uint32	AllocClass
	)

Definition at line 1508 of file extent.cpp.

{
    PUDF_ALLOCATION_CACHE_ITEM AllocCache;
    uint32 i, lim;
    OSSTATUS status;
 
    UDFPrint(("Flush AllocationCache\n"));
    UDFAcquireResourceExclusive(&(Vcb->PreallocResource),TRUE);
 
    status = UDFInitAllocationCache(Vcb, AllocClass, &AllocCache, &lim, FALSE);
    if(!OS_SUCCESS(status)) {
        UDFReleaseResource(&(Vcb->PreallocResource));
        return status;
    }
 
    for(i=0; i<lim; i++) {
        if(AllocCache[i].ParentLocation != LBA_NOT_ALLOCATED) {
            switch(AllocClass) {
            case UDF_PREALLOC_CLASS_FE:
                UDFDiscardFESpace(Vcb, AllocCache[i].Ext.Mapping, AllocCache[i].Items);
                break;
            case UDF_PREALLOC_CLASS_DIR:
                UDFMarkSpaceAsXXX(Vcb, 0, AllocCache[i].Ext.Mapping, AS_DISCARDED);
                break;
            }
        }
    }
    MyFreePool__(AllocCache);
    switch(AllocClass) {
    case UDF_PREALLOC_CLASS_FE:
        Vcb->FEChargeCache = NULL;
        Vcb->FEChargeCacheMaxSize = 0;
        break;
    case UDF_PREALLOC_CLASS_DIR:
        Vcb->PreallocCache = NULL;
        Vcb->PreallocCacheMaxSize = 0;
        break;
    }
    UDFReleaseResource(&(Vcb->PreallocResource));
    //
    return STATUS_SUCCESS;
} // end UDFFlushAllCachedAllocations()

Referenced by UDFEjectReqWaiter(), and UDFUmount__().

◆ UDFFlushFE()

OSSTATUS UDFFlushFE	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint32	PartNum
	)

Definition at line 3864 of file udf_info.cpp.

{
    int8* NewAllocDescs;
    OSSTATUS status;
    SIZE_T WrittenBytes;
    uint16 AllocMode;
    uint32 lba;
 
    AllocMode = ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
#ifdef UDF_DBG
/*    if(UDFIsADirectory(FileInfo) && (UDFGetFileSize(FileInfo) < 0x28) &&
       !UDFIsDeleted(UDFDirIndex(DirInfo->Dloc->DirIndex, FileInfo->Index)) ) {
        BrutePoint();
    }*/
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(FileInfo->Dloc->FELoc.Offset) {
        BrutePoint();
    }
    if(FileInfo->Dloc->AllocLoc.Mapping) {
        ASSERT(AllocMode != ICB_FLAG_AD_IN_ICB);
    }
#endif // UDF_DBG
retry_flush_FE:
    UDFPrint(("  FlushFE: %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
#ifndef UDF_READ_ONLY_BUILD
    UDFReTagDirectory(Vcb, FileInfo);
    if(FileInfo->Dloc->DataLoc.Modified ||
       FileInfo->Dloc->AllocLoc.Modified) {
        ASSERT(PartNum != (uint32)(-1));
        // prepare new AllocDescs for flushing...
        if(!OS_SUCCESS(status = UDFBuildAllocDescs(Vcb, PartNum, FileInfo, &NewAllocDescs))) {
            UDFPrint(("  FlushFE: UDFBuildAllocDescs() faliled (%x)\n", status));
            if(NewAllocDescs)
                MyFreePool__(NewAllocDescs);
            return status;
        }
#ifdef UDF_DBG
        if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
            ASSERT(UDFGetFileSize(FileInfo) <= UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping));
        } else {
            ASSERT(((UDFGetFileSize(FileInfo)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)) ==
                   ((UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)));
        }
        AllocMode = ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
#endif // UDF_DBG
        // initiate update of lengthAllocDescs
        FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
        if(NewAllocDescs) {
            ASSERT(AllocMode != ICB_FLAG_AD_IN_ICB);
            status = UDFPadLastSector(Vcb, &(FileInfo->Dloc->AllocLoc));
            // ... and flush it
            status = UDFWriteExtent(Vcb, &(FileInfo->Dloc->AllocLoc), 0, (uint32)(FileInfo->Dloc->AllocLoc.Length), FALSE, NewAllocDescs, &WrittenBytes);
            MyFreePool__(NewAllocDescs);
            if(!OS_SUCCESS(status)) {
                UDFPrint(("  FlushFE: UDFWriteExtent() faliled (%x)\n", status));
                return status;
            }
#ifdef UDF_DBG
        } else {
            ASSERT(AllocMode == ICB_FLAG_AD_IN_ICB);
#endif // UDF_DBG
        }
        FileInfo->Dloc->DataLoc.Modified = FALSE;
        FileInfo->Dloc->AllocLoc.Modified = FALSE;
    } else {
#if defined(UDF_DBG) && !defined(UDF_CHECK_UTIL)
        if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
            ASSERT(UDFGetFileSize(FileInfo) <= UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping));
        } else {
            ASSERT(((UDFGetFileSize(FileInfo)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)) ==
                   ((UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)));
        }
#endif // UDF_DBG
    }
/*    if(FileInfo->Fcb &&
       ((FileInfo->Dloc->FELoc.Mapping[0].extLocation > Vcb->LastLBA) ||
        UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) ) {
        BrutePoint();
    }*/
/*    if(FileInfo->Dloc->FELoc.Mapping[0].extLocation) {
        ASSERT( FileInfo->Dloc->FileEntry->tagLocation ==
               (FileInfo->Dloc->FELoc.Mapping[0].extLocation - 0x580));
    }*/
    if((FileInfo->Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ||
        FileInfo->Dloc->FELoc.Modified) {
        ASSERT(PartNum != (uint32)(-1));
        ASSERT(!PartNum);
        if(PartNum == (uint32)(-1) || PartNum == (uint32)(-2)) {
            UDFPrint(("  bad PartNum: %d\n", PartNum));
        }
        // update lengthAllocDescs in FE
        UDFSetAllocDescLen(Vcb, FileInfo);
/*        ASSERT( FileInfo->Dloc->FileEntry->tagLocation ==
               (FileInfo->Dloc->FELoc.Mapping[0].extLocation - 0x580));*/
        // flush FileEntry
 
        // if FE is located in remapped block, place it to reliable space
        lba = FileInfo->Dloc->FELoc.Mapping[0].extLocation;
        if(Vcb->BSBM_Bitmap) {
            if(UDFGetBadBit((uint32*)(Vcb->BSBM_Bitmap), lba)) {
                AdPrint(("  bad block under FE @%x\n", lba));
                goto relocate_FE;
            }
        }
 
        AdPrint(("  setup tag: @%x\n", lba));
        ASSERT( lba );
        UDFSetUpTag(Vcb, FileInfo->Dloc->FileEntry, (uint16)(FileInfo->Dloc->FileEntryLen),
                  UDFPhysLbaToPart(Vcb, PartNum, lba));
        status = UDFWriteExtent(Vcb, &(FileInfo->Dloc->FELoc), 0,
                  (uint32)(FileInfo->Dloc->FELoc.Length), FALSE,
                  (int8*)(FileInfo->Dloc->FileEntry), &WrittenBytes);
        if(!OS_SUCCESS(status)) {
            UDFPrint(("  FlushFE: UDFWriteExtent(2) faliled (%x)\n", status));
            if(status == STATUS_DEVICE_DATA_ERROR) {
relocate_FE:
                UDFPrint(("  try to relocate\n"));
 
                EXTENT_INFO _FEExtInfo;
                // calculate the length required
 
                // allocate block for FE
                if(OS_SUCCESS(UDFAllocateFESpace(Vcb, FileInfo->ParentFile, PartNum, &_FEExtInfo, (uint32)(FileInfo->Dloc->FELoc.Length)) )) {
                    UDFPrint(("  relocate %x -> %x\n",
                        lba,
                        _FEExtInfo.Mapping[0].extLocation));
 
                    UDFMarkSpaceAsXXX(Vcb, 0, FileInfo->Dloc->FELoc.Mapping, AS_BAD);
 
                    UDFRelocateDloc(Vcb, FileInfo->Dloc, _FEExtInfo.Mapping[0].extLocation);
                    MyFreePool__(FileInfo->Dloc->FELoc.Mapping);
                    FileInfo->Dloc->FELoc.Mapping = _FEExtInfo.Mapping;
 
                    FileInfo->Dloc->FELoc.Modified = TRUE;
                    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
 
                    AllocMode = ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
                    if(AllocMode == ICB_FLAG_AD_IN_ICB) {
                        UDFPrint(("  IN-ICB data lost\n"));
                        FileInfo->Dloc->DataLoc.Mapping[0].extLocation = _FEExtInfo.Mapping[0].extLocation;
                        FileInfo->Dloc->DataLoc.Modified = TRUE;
                    } else {
                        FileInfo->Dloc->AllocLoc.Mapping[0].extLocation = _FEExtInfo.Mapping[0].extLocation;
                        FileInfo->Dloc->AllocLoc.Modified = TRUE;
                    }
 
                    if(FileInfo->Index >= 2) {
                        PDIR_INDEX_ITEM DirNdx;
                        DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index);
                        if(DirNdx) {
                            UDFPrint(("  update reference in FI\n"));
                            DirNdx->FileEntryLoc.logicalBlockNum =
                                FileInfo->FileIdent->icb.extLocation.logicalBlockNum =
                                UDFPhysLbaToPart(Vcb, PartNum, _FEExtInfo.Mapping[0].extLocation);
                            DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
                        }
                    }
                    // this will update
                    UDFPrint(("  retry flush...\n"));
                    goto retry_flush_FE;
                }
            }
            BrutePoint();
            return status;
        }
        FileInfo->Dloc->FE_Flags &= ~UDF_FE_FLAG_FE_MODIFIED;
        FileInfo->Dloc->FELoc.Modified = FALSE;
    } else {
        ASSERT((FileInfo->Dloc->FileEntry->descVersion == 2) ||
               (FileInfo->Dloc->FileEntry->descVersion == 3));
    }
#endif //UDF_READ_ONLY_BUILD
#ifdef UDF_DBG
    if(FileInfo->Dloc->AllocLoc.Mapping) {
        ASSERT(AllocMode != ICB_FLAG_AD_IN_ICB);
    } else {
        ASSERT(AllocMode == ICB_FLAG_AD_IN_ICB);
    }
#endif // UDF_DBG
    return STATUS_SUCCESS;
} // end UDFFlushFE()

Referenced by UDFCloseFile__(), UDFCreateFile__(), and UDFFlushFile__().

◆ UDFFlushFESpace()

void UDFFlushFESpace	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc,
		IN BOOLEAN	Discard = `FLUSH_FE_KEEP`
	)

Definition at line 1776 of file extent.cpp.

{
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
    PEXTENT_MAP Mapping;
    uint32 lim;
 
    if(!(Mapping = Dloc->DirIndex->FECharge.Mapping))
        return;
 
    lim = (Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR) ? Vcb->FEChargeSDir : Vcb->FECharge;
 
    if(!Discard) {
        // cache it!
        if(OS_SUCCESS(UDFStoreCachedAllocation(Vcb,
                                 Dloc->FELoc.Mapping[0].extLocation,
                                 &Dloc->DirIndex->FECharge, lim, UDF_PREALLOC_CLASS_FE))) {
            Dloc->DirIndex->FECharge.Mapping = NULL;
            return;
        }
    }
    Dloc->DirIndex->FECharge.Mapping = NULL;
    UDFDiscardFESpace(Vcb, Mapping, lim);
#else // UDF_FE_ALLOCATION_CHARGE
    ASSERT(!Dloc->DirIndex->FECharge.Mapping);
    return;
#endif // UDF_FE_ALLOCATION_CHARGE
} // end UDFFlushFESpace()

Referenced by UDFCleanUpFile__(), UDFCloseFile__(), UDFFlushFile__(), and UDFUnlinkFile__().

◆ UDFFlushFI()

OSSTATUS UDFFlushFI	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN uint32	PartNum
	)

Definition at line 4051 of file udf_info.cpp.

{
    PUDF_FILE_INFO DirInfo = FileInfo->ParentFile;
    PDIR_INDEX_ITEM DirNdx;
    OSSTATUS status;
    SIZE_T WrittenBytes;
    // use WrittenBytes variable to store LBA of FI to be recorded
    #define lba   WrittenBytes
 
//    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    // some files has no FI
    if(!DirInfo || UDFIsAStreamDir(FileInfo))
        return STATUS_SUCCESS;
    DirNdx = UDFDirIndex(DirInfo->Dloc->DirIndex, FileInfo->Index);
//    ASSERT(FileInfo->FileIdent->lengthFileIdent < 0x80);
#ifdef UDF_DBG
    if(DirNdx->FileCharacteristics & FILE_DELETED) {
        ASSERT(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED);
    }
#endif // UDF_DBG
    UDFPrint(("  FlushFI: offs %x\n", (ULONG)(DirNdx->Offset)));
#ifndef UDF_READ_ONLY_BUILD
    if((DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) {
        // flush FileIdent
        ASSERT(PartNum != (uint32)(-1));
        FileInfo->FileIdent->fileCharacteristics = DirNdx->FileCharacteristics;
        lba = UDFExtentOffsetToLba(Vcb, DirInfo->Dloc->DataLoc.Mapping,
                                        DirNdx->Offset, NULL, NULL, NULL, NULL);
        AdPrint(("  FI lba %x\n", lba));
        // check if requested Offset is allocated
        if(lba == (uint32)LBA_OUT_OF_EXTENT) {
            // write 1 byte
            if(!OS_SUCCESS(status = UDFWriteFile__(Vcb, DirInfo, DirNdx->Offset, 1, FALSE, (int8*)(FileInfo->FileIdent), &WrittenBytes) )) {
                BrutePoint();
                return status;
            }
            lba = UDFExtentOffsetToLba(Vcb, DirInfo->Dloc->DataLoc.Mapping,
                                            DirNdx->Offset, NULL, NULL, NULL, NULL);
            AdPrint(("  allocated FI lba %x\n", lba));
            // check if requested Offset is allocated
            if(lba == (uint32)LBA_OUT_OF_EXTENT) {
                BrutePoint();
                return STATUS_UNSUCCESSFUL;
            }
        }
        // init structure
        UDFSetUpTag(Vcb, &(FileInfo->FileIdent->descTag), (uint16)(FileInfo->FileIdentLen),
                  UDFPhysLbaToPart(Vcb, PartNum, lba));
        // record data
        if(!OS_SUCCESS(status = UDFWriteFile__(Vcb, DirInfo, DirNdx->Offset, FileInfo->FileIdentLen, FALSE, (int8*)(FileInfo->FileIdent), &WrittenBytes) )) {
            BrutePoint();
            return status;
        }
        DirNdx->FI_Flags &= ~UDF_FI_FLAG_FI_MODIFIED;
    }
#endif //UDF_READ_ONLY_BUILD
    return STATUS_SUCCESS;
} // end UDFFlushFI()

Referenced by UDFCloseFile__(), UDFCreateFile__(), UDFFlushFile__(), and UDFRenameMoveFile__().

◆ UDFFlushFile__()

OSSTATUS UDFFlushFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN ULONG	FlushFlags = `0`
	)

Definition at line 4119 of file udf_info.cpp.

{
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo) return STATUS_SUCCESS;
    OSSTATUS status;
    uint32 PartNum;
 
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(PartNum == (uint32)-1) {
        UDFPrint(("  Is DELETED ?\n"));
        if(FileInfo->ParentFile) {
            PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->ParentFile->Dloc->FELoc.Mapping[0].extLocation);
        } else {
            BrutePoint();
        }
    }
#ifdef UDF_CHECK_DISK_ALLOCATION
    if( FileInfo->Fcb &&
        UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), FileInfo->Dloc->FELoc.Mapping[0].extLocation)) {
 
        if(UDFIsAStreamDir(FileInfo)) {
            if(!UDFIsSDirDeleted(FileInfo)) {
                UDFPrint(("  Not DELETED SDir\n"));
                BrutePoint();
            }
            ASSERT(!FileInfo->Dloc->FELoc.Modified);
        } else
        if(!FileInfo->FileIdent ||
           !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED)) {
            if(!FileInfo->FileIdent)
                AdPrint(("  No FileIdent\n"));
            if(FileInfo->FileIdent &&
               !(FileInfo->FileIdent->fileCharacteristics & FILE_DELETED))
                AdPrint(("  Not DELETED\n"));
            AdPrint(("Flushing to Discarded block %x\n", FileInfo->Dloc->FELoc.Mapping[0].extLocation));
            BrutePoint();
        }
    }
#endif // UDF_CHECK_DISK_ALLOCATION
 
    // flush FE and pre-allocation charge for directories
    if(FileInfo->Dloc &&
       FileInfo->Dloc->DirIndex) {
        // if Lite Flush is used, keep preallocations
        if(!(FlushFlags & UDF_FLUSH_FLAGS_LITE)) {
full_flush:
            UDFFlushFESpace(Vcb, FileInfo->Dloc);
            if(FileInfo->Dloc->DataLoc.Flags & EXTENT_FLAG_PREALLOCATED) {
                FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_CUT_PREALLOCATED;
                status = UDFResizeExtent(Vcb, PartNum, UDFGetFileSize(FileInfo), FALSE, &(FileInfo->Dloc->DataLoc));
                FileInfo->Dloc->DataLoc.Flags &= ~(EXTENT_FLAG_PREALLOCATED | EXTENT_FLAG_CUT_PREALLOCATED);
                if(OS_SUCCESS(status)) {
                    AdPrint(("Dir pre-alloc truncated (Flush)\n"));
                    FileInfo->Dloc->DataLoc.Modified = TRUE;
                }
            }
        }
    }
    // flush FE
    if(!OS_SUCCESS(status = UDFFlushFE(Vcb, FileInfo, PartNum))) {
        UDFPrint(("Error flushing FE\n"));
        BrutePoint();
        if(FlushFlags & UDF_FLUSH_FLAGS_LITE) {
            UDFPrint(("  flush pre-alloc\n"));
            FlushFlags &= ~UDF_FLUSH_FLAGS_LITE;
            goto full_flush;
        }
        if(FileInfo->Index >= 2) {
            PDIR_INDEX_ITEM DirNdx;
            DirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo), FileInfo->Index);
            if(DirNdx) {
                UDFPrint(("Recovery: mark as deleted & flush FI\n"));
                DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
                DirNdx->FileCharacteristics |= FILE_DELETED;
                FileInfo->FileIdent->fileCharacteristics |= FILE_DELETED;
                UDFFlushFI(Vcb, FileInfo, PartNum);
            }
        }
        return status;
    }
    if(!OS_SUCCESS(status = UDFFlushFI(Vcb, FileInfo, PartNum)))
        return status;
 
    ASSERT((FileInfo->Dloc->FileEntry->descVersion == 2) ||
           (FileInfo->Dloc->FileEntry->descVersion == 3));
 
    return STATUS_SUCCESS;
} // end UDFFlushFile__()

Referenced by UDFCleanUpFcbChain(), UDFCommonCleanup(), UDFCommonCreate(), UDFFlushADirectory(), UDFFlushAFile(), UDFRecordVAT(), UDFRenameMoveFile__(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), UDFUpdateNonAllocated(), and UDFWriteSecurity().

◆ UDFFreeDloc()

void UDFFreeDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1353 of file dirtree.cpp.

{
    LONG i;
 
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
 
    if((i = UDFFindDlocInMem(Vcb, Dloc)) != (-1)) {
        ASSERT(Vcb->DlocList);
        RtlZeroMemory(&(Vcb->DlocList[i]), sizeof(UDF_DATALOC_INDEX));
    }
    UDFReleaseResource(&(Vcb->DlocResource));
    MyFreePool__(Dloc);
} // end UDFFreeDloc()

Referenced by UDFCleanUpFile__().

◆ UDFFreeFESpace()

void UDFFreeFESpace	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN PEXTENT_INFO	FEExtInfo
	)

Definition at line 1725 of file extent.cpp.

{
#ifdef UDF_FE_ALLOCATION_CHARGE // UDF_FE_ALLOCATION_CHARGE
    PEXTENT_INFO Ext;
    uint32 i, lim, j=-1;
    uint32 Lba;
 
    // check if the DirInfo we are called with is a Directory
    // (it can be a file with SDir)
    if(DirInfo && DirInfo->Dloc->DirIndex &&
       (Ext = &(DirInfo->Dloc->DirIndex->FECharge))->Mapping) {
        if(!FEExtInfo->Mapping)
            return;
        Lba = FEExtInfo->Mapping[0].extLocation;
 
        lim = (DirInfo->Dloc->FE_Flags & UDF_FE_FLAG_IS_SDIR) ? Vcb->FEChargeSDir : Vcb->FECharge;
        for(i=0;i<lim;i++) {
            if(Ext->Mapping[i].extLocation == Lba) {
                ASSERT(!(Ext->Mapping[i].extLength >> 30));
                Ext->Mapping[i].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                goto clean_caller;
            }
            if(!Ext->Mapping[i].extLocation) {
                j = i;
            }
        }
        if(j != (ULONG)-1) {
            i = j;
            Ext->Mapping[i].extLocation = Lba;
            Ext->Mapping[i].extLength   = Vcb->LBlockSize | (EXTENT_NOT_RECORDED_ALLOCATED << 30);
            goto clean_caller;
        }
    }
#endif // UDF_FE_ALLOCATION_CHARGE
    UDFMarkSpaceAsXXX(Vcb, 0, FEExtInfo->Mapping, AS_DISCARDED); // free
clean_caller:
    FEExtInfo->Mapping[0].extLocation = 0;
    FEExtInfo->Mapping[0].extLength = (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
    return;
} // end UDFFreeFESpace()

Referenced by UDFBuildFileEntry(), UDFCreateFile__(), UDFFreeFileAllocation(), UDFHardLinkFile__(), and UDFRenameMoveFile__().

◆ UDFFreeFileAllocation()

void UDFFreeFileAllocation	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 2696 of file extent.cpp.

{
    if(FileInfo->Dloc->DataLoc.Offset) {
        // in-ICB data
        if(FileInfo->Dloc->DataLoc.Mapping) {
            ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation ==
                   FileInfo->Dloc->DataLoc.Mapping[0].extLocation);
            UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, &(FileInfo->Dloc->DataLoc.Mapping[1]), AS_DISCARDED); // free
            FileInfo->Dloc->DataLoc.Mapping[1].extLocation =
            FileInfo->Dloc->DataLoc.Mapping[1].extLength = 0;
            FileInfo->Dloc->DataLoc.Mapping[0].extLocation = 0;
            FileInfo->Dloc->DataLoc.Mapping[0].extLength = EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30;
        }
        if(FileInfo->Dloc->AllocLoc.Mapping) {
            ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation ==
                   FileInfo->Dloc->AllocLoc.Mapping[0].extLocation);
            UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, &(FileInfo->Dloc->AllocLoc.Mapping[1]), AS_DISCARDED); // free
            FileInfo->Dloc->AllocLoc.Mapping[1].extLocation =
            FileInfo->Dloc->AllocLoc.Mapping[1].extLength = 0;
            FileInfo->Dloc->AllocLoc.Mapping[0].extLocation = 0;
            FileInfo->Dloc->AllocLoc.Mapping[0].extLength = EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30;
        }
        UDFFreeFESpace(Vcb, DirInfo, &(FileInfo->Dloc->FELoc));
    } else {
        if(FileInfo->Dloc->AllocLoc.Mapping) {
            ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation ==
                   FileInfo->Dloc->AllocLoc.Mapping[0].extLocation);
            UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, &(FileInfo->Dloc->AllocLoc.Mapping[1]), AS_DISCARDED); // free
            FileInfo->Dloc->AllocLoc.Mapping[1].extLocation =
            FileInfo->Dloc->AllocLoc.Mapping[1].extLength = 0;
            FileInfo->Dloc->AllocLoc.Mapping[0].extLocation = 0;
            FileInfo->Dloc->AllocLoc.Mapping[0].extLength = EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30;
        }
        UDFFreeFESpace(Vcb, DirInfo, &(FileInfo->Dloc->FELoc));
        UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, FileInfo->Dloc->DataLoc.Mapping, AS_DISCARDED); // free
    }
    FileInfo->Dloc->DataLoc.Modified =
    FileInfo->Dloc->AllocLoc.Modified =
    FileInfo->Dloc->FELoc.Modified = FALSE;
} // end UDFFreeFileAllocation()

Referenced by UDFUnlinkFile__().

◆ UDFGetBitmapLen()

SIZE_T UDFGetBitmapLen	(	uint32 *	Bitmap,
		SIZE_T	Offs,
		SIZE_T	Lim
	)

Definition at line 496 of file alloc.cpp.

{
    ASSERT(Offs <= Lim);
    if(Offs >= Lim) {
        return 0;//(Offs == Lim);
    }
 
    BOOLEAN bit = UDFGetBit(Bitmap, Offs);
    SIZE_T i=Offs>>5;
    SIZE_T len=0;
    uint8 j=(uint8)(Offs&31);
    uint8 lLim=(uint8)(Lim&31);
 
    Lim = Lim>>5;
 
    ASSERT((bit == 0) || (bit == 1));
 
    uint32 a;
 
    a = Bitmap[i] >> j;
 
    while(i<=Lim) {
 
        while( j < ((i<Lim) ? 32 : lLim) ) {
            if( ((BOOLEAN)(a&1)) != bit)
                return len;
            len++;
            a>>=1;
            j++;
        }
        j=0;
While_3:
        i++;
        a = Bitmap[i];
 
        if(i<Lim) {
            if((bit && (a==0xffffffff)) ||
               (!bit && !a)) {
                len+=32;
                goto While_3;
            }
        }
    }
 
    return len;
 
#endif // _X86_
 
} // end UDFGetBitmapLen()

Referenced by UDFAddXSpaceBitmap(), UDFFindMinSuitableExtent(), and UDFResizeExtent().

◆ UDFGetCachedAllocation()

OSSTATUS UDFGetCachedAllocation	(	IN PVCB	Vcb,
		IN uint32	ParentLocation,
		OUT PEXTENT_INFO	Ext,
		OUT uint32 *	Items,
		IN uint32	AllocClass
	)

Definition at line 1417 of file extent.cpp.

{
    PUDF_ALLOCATION_CACHE_ITEM AllocCache;
    uint32 i, lim;
    OSSTATUS status;
 
    UDFAcquireResourceExclusive(&(Vcb->PreallocResource),TRUE);
 
    status = UDFInitAllocationCache(Vcb, AllocClass, &AllocCache, &lim, FALSE);
    if(!OS_SUCCESS(status)) {
        UDFReleaseResource(&(Vcb->PreallocResource));
        return status;
    }
    UDFPrint(("Get AllocationCache for %x\n", ParentLocation));
 
    for(i=0; i<lim; i++) {
        if(AllocCache[i].ParentLocation == ParentLocation) {
            (*Ext) = AllocCache[i].Ext;
            AdPrint(("    map %x (%x)\n", Ext->Mapping, i));
            if(Items) {
                (*Items) = AllocCache[i].Items;
            }
            RtlZeroMemory(&(AllocCache[i]), sizeof(AllocCache[i]));
            AllocCache[i].ParentLocation = LBA_NOT_ALLOCATED;
            UDFReleaseResource(&(Vcb->PreallocResource));
            return STATUS_SUCCESS;
        }
    }
    AdPrint(("    no map\n"));
    UDFReleaseResource(&(Vcb->PreallocResource));
    return STATUS_UNSUCCESSFUL;
} // end UDFGetCachedAllocation()

Referenced by UDFAllocateFESpace(), and UDFResizeExtent().

◆ UDFGetDirIndexByFileInfo()

PDIR_INDEX_HDR UDFGetDirIndexByFileInfo ( IN PUDF_FILE_INFO FileInfo )

Definition at line 1092 of file dirtree.cpp.

{
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo) {
        BrutePoint();
        return NULL;
    }
    if (FileInfo->ParentFile) {
        ValidateFileInfo(FileInfo->ParentFile);
 
        if(UDFIsAStreamDir(FileInfo))
            return NULL;
        if(FileInfo->ParentFile->Dloc)
            return FileInfo->ParentFile->Dloc->DirIndex;
        return NULL;
    }
    if(FileInfo->Dloc)
        return FileInfo->Dloc->DirIndex;
    return NULL;
}

Referenced by UDFCloseFile__(), UDFCommonCleanup(), UDFCommonClose(), UDFCommonCreate(), UDFCompleteMount(), UDFCreateFile__(), UDFDoesOSAllowFilePretendDeleted__(), UDFDoesOSAllowFileToBeTargetForRename__(), UDFFirstOpenFile(), UDFFlushAFile(), UDFFlushFE(), UDFFlushFile__(), UDFGetAltNameInformation(), UDFGetBasicInformation(), UDFGetFileSizeFromDirNdx(), UDFGetNetworkInformation(), UDFPretendFileDeleted__(), UDFRecordDirectory__(), UDFSetBasicInformation(), UDFSetEOF(), UDFSetFileSizeInDirNdx(), and UDFSetFileXTime().

◆ UDFGetDiskInfoAndVerify()

OSSTATUS UDFGetDiskInfoAndVerify	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb
	)

Definition at line 2983 of file mount.cpp.

{
    OSSTATUS        RC = STATUS_UNRECOGNIZED_VOLUME;
    uint32          NSRDesc;
    lb_addr         fileset;
    PFILE_SET_DESC  FileSetDesc = NULL;
 
    int8*           Buf = NULL;
    SIZE_T          ReadBytes;
 
    UDFPrint(("UDFGetDiskInfoAndVerify\n"));
    _SEH2_TRY {
 
        if(!UDFFindAnchor(Vcb)) {
            if(Vcb->FsDeviceType == FILE_DEVICE_CD_ROM_FILE_SYSTEM) {
                // check if this disc is mountable for CDFS
                UDFPrint(("   FILE_DEVICE_CD_ROM_FILE_SYSTEM\n"));
check_NSR:
                NSRDesc = UDFFindVRS(Vcb);
                if(!(NSRDesc & VRS_ISO9660_FOUND)) {
                    // no CDFS VRS found
                    UDFPrint(("UDFGetDiskInfoAndVerify: no CDFS VRS found\n"));
                    if(!Vcb->TrackMap[Vcb->LastTrackNum].LastLba &&
                       !Vcb->TrackMap[Vcb->FirstTrackNum].LastLba) {
                        // such a stupid method of Audio-CD detection...
                        UDFPrint(("UDFGetDiskInfoAndVerify: set UDF_VCB_FLAGS_RAW_DISK\n"));
                        Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
                    }
                }
                Vcb->NSRDesc = NSRDesc;
 
                Buf = (int8*)MyAllocatePool__(NonPagedPool, 0x10000);
                if(!Buf) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
                RC = UDFReadData(Vcb, FALSE, 0, 0x10000, FALSE, Buf, &ReadBytes);
                if(!OS_SUCCESS(RC))
                    try_return(RC = STATUS_UNRECOGNIZED_VOLUME);
                RC = STATUS_UNRECOGNIZED_VOLUME;
                if(!UDFCheckZeroBuf(Buf,0x10000)) {
                    UDFPrint(("UDFGetDiskInfoAndVerify: possible FS detected, remove UDF_VCB_FLAGS_RAW_DISK\n"));
                    Vcb->VCBFlags &= ~UDF_VCB_FLAGS_RAW_DISK;
                }
                MyFreePool__(Buf);
                Buf = NULL;
            }
            try_return(RC = STATUS_UNRECOGNIZED_VOLUME);
        }
 
        RC = UDFLoadPartition(DeviceObject,Vcb,&fileset);
        if(!OS_SUCCESS(RC)) {
            if(RC == STATUS_UNRECOGNIZED_VOLUME) {
                UDFPrint(("UDFGetDiskInfoAndVerify: check NSR presence\n"));
                goto check_NSR;
            }
            try_return(RC);
        }
 
        FileSetDesc = (PFILE_SET_DESC)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
        if(!FileSetDesc) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
 
        RC = UDFFindLastFileSet(Vcb,&fileset,FileSetDesc);
        if(!OS_SUCCESS(RC)) try_return(RC);
 
        UDFLoadFileset(Vcb,FileSetDesc, &(Vcb->RootLbAddr), &(Vcb->SysStreamLbAddr));
 
        Vcb->FSBM_OldBitmap = (int8*)DbgAllocatePool(NonPagedPool, Vcb->FSBM_ByteCount);
        if(!(Vcb->FSBM_OldBitmap)) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
        RtlCopyMemory(Vcb->FSBM_OldBitmap, Vcb->FSBM_Bitmap, Vcb->FSBM_ByteCount);
 
try_exit:   NOTHING;
    } _SEH2_FINALLY {
        if(FileSetDesc)   MyFreePool__(FileSetDesc);
        if(Buf)           MyFreePool__(Buf);
    } _SEH2_END;
 
    return(RC);
 
} // end UDFGetDiskInfoAndVerify()

Referenced by UDFMountVolume(), and UDFVerifyVolume().

◆ UDFGetExtentLength()

int64 UDFGetExtentLength ( IN PEXTENT_MAP Extent )

Definition at line 142 of file extent.cpp.

{
    if(!Extent) return 0;
    int64 i=0;
 
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
 
    __asm push  ebx
    __asm push  ecx
    __asm push  esi
 
    __asm lea   ebx,i
    __asm mov   esi,Extent
    __asm xor   ecx,ecx
While_1:
    __asm mov   eax,[esi+ecx*8]  // Extent[j].extLength
    __asm and   eax,UDF_EXTENT_LENGTH_MASK
    __asm jz    EO_While
    __asm add   [ebx],eax
    __asm adc   [ebx+4],0
    __asm inc   ecx
    __asm jmp   While_1
EO_While:;
    __asm pop   esi
    __asm pop   ecx
    __asm pop   ebx
 
#else   // NO X86 optimization , use generic C/C++
 
    while(Extent->extLength) {
        i += (Extent->extLength & UDF_EXTENT_LENGTH_MASK);
        Extent++;
    }
 
#endif // _X86_
 
    return i;
} // UDFGetExtentLength()

Referenced by UDFAllocFreeExtent_(), UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFFlushFE(), UDFLoadExtInfo(), UDFMarkAllocatedAsRecorded(), UDFPackMapping(), UDFRecordDirectory__(), UDFResizeExtent(), UDFResizeFile__(), UDFUnPackMapping(), UDFUpdateNonAllocated(), and UDFWriteFile__().

◆ UDFGetFileEALength()

uint32 UDFGetFileEALength ( IN PUDF_FILE_INFO FileInfo )

Definition at line 1420 of file udf_info.cpp.

{
    uint16 Ident;
 
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo->Dloc->FileEntry)
        return 1;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
 
    if(Ident == TID_FILE_ENTRY) {
        return ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->lengthExtendedAttr;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        return ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->lengthExtendedAttr;
    }
    return 0;
} // end UDFGetFileEALength()

Referenced by UDFHardLinkFile__(), and UDFRenameMoveFile__().

◆ UDFGetFileLinkCount()

uint16 UDFGetFileLinkCount ( IN PUDF_FILE_INFO FileInfo )

Definition at line 1355 of file udf_info.cpp.

{
    uint16 Ident;
    uint16 d;
 
    ValidateFileInfo(FileInfo);
 
    if(!FileInfo->Dloc->FileEntry)
        return 1;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    // UDF engine assumes that LinkCount is a counter
    // of FileIdents, referencing this FE.
    // UDF 2.0 states, that it should be counter of ALL
    // references (including SDir) - 1.
    // Thus we'll write to media UDF-required value, but return
    // cooked value to callers
    d = UDFHasAStreamDir(FileInfo) ? 0 : 1;
    if(Ident == TID_FILE_ENTRY) {
        return ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->fileLinkCount + d;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        return ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->fileLinkCount + d;
    }
    return UDF_INVALID_LINK_COUNT;
} // end UDFGetFileLinkCount()

Referenced by UDFCleanUpFile__(), UDFCloseFile__(), UDFCommonCleanup(), UDFFileDirInfoToNT(), UDFGetStandardInformation(), UDFHardLinkFile__(), UDFMarkStreamsForDeletion(), UDFOpenFile__(), UDFPrepareForRenameMoveLink(), UDFRenameMoveFile__(), UDFSetDispositionInformation(), UDFSetEOF(), and UDFUnlinkFile__().

◆ UDFGetFileSize()

int64 UDFGetFileSize ( IN PUDF_FILE_INFO FileInfo )

Definition at line 1236 of file udf_info.cpp.

{
    uint16 Ident;
 
    ValidateFileInfo(FileInfo);
 
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        return fe->informationLength;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        return fe->informationLength;
    }
    return (-1);
} // end UDFGetFileSize()

Referenced by UDFCloseFile__(), UDFCompleteMount(), UDFFlushFE(), UDFFlushFile__(), UDFGetNetworkInformation(), UDFGetStandardInformation(), UDFLoadVAT(), UDFReadSecurity(), UDFRecordDirectory__(), UDFRecordVAT(), UDFResizeFile__(), and UDFWriteFile__().

◆ UDFGetFileSizeFromDirNdx()

int64 UDFGetFileSizeFromDirNdx	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 1256 of file udf_info.cpp.

{
    PDIR_INDEX_ITEM DirIndex;
 
    ValidateFileInfo(FileInfo);
 
    DirIndex = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo),FileInfo->Index);
    if(!DirIndex)
       return -1;
 
    return DirIndex->FileSize;
} // end UDFGetFileSizeFromDirNdx()

Referenced by UDFSetEOF().

◆ UDFGetFileUID()

int64 UDFGetFileUID ( IN PUDF_FILE_INFO FileInfo )

Definition at line 1509 of file udf_info.cpp.

{
    ValidateFileInfo(FileInfo);
 
    return UDFGetFileUID_(FileInfo->Dloc->FileEntry);
} // end UDFGetFileUID()

◆ UDFGetFreeSpace()

int64 __fastcall UDFGetFreeSpace ( IN PVCB Vcb )

Definition at line 1105 of file alloc.cpp.

{
    int64 s=0;
    uint32 i;
//    uint32* cur = (uint32*)(Vcb->FSBM_Bitmap);
 
    if(!Vcb->CDR_Mode &&
       !(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK)) {
        for(i=0;i<Vcb->PartitionMaps;i++) {
/*            lim = UDFPartEnd(Vcb,i);
            for(j=UDFPartStart(Vcb,i); j<lim && len; ) {
                len = UDFGetBitmapLen(cur, j, lim);
                if(UDFGetFreeBit(cur, j)) // is the extent found free or used ?
                    s+=len;
                j+=len;
            }*/
            s += UDFGetPartFreeSpace(Vcb, i);
        }
    } else {
        ASSERT(Vcb->LastPossibleLBA >= max(Vcb->NWA, Vcb->LastLBA));
        s = Vcb->LastPossibleLBA - max(Vcb->NWA, Vcb->LastLBA);
        //if(s & ((int64)1 << 64)) s=0;
    }
    return s >> Vcb->LB2B_Bits;
} // end UDFGetFreeSpace()

Referenced by UDFEjectReqWaiter(), UDFMountVolume(), UDFQueryFsFullSizeInfo(), UDFQueryFsSizeInfo(), and UDFSetAllocationInformation().

◆ UDFGetMappingLength()

uint32 UDFGetMappingLength ( IN PEXTENT_MAP Extent )

Definition at line 223 of file extent.cpp.

{
    if(!Extent) return 0;
    uint32 i=0;
 
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
    __asm push  ebx
 
    __asm mov   ebx,Extent
    __asm xor   eax,eax
While_1:
    __asm mov   ecx,[ebx+eax*8]
    __asm jecxz EO_While
    __asm inc   eax
    __asm jmp   While_1
EO_While:
    __asm inc   eax
    __asm shl   eax,3
    __asm mov   i,eax
 
    __asm pop   ebx
 
#else   // NO X86 optimization , use generic C/C++
 
    while(Extent->extLength) {
        i++;
        Extent++;
    }
    i++;
    i*=sizeof(EXTENT_MAP);
 
#endif // _X86_
 
    return i; //  i*sizeof(EXTENT_MAP)
} // end UDFGetMappingLength()

Referenced by UDFMarkAllocatedAsNotXXX(), UDFMarkAllocatedAsRecorded(), UDFMarkNotAllocatedAsAllocated(), UDFMergeMappings(), UDFPackMapping(), UDFRecordVAT(), and UDFResizeExtent().

◆ UDFGetPartFreeSpace()

uint32 __fastcall UDFGetPartFreeSpace	(	IN PVCB	Vcb,
		IN uint32	partNum
	)

Definition at line 1086 of file alloc.cpp.

{
    uint32 lim/*, len=1*/;
    uint32 s=0;
    uint32 j;
    PUCHAR cur = (PUCHAR)(Vcb->FSBM_Bitmap);
 
    lim = (UDFPartEnd(Vcb,partNum)+7)/8;
    for(j=(UDFPartStart(Vcb,partNum)+7)/8; j<lim/* && len*/; j++) {
        s+=bit_count_tab[cur[j]];
    }
    return s;
} // end UDFGetPartFreeSpace()

Referenced by UDFGetFreeSpace(), and UDFUpdateLogicalVolInt().

◆ UDFGetPartNumByPhysLba()

uint32 __fastcall UDFGetPartNumByPhysLba	(	IN PVCB	Vcb,
		IN uint32	Lba
	)

Definition at line 201 of file alloc.cpp.

{
    uint32 i=Vcb->PartitionMaps-1, root;
    PUDFPartMap pm = &(Vcb->Partitions[i]);
    // walk through the partition maps to find suitable one
    for(;i!=0xffffffff;i--,pm--) {
        if( ((root = pm->PartitionRoot) <= Lba) &&
            ((root + pm->PartitionLen) > Lba) ) return (uint16)pm->PartitionNum;
    }
    return LBA_OUT_OF_EXTENT; // Lba doesn't belong to any partition
} // end UDFGetPartNumByPhysLba()

Referenced by UDFCloseFile__(), UDFConvertFEToNonInICB(), UDFCreateFile__(), UDFCreateStreamDir__(), UDFFlushFile__(), UDFIndexDirectory(), UDFMarkNotAllocatedAsAllocated(), UDFMarkSpaceAsXXXNoProtect_(), UDFPackDirectory__(), UDFRecordDirectory__(), UDFRenameMoveFile__(), UDFResizeFile__(), UDFReTagDirectory(), UDFUpdateNonAllocated(), UDFUpdateVAT(), and UDFWriteFile__().

◆ UDFGetTotalSpace()

int64 __fastcall UDFGetTotalSpace ( IN PVCB Vcb )

Definition at line 1138 of file alloc.cpp.

{
    int64 s=0;
    uint32 i;
 
    if(Vcb->VCBFlags & UDF_VCB_FLAGS_RAW_DISK) {
        s= Vcb->LastPossibleLBA;
    } else if(!Vcb->CDR_Mode) {
        for(i=0;i<Vcb->PartitionMaps;i++) {
            s+=Vcb->Partitions[i].PartitionLen;
        }
    } else {
        if(s & ((int64)1 << 63)) s=0;  /* FIXME ReactOS this shift value was 64, which is undefiened behavior. */
        s= Vcb->LastPossibleLBA - Vcb->Partitions[0].PartitionRoot;
    }
    return s >> Vcb->LB2B_Bits;
} // end UDFGetTotalSpace()

Referenced by UDFMountVolume(), UDFQueryFsFullSizeInfo(), and UDFQueryFsSizeInfo().

◆ UDFHardLinkFile__()

OSSTATUS UDFHardLinkFile__	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN OUT BOOLEAN *	Replace,
		IN PUNICODE_STRING	fn,
		IN OUT PUDF_FILE_INFO	DirInfo1,
		IN OUT PUDF_FILE_INFO	DirInfo2,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 4672 of file udf_info.cpp.

{
    PUDF_FILE_INFO FileInfo2;
    OSSTATUS status;
    PDIR_INDEX_ITEM DirNdx1;
    PDIR_INDEX_ITEM DirNdx2;
    uint_di i;
    BOOLEAN Recovery = FALSE;
    BOOLEAN SameFE = FALSE;
    uint32 NTAttr = 0;
 
    // validate FileInfo
    ValidateFileInfo(DirInfo1);
    ValidateFileInfo(DirInfo2);
    ValidateFileInfo(FileInfo);
 
    if(UDFGetFileLinkCount(FileInfo) >= UDF_MAX_LINK_COUNT) {
        // too many links to file...
        return STATUS_TOO_MANY_LINKS;
    }
 
    i = 0;
    if(DirInfo1 == DirInfo2) {
        if(OS_SUCCESS(status = UDFFindFile(Vcb, IgnoreCase, TRUE, fn, DirInfo2, &i)) &&
           (i==FileInfo->Index) ) {
            // case-only difference
            return STATUS_OBJECT_NAME_COLLISION;
        }
    }
 
    // PHASE 0
    // try to create new FileIdent & FileEntry in Dir2
 
HLinkRetry:
    if(!OS_SUCCESS(status = UDFCreateFile__(Vcb, IgnoreCase, fn, UDFGetFileEALength(FileInfo),
                    0, (FileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY),
                    TRUE, DirInfo2, &FileInfo2))) {
        if(UDFCleanUpFile__(Vcb, FileInfo2) && FileInfo2)
            MyFreePool__(FileInfo2);
        if(status == STATUS_ACCESS_DENIED) {
            // try to recover >;->
            if((*Replace) && !Recovery) {
                Recovery = TRUE;
                status = UDFOpenFile__(Vcb, IgnoreCase, TRUE, fn, DirInfo2, &FileInfo2, NULL);
                if(OS_SUCCESS(status)) {
                    status = UDFDoesOSAllowFileToBeTargetForHLink__(FileInfo2);
                    if(!OS_SUCCESS(status)) {
                        UDFCloseFile__(Vcb, FileInfo2);
                        goto cleanup_and_abort_hlink;
                    }
                    if((FileInfo->Dloc == FileInfo2->Dloc)  &&
                       (FileInfo != FileInfo2)) {
                        SameFE = TRUE;
                        // 'status' is already STATUS_SUCCESS here
                    } else {
                        status = UDFUnlinkFile__(Vcb, FileInfo2, TRUE);
                    }
                    UDFCloseFile__(Vcb, FileInfo2);
                    if(UDFCleanUpFile__(Vcb, FileInfo2)) {
                        MyFreePool__(FileInfo2);
                        FileInfo2 = NULL;
                        if(SameFE)
                            return STATUS_SUCCESS;
                    } else {
                        // we get here if the FileInfo has associated
                        // system-specific Fcb
                        // Such fact means that not all system references
                        // has already gone (except Linked file case)
                        if(SameFE)
                            return STATUS_SUCCESS;
                        if(!OS_SUCCESS(status) ||
                           (UDFGetFileLinkCount(FileInfo) < 1))
                            status = STATUS_ACCESS_DENIED;
                    }
                    if(OS_SUCCESS(status)) goto HLinkRetry;
                }
cleanup_and_abort_hlink:
                if(FileInfo2 && UDFCleanUpFile__(Vcb, FileInfo2)) {
                    MyFreePool__(FileInfo2);
                    FileInfo2 = NULL;
                }
            } else {
                status = STATUS_OBJECT_NAME_COLLISION;
            }
        }
        return status;
    }
    // update pointers
    DirNdx1 = UDFDirIndex(DirInfo1->Dloc->DirIndex, FileInfo->Index);
    DirNdx2 = UDFDirIndex(DirInfo2->Dloc->DirIndex, FileInfo2->Index);
 
    // copy file attributes to newly created FileIdent
    NTAttr = UDFAttributesToNT(DirNdx1, FileInfo->Dloc->FileEntry);
    FileInfo2->FileIdent->fileVersionNum = FileInfo->FileIdent->fileVersionNum;
 
    // PHASE 1
    // copy all necessary info from FileInfo to FileInfo2
 
    FileInfo2->FileIdent->icb = FileInfo->FileIdent->icb;
    FileInfo2->FileIdent->fileCharacteristics = FileInfo->FileIdent->fileCharacteristics;
    FileInfo2->FileIdent->fileVersionNum = FileInfo->FileIdent->fileVersionNum;
 
    DirNdx2->FileCharacteristics = DirNdx1->FileCharacteristics & ~FILE_DELETED;
    DirNdx2->FileEntryLoc = DirNdx1->FileEntryLoc;
    DirNdx2->FI_Flags = (DirNdx1->FI_Flags & ~UDF_FI_FLAG_SYS_ATTR) | UDF_FI_FLAG_FI_MODIFIED | UDF_FI_FLAG_LINKED;
 
    UDFAttributesToUDF(DirNdx2, FileInfo2->Dloc->FileEntry, NTAttr);
 
    // PHASE 2
    // update FileInfo
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    DirNdx1->FI_Flags = DirNdx2->FI_Flags;
    UDFIncFileLinkCount(FileInfo); // increase to 1
//    UDFUpdateModifyTime(Vcb, FileInfo);
    FileInfo->Dloc->LinkRefCount += FileInfo2->Dloc->LinkRefCount;
    if(FileInfo2->FileIdent)
        ((FidADImpUse*)&(FileInfo2->FileIdent->icb.impUse))->uniqueID = (uint32)UDFAssingNewFUID(Vcb);
 
    // PHASE 3
    // drop all unnecessary info from FileInfo2
 
    UDFFreeFESpace(Vcb, DirInfo2, &(FileInfo2->Dloc->FELoc));
    UDFRemoveDloc(Vcb, FileInfo2->Dloc);
 
    // PHASE 4
    // perform in-memory linkage (update driver's tree structures) and flush
 
    FileInfo2->Dloc = FileInfo->Dloc;
    UDFInsertLinkedFile(FileInfo2, FileInfo);
 
    UDFCloseFile__(Vcb, FileInfo2);
    if(UDFCleanUpFile__(Vcb, FileInfo2)) {
        MyFreePool__(FileInfo2);
    }
    // return 'delete target' status
    (*Replace) = Recovery;
 
    return STATUS_SUCCESS;
} // end UDFHardLinkFile__()

Referenced by UDFHardLink().

◆ UDFIndexDirectory()

OSSTATUS UDFIndexDirectory	(	IN PVCB	Vcb,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 507 of file dirtree.cpp.

{
    PDIR_INDEX_HDR hDirNdx;
    PDIR_INDEX_ITEM DirNdx;
    PFILE_IDENT_DESC FileId;
    uint32 Offset = 0;
//    uint32 prevOffset = 0;
    uint_di Count = 0;
    OSSTATUS status;
    int8* buff;
    PEXTENT_INFO ExtInfo;  // Extent array for directory
    uint16 PartNum;
    SIZE_T ReadBytes;
    uint16 valueCRC;
 
    if(!FileInfo) return STATUS_INVALID_PARAMETER;
    ValidateFileInfo(FileInfo);
 
    ExtInfo = &(FileInfo->Dloc->DataLoc);
    FileInfo->Dloc->DirIndex = NULL;
    UDFPrint(("UDF: scaning directory\n"));
    // allocate buffer for the whole directory
    ASSERT((uint32)(ExtInfo->Length));
    if(!ExtInfo->Length)
        return STATUS_FILE_CORRUPT_ERROR;
    buff = (int8*)DbgAllocatePool(PagedPool, (uint32)(ExtInfo->Length));
    if(!buff)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    ExtInfo->Flags |= EXTENT_FLAG_ALLOC_SEQUENTIAL;
 
    // read FileIdents
    status = UDFReadExtent(Vcb, ExtInfo, 0, (uint32)(ExtInfo->Length), FALSE, buff, &ReadBytes);
    if(!OS_SUCCESS(status)) {
        DbgFreePool(buff);
        return status;
    }
    // scan Dir to get entry counter
    FileId = (PFILE_IDENT_DESC)buff;
    DirPrint(("  ExtInfo->Length %x\n", ExtInfo->Length));
//    prevOffset = 0;
    while(Offset<ExtInfo->Length) {
        DirPrint(("  Offset %x\n", Offset));
        if(!FileId->descTag.tagIdent) {
            DirPrint(("  term item\n"));
            break;
        }
        if(FileId->descTag.tagIdent != TID_FILE_IDENT_DESC) {
            DirPrint(("  Inv. tag %x\n", FileId->descTag.tagIdent));
            Offset = UDFFindNextFI(buff, prevOffset, (ULONG)(ExtInfo->Length));
            if(!Offset) {
                DirPrint(("  can't find next\n"));
                break;
            } else {
                DirPrint(("  found next offs %x\n", Offset));
                FileId = (PFILE_IDENT_DESC)((buff)+Offset);
            }
        }
        if(((ULONG)Offset & (Vcb->LBlockSize-1)) > (Vcb->LBlockSize-sizeof(FILE_IDENT_DESC))) {
            DirPrint(("  badly aligned\n", Offset));
            if(Vcb->Modified) {
                DirPrint(("  queue repack request\n"));
                FileInfo->Dloc->DirIndex->DelCount = Vcb->PackDirThreshold+1;
            }
        }
//        prevOffset = Offset;
        Offset += (FileId->lengthFileIdent + FileId->lengthOfImpUse + sizeof(FILE_IDENT_DESC) + 3) & (~((uint32)3));
        FileId = (PFILE_IDENT_DESC)((buff)+Offset);
        Count++;
        if(Offset+sizeof(FILE_IDENT_DESC) > ExtInfo->Length) {
            if(Offset != ExtInfo->Length) {
                UDFPrint(("  Trash at the end of Dir\n"));
            }
//            BrutePoint();
            break;
        }
    }
    DirPrint(("  final Offset %x\n", Offset));
    if(Offset > ExtInfo->Length) {
        BrutePoint();
        UDFPrint(("  Unexpected end of Dir\n"));
        DbgFreePool(buff);
        return STATUS_FILE_CORRUPT_ERROR;
    }
    // allocate buffer for directory index & zero it
    DirPrint(("  Count %x\n", Count));
    hDirNdx = UDFDirIndexAlloc(Count+1);
    if(!hDirNdx) {
        DbgFreePool(buff);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Offset = Count = 0;
    hDirNdx->DIFlags |= (ExtInfo->Offset ? UDF_DI_FLAG_INIT_IN_ICB : 0);
    // add entry pointing to the directory itself
    DirNdx = UDFDirIndex(hDirNdx,0);
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    DirNdx->FileEntryLoc.partitionReferenceNum = PartNum =
        (uint16)UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    ASSERT(PartNum != -1);
    DirNdx->FileEntryLoc.logicalBlockNum =
        UDFPhysLbaToPart(Vcb, PartNum, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    if(DirNdx->FileEntryLoc.logicalBlockNum == (ULONG)-1) {
        DirPrint(("  err: FileEntryLoc=-1\n"));
        DbgFreePool(buff);
        UDFDirIndexFree(hDirNdx);
        return STATUS_FILE_CORRUPT_ERROR;
    }
    DirNdx->FileCharacteristics = (FileInfo->FileIdent) ?
                         FileInfo->FileIdent->fileCharacteristics :
                         FILE_DIRECTORY;
//    DirNdx->Offset = 0;
//    DirNdx->Length = 0;
    RtlInitUnicodeString(&DirNdx->FName, L".");
    DirNdx->FileInfo = FileInfo;
    DirNdx->FI_Flags |= UDF_FI_FLAG_KEEP_NAME;
    DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes),
        HASH_ALL | HASH_KEEP_NAME);
    Count++;
    FileId = (PFILE_IDENT_DESC)buff;
    status = STATUS_SUCCESS;
//    prevOffset = 0;
    while((Offset<ExtInfo->Length) && FileId->descTag.tagIdent) {
        // add new entry to index list
        if(FileId->descTag.tagIdent != TID_FILE_IDENT_DESC) {
            UDFPrint(("  Invalid tagIdent %x (expected %x) offst %x\n", FileId->descTag.tagIdent, TID_FILE_IDENT_DESC, Offset));
            DirPrint(("    FileId: filen %x, iulen %x, charact %x\n",
                FileId->lengthFileIdent, FileId->lengthOfImpUse, FileId->fileCharacteristics));
            DirPrint(("    loc: @%x\n", UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, Offset, NULL, NULL, NULL, NULL)));
            KdDump(FileId, sizeof(FileId->descTag));
            Offset = UDFFindNextFI(buff, prevOffset, (ULONG)(ExtInfo->Length));
            if(!Offset) {
                DbgFreePool(buff);
                UDFDirIndexFree(hDirNdx);
                return STATUS_FILE_CORRUPT_ERROR;
            } else {
                DirPrint(("  found next offs %x\n", Offset));
                FileId = (PFILE_IDENT_DESC)((buff)+Offset);
            }
        }
        DirNdx = UDFDirIndex(hDirNdx,Count);
        // allocate buffer & fill it with decompressed unicode filename
        if(FileId->fileCharacteristics & FILE_DELETED) {
            DirPrint(("  FILE_DELETED\n"));
            hDirNdx->DelCount++;
        }
        DirPrint(("  FileId: offs %x, filen %x, iulen %x\n", Offset, FileId->lengthFileIdent, FileId->lengthOfImpUse));
        DirNdx->Length = (FileId->lengthFileIdent + FileId->lengthOfImpUse + sizeof(FILE_IDENT_DESC) + 3) & (~((uint32)3));
        DirPrint(("  DirNdx: Length %x, Charact %x\n", DirNdx->Length, FileId->fileCharacteristics));
        if(FileId->fileCharacteristics & FILE_PARENT) {
            DirPrint(("  parent\n"));
            // init 'parent' entry
            // '..' points to Parent Object (if any),
            // otherwise it points to the Dir itself
            RtlInitUnicodeString(&DirNdx->FName, L"..");
            DirNdx->FileInfo = (FileInfo->ParentFile) ?
                                      FileInfo->ParentFile : FileInfo;
            DirNdx->FI_Flags |= UDF_FI_FLAG_KEEP_NAME;
            DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes), HASH_ALL | HASH_KEEP_NAME);
        } else {
            // init plain file/dir entry
            ASSERT( (Offset+sizeof(FILE_IDENT_DESC)+FileId->lengthOfImpUse+FileId->lengthFileIdent) <=
                    ExtInfo->Length );
            UDFDecompressUnicode(&(DirNdx->FName),
                             ((uint8*)(FileId+1)) + (FileId->lengthOfImpUse),
                             FileId->lengthFileIdent,
                             &valueCRC);
            UDFNormalizeFileName(&(DirNdx->FName), valueCRC);
            DirNdx->FI_Flags |= UDFBuildHashEntry(Vcb, &(DirNdx->FName), &(DirNdx->hashes), HASH_ALL);
        }
        if((FileId->fileCharacteristics & FILE_METADATA)
                       ||
              !DirNdx->FName.Buffer
                       ||
           ((DirNdx->FName.Length >= sizeof(UDF_RESERVED_NAME_HDR)-sizeof(WCHAR)) &&
            (RtlCompareMemory(DirNdx->FName.Buffer, UDF_RESERVED_NAME_HDR, sizeof(UDF_RESERVED_NAME_HDR)-sizeof(WCHAR)) == sizeof(UDF_RESERVED_NAME_HDR)-sizeof(WCHAR)) )) {
            DirPrint(("  metadata\n"));
            DirNdx->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL;
        }
#if 0
        UDFPrint(("%ws\n", DirNdx->FName.Buffer));
#endif
        DirPrint(("%ws\n", DirNdx->FName.Buffer));
        // remember FileEntry location...
        DirNdx->FileEntryLoc = FileId->icb.extLocation;
        // ... and some file characteristics
        DirNdx->FileCharacteristics = FileId->fileCharacteristics;
        DirNdx->Offset = Offset;
#ifdef UDF_CHECK_DISK_ALLOCATION
        if(!(FileId->fileCharacteristics & FILE_DELETED) &&
            (UDFPartLbaToPhys(Vcb, &(DirNdx->FileEntryLoc)) != LBA_OUT_OF_EXTENT) &&
             UDFGetFreeBit(((uint32*)(Vcb->FSBM_Bitmap)), UDFPartLbaToPhys(Vcb, &(DirNdx->FileEntryLoc)) )) {
 
            AdPrint(("Ref to Discarded block %x\n",UDFPartLbaToPhys(Vcb, &(DirNdx->FileEntryLoc)) ));
            BrutePoint();
            FileId->fileCharacteristics |= FILE_DELETED;
        } else
        if(UDFPartLbaToPhys(Vcb, &(DirNdx->FileEntryLoc)) == LBA_OUT_OF_EXTENT) {
            AdPrint(("Ref to Invalid block %x\n", UDFPartLbaToPhys(Vcb, &(DirNdx->FileEntryLoc)) ));
            BrutePoint();
            FileId->fileCharacteristics |= FILE_DELETED;
        }
#endif // UDF_CHECK_DISK_ALLOCATION
//        prevOffset = Offset;
        Offset += DirNdx->Length;
        FileId = (PFILE_IDENT_DESC)(((int8*)FileId)+DirNdx->Length);
        Count++;
        if(Offset+sizeof(FILE_IDENT_DESC) > ExtInfo->Length) {
            if(Offset != ExtInfo->Length) {
                UDFPrint(("  Trash at the end of Dir (2)\n"));
            }
//            BrutePoint();
            break;
        }
    } // while()
    // we needn't writing terminator 'cause the buffer is already zero-filled
    DbgFreePool(buff);
    if(Count < 2) {
        UDFDirIndexFree(hDirNdx);
        UDFPrint(("  Directory too short\n"));
        return STATUS_FILE_CORRUPT_ERROR;
    }
    // store index
    FileInfo->Dloc->DirIndex = hDirNdx;
    return status;
} // end UDFIndexDirectory()

Referenced by UDFCleanUpFile__(), UDFOpenFile__(), UDFOpenRootFile__(), and UDFRecordDirectory__().

◆ UDFInsertLinkedFile()

void UDFInsertLinkedFile	(	PUDF_FILE_INFO	fi,
		PUDF_FILE_INFO	fi2
	)

Definition at line 1470 of file dirtree.cpp.

{
    fi->NextLinkedFile = fi2->NextLinkedFile;
    fi->PrevLinkedFile = fi2;
    fi->NextLinkedFile->PrevLinkedFile =
    fi->PrevLinkedFile->NextLinkedFile = fi;
    return;
} // end UDFInsertLinkedFile()

Referenced by UDFHardLinkFile__(), UDFOpenFile__(), and UDFOpenStreamDir__().

◆ UDFIsBlockAllocated()

ULONG UDFIsBlockAllocated	(	IN void *	_Vcb,
		IN uint32	Lba
	)

Definition at line 1164 of file alloc.cpp.

{
    ULONG ret_val = 0;
    uint32* bm;
//    return TRUE;
    if(!(((PVCB)_Vcb)->VCBFlags & UDF_VCB_ASSUME_ALL_USED)) {
        // check used
        if((bm = (uint32*)(((PVCB)_Vcb)->FSBM_Bitmap)))
            ret_val = (UDFGetUsedBit(bm, Lba) ? WCACHE_BLOCK_USED : 0);
        // check zero-filled
        if((bm = (uint32*)(((PVCB)_Vcb)->ZSBM_Bitmap)))
            ret_val |= (UDFGetZeroBit(bm, Lba) ? WCACHE_BLOCK_ZERO : 0);
    } else {
        ret_val = WCACHE_BLOCK_USED;
    }
    // check bad block
 
    // WCache works with LOGICAL addresses, not PHYSICAL, BB check must be performed UNDER cache
/*
    if(bm = (uint32*)(((PVCB)_Vcb)->BSBM_Bitmap)) {
        ret_val |= (UDFGetBadBit(bm, Lba) ? WCACHE_BLOCK_BAD : 0);
        if(ret_val & WCACHE_BLOCK_BAD) {
            UDFPrint(("Marked BB @ %#x\n", Lba));
        }
    }
*/
    return ret_val;
} // end UDFIsBlockAllocated()

Referenced by UDFMountVolume(), and UDFVerifyVolume().

◆ UDFIsDirEmpty()

BOOLEAN UDFIsDirEmpty ( IN PDIR_INDEX_HDR hCurDirNdx )

Definition at line 3844 of file udf_info.cpp.

{
    uint32 fc;
    uint_di i;
    PDIR_INDEX_ITEM CurDirNdx;
    // not empty
    for(i=2; (CurDirNdx = UDFDirIndex(hCurDirNdx,i)); i++) {
        fc = CurDirNdx->FileCharacteristics;
        if(!(fc & (FILE_PARENT | FILE_DELETED)) &&
           CurDirNdx->Length)
            return FALSE;
    }
    return TRUE;
} // end UDFIsDirEmpty()

Referenced by UDFUnlinkFile__().

◆ UDFIsExtentCached()

BOOLEAN UDFIsExtentCached	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo,
		IN int64	Offset,
		IN uint32	Length,
		IN BOOLEAN	ForWrite
	)

Definition at line 2918 of file extent.cpp.

{
    BOOLEAN retstat = FALSE;
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    SIZE_T to_read;
    uint32 Lba, sect_offs, flags, i;
 
    WCacheStartDirect__(&(Vcb->FastCache), Vcb, TRUE/*FALSE*//*ForWrite*/);
    if(!ExtInfo || !ExtInfo->Mapping) goto EO_IsCached;
    if(!Length) {
        retstat = TRUE;
        goto EO_IsCached;
    }
 
    // prevent reading out of data space
    if(Offset > ExtInfo->Length) goto EO_IsCached;
    if(Offset+Length > ExtInfo->Length) goto EO_IsCached;
    Offset += ExtInfo->Offset;               // used for in-ICB data
    // read maximal possible part of each frag of extent
    Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_read, &flags, &i);
    while(((LONG)Length) > 0) {
        // EOF check
        if(Lba == LBA_OUT_OF_EXTENT) goto EO_IsCached;
        Extent += (i + 1);
        // check for reading tail
        to_read = min(to_read, Length);
        if(flags == EXTENT_RECORDED_ALLOCATED) {
            retstat = UDFIsDataCached(Vcb, Lba, (to_read+sect_offs+Vcb->BlockSize-1)>>Vcb->BlockSizeBits);
            if(!retstat) goto EO_IsCached;
        } else if(ForWrite) {
            goto EO_IsCached;
        }
        Offset += to_read;
        Length -= to_read;
        Lba = UDFNextExtentToLba(Vcb, Extent, &to_read, &flags, &i);
    }
    retstat = TRUE;
EO_IsCached:
    if(!retstat) {
        WCacheEODirect__(&(Vcb->FastCache), Vcb);
    }
    return retstat;
} // end UDFIsExtentCached()

◆ UDFIsIllegalChar()

BOOLEAN __fastcall UDFIsIllegalChar ( IN WCHAR ch )

Definition at line 370 of file udf_info.cpp.

{
    // Genuine illegal char's for DOS.
#if defined (_X86_) && defined (_MSC_VER)
  _asm {
    push ebx
 
    xor  eax,eax
//  mov  ax,chr
    mov  ax,cx
    or   ah,ah
    jnz  ERR_IIC
 
    lea  ebx,[valid_char_arr]
    xlatb
    jmp  short ERR_IIC2
ERR_IIC:
    mov  al,1
ERR_IIC2:
 
    pop  ebx
    ret
  }
 
#else   // NO X86 optimization , use generic C/C++
    /* FIXME */
    //return ((ch < 0x20) || UDFUnicodeInString((uint8*)&valid_char_arr, ch));
    return ((chr < 0x20) || UDFUnicodeInString((uint8*)&valid_char_arr, chr));
#endif // _X86_
} // end UDFIsIllegalChar()

Referenced by UDFDOSName100(), UDFDOSName200(), and UDFDOSName201().

◆ UDFLoadExtInfo()

OSSTATUS UDFLoadExtInfo	(	IN PVCB	Vcb,
		IN PFILE_ENTRY	fe,
		IN PLONG_AD	fe_loc,
		IN OUT PEXTENT_INFO	FExtInfo,
		IN OUT PEXTENT_INFO	AExtInfo
	)

Definition at line 1062 of file udf_info.cpp.

{
    EXTENT_AD TmpExt;
 
    UDFPrint(("  UDFLoadExtInfo:\n"));
    FExtInfo->Mapping = UDFReadMappingFromXEntry(Vcb, fe_loc->extLocation.partitionReferenceNum,
                                       (tag*)fe, &(FExtInfo->Offset), AExtInfo);
    if(!(FExtInfo->Mapping)) {
        if(!(FExtInfo->Offset))
            return STATUS_UNSUCCESSFUL;
        TmpExt.extLength = fe_loc->extLength;
        TmpExt.extLocation = UDFPartLbaToPhys(Vcb, &(fe_loc->extLocation));
        if(TmpExt.extLocation == LBA_OUT_OF_EXTENT)
            return STATUS_FILE_CORRUPT_ERROR;
        FExtInfo->Mapping = UDFExtentToMapping(&TmpExt);
    }
    if(fe->descTag.tagIdent == TID_FILE_ENTRY) {
//        UDFPrint(("Standard FileEntry\n"));
        FExtInfo->Length = fe->informationLength;
    } else /*if(fe->descTag.tagIdent == TID_EXTENDED_FILE_ENTRY) */ {
        FExtInfo->Length = ((PEXTENDED_FILE_ENTRY)fe)->informationLength;
    }
    UDFPrint(("  FExtInfo->Length %x\n", FExtInfo->Length));
    ASSERT(FExtInfo->Length <= UDFGetExtentLength(FExtInfo->Mapping));
    FExtInfo->Modified = FALSE;
 
    return STATUS_SUCCESS;
} // end UDFLoadExtInfo()

Referenced by UDFOpenFile__(), and UDFOpenRootFile__().

◆ UDFLoadFileset()

void UDFLoadFileset	(	IN PVCB	Vcb,
		IN PFILE_SET_DESC	fset,
		OUT lb_addr *	root,
		OUT lb_addr *	sysstream
	)

Definition at line 2539 of file mount.cpp.

{
    *root = fset->rootDirectoryICB.extLocation;
    Vcb->SerialNumber = fset->descTag.tagSerialNum;
    UDFPrint(("Rootdir at block=%x, partition=%d\n",
        root->logicalBlockNum, root->partitionReferenceNum));
    if(sysstream) {
        *sysstream = fset->streamDirectoryICB.extLocation;
        UDFPrint(("SysStream at block=%x, partition=%d\n",
            sysstream->logicalBlockNum, sysstream->partitionReferenceNum));
    }
#define CUR_IDENT_SZ (sizeof(fset->logicalVolIdent))
    if (Vcb->VolIdent.Buffer) {
        MyFreePool__(Vcb->VolIdent.Buffer);
    }
    UDFGetDstring(&(Vcb->VolIdent), (dstring*)&(fset->logicalVolIdent), CUR_IDENT_SZ);
#undef CUR_IDENT_SZ
    UDFPrint(("volIdent[] = '%ws'\n", Vcb->VolIdent.Buffer));
    // Get current UDF revision
    // Get Read-Only flags
    UDFReadEntityID_Domain(Vcb, &(fset->domainIdent));
 
} // end UDFLoadFileset()

Referenced by UDFGetDiskInfoAndVerify().

◆ UDFLoadLogicalVol()

OSSTATUS UDFLoadLogicalVol	(	PDEVICE_OBJECT	DeviceObject,
		PVCB	Vcb,
		int8 *	Buf,
		lb_addr *	fileset
	)

Definition at line 1374 of file mount.cpp.

{
    LogicalVolDesc *lvd = (LogicalVolDesc *)Buf;
    uint16 i, offset;
    uint8 type;
    OSSTATUS status = STATUS_SUCCESS;
    UDFPrint(("UDF: LogicalVolDesc\n"));
    // Validate partition map counter
    if(!(Vcb->Partitions)) {
        Vcb->PartitionMaps = lvd->numPartitionMaps;
        Vcb->Partitions = (PUDFPartMap)MyAllocatePool__(NonPagedPool, sizeof(UDFPartMap) * Vcb->PartitionMaps );
        if(!Vcb->Partitions)
            return STATUS_INSUFFICIENT_RESOURCES;
    } else {
        if(Vcb->PartitionMaps != lvd->numPartitionMaps)
            return STATUS_DISK_CORRUPT_ERROR;
    }
    UDFPrint(("UDF: volDescSeqNum = %x\n", lvd->volDescSeqNum));
    // Get logical block size (may be different from physical)
    Vcb->LBlockSize = lvd->logicalBlockSize;
    // Get current UDF revision
    // Get Read-Only flags
    UDFReadEntityID_Domain(Vcb, &(lvd->domainIdent));
 
    if(Vcb->LBlockSize < Vcb->BlockSize)
        return STATUS_DISK_CORRUPT_ERROR;
    switch(Vcb->LBlockSize) {
    case 512: Vcb->LBlockSizeBits = 9; break;
    case 1024: Vcb->LBlockSizeBits = 10; break;
    case 2048: Vcb->LBlockSizeBits = 11; break;
    case 4096: Vcb->LBlockSizeBits = 12; break;
    case 8192: Vcb->LBlockSizeBits = 13; break;
    case 16384: Vcb->LBlockSizeBits = 14; break;
    case 32768: Vcb->LBlockSizeBits = 15; break;
    case 65536: Vcb->LBlockSizeBits = 16; break;
    default:
        UDFPrint(("UDF: Bad block size (%ld)\n", Vcb->LBlockSize));
        return STATUS_DISK_CORRUPT_ERROR;
    }
    UDFPrint(("UDF: logical block size (%ld)\n", Vcb->LBlockSize));
    Vcb->LB2B_Bits = Vcb->LBlockSizeBits - Vcb->BlockSizeBits;
    UDFPrint(("UDF: mapTableLength = %x\n", lvd->mapTableLength));
    UDFPrint(("UDF: numPartitionMaps = %x\n", lvd->numPartitionMaps));
    // walk through all available part maps
    for (i=0,offset=0;
         i<Vcb->PartitionMaps && offset<lvd->mapTableLength;
         i++,offset+=((GenericPartitionMap *)( ((uint8*)(lvd+1))+offset) )->partitionMapLength)
    {
        GenericPartitionMap* gpm = (GenericPartitionMap *)(((uint8*)(lvd+1))+offset);
        type = gpm->partitionMapType;
        UDFPrint(("Partition (%d) type %x, len %x\n", i, type, gpm->partitionMapLength));
        if(type == PARTITION_MAP_TYPE_1)
        {
            GenericPartitionMap1 *gpm1 = (GenericPartitionMap1 *)(((uint8*)(lvd+1))+offset);
 
            Vcb->Partitions[i].PartitionType = UDF_TYPE1_MAP15;
            Vcb->Partitions[i].VolumeSeqNum = gpm1->volSeqNum;
            Vcb->Partitions[i].PartitionNum = gpm1->partitionNum;
            status = STATUS_SUCCESS;
        }
        else if(type == PARTITION_MAP_TYPE_2)
        {
            UdfPartitionMap2* upm2 = (UdfPartitionMap2 *)(((uint8*)(lvd+1))+offset);
            if(!strncmp((int8*)&(upm2->partIdent.ident), UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL)))
            {
                UDFIdentSuffix* udfis =
                    (UDFIdentSuffix*)&(upm2->partIdent.identSuffix);
 
                if( (udfis->currentRev == 0x0150)/* ||
                    (Vcb->CurrentUDFRev == 0x0150)*/ ) {
                    UDFPrint(("Found VAT 1.50\n"));
                    Vcb->Partitions[i].PartitionType = UDF_VIRTUAL_MAP15;
                } else
                if( (udfis->currentRev == 0x0200) ||
                    (udfis->currentRev == 0x0201) /*||
                    (Vcb->CurrentUDFRev == 0x0200) ||
                    (Vcb->CurrentUDFRev == 0x0201)*/ ) {
                    UDFPrint(("Found VAT 2.00\n"));
                    Vcb->Partitions[i].PartitionType = UDF_VIRTUAL_MAP20;
                }
                status = STATUS_SUCCESS;
            }
            else if(!strncmp((int8*)&(upm2->partIdent.ident), UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE)))
            {
                UDFPrint(("Load sparing table\n"));
                PSPARABLE_PARTITION_MAP spm = (PSPARABLE_PARTITION_MAP)(((uint8*)(lvd+1))+offset);
                Vcb->Partitions[i].PartitionType = UDF_SPARABLE_MAP15;
                status = UDFLoadSparingTable(Vcb, spm);
            }
            else if(!strncmp((int8*)&(upm2->partIdent.ident), UDF_ID_METADATA, strlen(UDF_ID_METADATA)))
            {
                UDFPrint(("Found metadata partition\n"));
//                PMETADATA_PARTITION_MAP mpm = (PMETADATA_PARTITION_MAP)(((uint8*)(lvd+1))+offset);
                Vcb->Partitions[i].PartitionType = UDF_METADATA_MAP25;
                //status = UDFLoadSparingTable(Vcb, spm);
            }
            else
            {
                UDFPrint(("Unknown ident: %s\n", upm2->partIdent.ident));
                continue;
            }
            Vcb->Partitions[i].VolumeSeqNum = upm2->volSeqNum;
            Vcb->Partitions[i].PartitionNum = upm2->partitionNum;
        }
    }
 
    if(fileset) {
        // remember FileSet location
        long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
        *fileset = (la->extLocation);
        UDFPrint(("FileSet found in LogicalVolDesc at block=%x, partition=%d\n",
            fileset->logicalBlockNum,
            fileset->partitionReferenceNum));
    }
    if(OS_SUCCESS(status)) {
        // load Integrity Desc if any
        if(lvd->integritySeqExt.extLength)
            status = UDFLoadLogicalVolInt(DeviceObject,Vcb,lvd->integritySeqExt);
    }
    return status;
} // end UDFLoadLogicalVol()

Referenced by UDFProcessSequence().

◆ UDFLoadLogicalVolInt()

OSSTATUS UDFLoadLogicalVolInt	(	PDEVICE_OBJECT	DeviceObject,
		PVCB	Vcb,
		extent_ad	loc
	)

Definition at line 1239 of file mount.cpp.

{
    OSSTATUS    RC = STATUS_SUCCESS;
    uint32      len;
    SIZE_T      _ReadBytes;
    int8*       Buf = NULL;
    uint16      ident;
    LogicalVolIntegrityDescImpUse* LVID_iUse;
    LogicalVolHeaderDesc* LVID_hd;
    extent_ad   last_loc;
    BOOLEAN     read_last = FALSE;
    uint32      lvid_count = 0;
 
    ASSERT(!Vcb->LVid);
    if(Vcb->LVid) {
        MyFreePool__(Vcb->LVid);
        Vcb->LVid = NULL;
    }
    // walk through all sectors inside LogicalVolumeIntegrityDesc
    while(loc.extLength) {
        UDFPrint(("UDF: Reading LVID @%x (%x)\n", loc.extLocation, loc.extLength));
        len = max(loc.extLength, Vcb->BlockSize);
        Buf = (int8*)MyAllocatePool__(NonPagedPool,len);
        if(!Buf)
            return STATUS_INSUFFICIENT_RESOURCES;
        RC = UDFReadTagged(Vcb,Buf, loc.extLocation, loc.extLocation, &ident);
        if(!OS_SUCCESS(RC)) {
exit_with_err:
            UDFPrint(("UDF: Reading LVID @%x (%x) failed.\n", loc.extLocation, loc.extLength));
            switch(Vcb->PartitialDamagedVolumeAction) {
            case UDF_PART_DAMAGED_RO:
                UDFPrint(("UDF: Switch to r/o mode.\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
                Vcb->UserFSFlags |= UDF_USER_FS_FLAGS_MEDIA_DEFECT_RO;
                RC = STATUS_SUCCESS;
                break;
            case UDF_PART_DAMAGED_NO:
                UDFPrint(("UDF: Switch to raw mount mode, return UNRECOGNIZED_VOLUME.\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
                //RC = STATUS_WRONG_VOLUME;
                break;
            case UDF_PART_DAMAGED_RW:
            default:
                UDFPrint(("UDF: Keep r/w mode for your own risk.\n"));
                RC = STATUS_SUCCESS;
                // asume we have INTEGRITY_TYPE_CLOSE
                Vcb->IntegrityType = INTEGRITY_TYPE_CLOSE;
                break;
            }
 
            MyFreePool__(Buf);
            return RC;
        }
        UDFRegisterFsStructure(Vcb, loc.extLocation, len);
        // handle Terminal Entry
        if(ident == TID_TERMINAL_ENTRY) {
            read_last = TRUE;
            MyFreePool__(Buf);
            Vcb->LVid = NULL;
            loc = last_loc;
            continue;
        } else
        if(ident != TID_LOGICAL_VOL_INTEGRITY_DESC) {
            RC = STATUS_DISK_CORRUPT_ERROR;
            goto exit_with_err;
        }
 
        Vcb->LVid = (LogicalVolIntegrityDesc *)Buf;
        RC = UDFReadData(Vcb, TRUE, ((uint64)(loc.extLocation)) << Vcb->BlockSizeBits, len, FALSE, Buf, &_ReadBytes);
        // update info
        if( !read_last &&
            Vcb->LVid->nextIntegrityExt.extLength) {
            // go to next LVID
            last_loc = loc;
            loc = Vcb->LVid->nextIntegrityExt;
            Vcb->LVid = NULL;
            lvid_count++;
            if(lvid_count > UDF_MAX_LVID_CHAIN_LENGTH) {
                RC = STATUS_DISK_CORRUPT_ERROR;
                goto exit_with_err;
            }
            MyFreePool__(Buf);
            continue;
        }
        // process last LVID
        Vcb->origIntegrityType =
            Vcb->IntegrityType = Vcb->LVid->integrityType;
        Vcb->LVid_loc = loc;
 
        LVID_iUse = UDFGetLVIDiUse(Vcb);
 
        UDFPrint(("UDF: Last LVID:\n"));
        UDFPrint(("     minR: %x\n",LVID_iUse->minUDFReadRev ));
        UDFPrint(("     minW: %x\n",LVID_iUse->minUDFWriteRev));
        UDFPrint(("     maxW: %x\n",LVID_iUse->maxUDFWriteRev));
        UDFPrint(("     Type: %s\n",!Vcb->IntegrityType ? "Open" : "Close"));
 
        Vcb->minUDFReadRev  = LVID_iUse->minUDFReadRev;
        Vcb->minUDFWriteRev = LVID_iUse->minUDFWriteRev;
        Vcb->maxUDFWriteRev = LVID_iUse->maxUDFWriteRev;
 
        Vcb->numFiles = LVID_iUse->numFiles;
        Vcb->numDirs  = LVID_iUse->numDirs;
        UDFPrint(("     nFiles: %x\n",Vcb->numFiles ));
        UDFPrint(("     nDirs: %x\n",Vcb->numDirs ));
 
        // Check if we can understand this format
        if(Vcb->minUDFReadRev > UDF_MAX_READ_REVISION)
            RC = STATUS_UNRECOGNIZED_VOLUME;
        // Check if we know how to write here
        if(Vcb->minUDFWriteRev > UDF_MAX_WRITE_REVISION) {
            UDFPrint(("     Target FS requires: %x Revision => ReadOnly\n",Vcb->minUDFWriteRev));
            Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
            Vcb->UserFSFlags |= UDF_USER_FS_FLAGS_NEW_FS_RO;
        }
 
        LVID_hd = (LogicalVolHeaderDesc*)&(Vcb->LVid->logicalVolContentsUse);
        Vcb->NextUniqueId = LVID_hd->uniqueID;
        UDFPrint(("     Next FID: %x\n",Vcb->NextUniqueId));
 
        break;
    }
 
    return RC;
} // end UDFLoadLogicalVolInt()

Referenced by UDFLoadLogicalVol().

◆ UDFLoadPartDesc()

OSSTATUS UDFLoadPartDesc	(	PVCB	Vcb,
		int8 *	Buf
	)

Definition at line 2023 of file mount.cpp.

{
    PartitionDesc *p = (PartitionDesc *)Buf;
    uint32 i;
    OSSTATUS RC;
    BOOLEAN Found = FALSE;
    UDFPrint(("UDF: Pard Descr:\n"));
    UDFPrint((" volDescSeqNum   = %x\n", p->volDescSeqNum));
    UDFPrint((" partitionFlags  = %x\n", p->partitionFlags));
    UDFPrint((" partitionNumber = %x\n", p->partitionNumber));
    UDFPrint((" accessType      = %x\n", p->accessType));
    UDFPrint((" partitionStartingLocation = %x\n", p->partitionStartingLocation));
    UDFPrint((" partitionLength = %x\n", p->partitionLength));
    // There is nothing interesting to comment here
    // Just look at Names & Messages....
    for (i=0; i<Vcb->PartitionMaps; i++) {
        UDFPrint(("Searching map: (%d == %d)\n",
            Vcb->Partitions[i].PartitionNum, (p->partitionNumber) ));
        if(Vcb->Partitions[i].PartitionNum == (p->partitionNumber)) {
            Found = TRUE;
            Vcb->Partitions[i].PartitionRoot = p->partitionStartingLocation + Vcb->FirstLBA;
            Vcb->Partitions[i].PartitionLen = p->partitionLength;
            Vcb->Partitions[i].UspaceBitmap = 0xFFFFFFFF;
            Vcb->Partitions[i].FspaceBitmap = 0xFFFFFFFF;
            Vcb->Partitions[i].AccessType = p->accessType;
            UDFPrint(("Access mode %x\n", p->accessType));
            if(p->accessType == PARTITION_ACCESS_WO) {
                Vcb->CDR_Mode = TRUE;
//                Vcb->Partitions[i].PartitionLen = Vcb->LastPossibleLBA - p->partitionStartingLocation;
            } else if(p->accessType < PARTITION_ACCESS_WO) {
                // Soft-read-only volume
                UDFPrint(("Soft Read-only volume\n"));
                Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
                Vcb->UserFSFlags |= UDF_USER_FS_FLAGS_PART_RO;
            } else if(p->accessType > PARTITION_ACCESS_MAX_KNOWN) {
                return STATUS_UNRECOGNIZED_MEDIA;
            }
 
            if(!strcmp((int8*)&(p->partitionContents.ident), PARTITION_CONTENTS_NSR02) ||
                !strcmp((int8*)&(p->partitionContents.ident), PARTITION_CONTENTS_NSR03))
            {
                PPARTITION_HEADER_DESC phd;
 
                phd = (PPARTITION_HEADER_DESC)(p->partitionContentsUse);
#ifdef UDF_DBG
                if(phd->unallocatedSpaceTable.extLength)
                    UDFPrint(("unallocatedSpaceTable (part %d)\n", i));
#endif // UDF_DBG
                if(phd->unallocatedSpaceBitmap.extLength) {
                    Vcb->Partitions[i].UspaceBitmap =
                        phd->unallocatedSpaceBitmap.extPosition;
                    UDFPrint(("unallocatedSpaceBitmap (part %d) @ %x\n",
                        i, Vcb->Partitions[i].UspaceBitmap ));
                }
#ifdef UDF_DBG
                if(phd->partitionIntegrityTable.extLength)
                    UDFPrint(("partitionIntegrityTable (part %d)\n", i));
                if(phd->freedSpaceTable.extLength)
                    UDFPrint(("freedSpaceTable (part %d)\n", i));
#endif // UDF_DBG
                if(phd->freedSpaceBitmap.extLength) {
                    Vcb->Partitions[i].FspaceBitmap =
                        phd->freedSpaceBitmap.extPosition;
                    UDFPrint(("freedSpaceBitmap (part %d)\n", i));
                }
                RC = UDFBuildFreeSpaceBitmap(Vcb, i, phd, 0);
                //Vcb->Modified = FALSE;
                UDFPreClrModified(Vcb);
                UDFClrModified(Vcb);
                if(!OS_SUCCESS(RC))
                    return RC;
 
                if ((Vcb->Partitions[i].PartitionType == UDF_VIRTUAL_MAP15) ||
                    (Vcb->Partitions[i].PartitionType == UDF_VIRTUAL_MAP20)) {
                    RC = UDFLoadVAT(Vcb, i);
                    if(!OS_SUCCESS(RC))
                        return RC;
                    WCacheFlushAll__(&(Vcb->FastCache), Vcb);
                    WCacheSetMode__(&(Vcb->FastCache), WCACHE_MODE_R);
                    Vcb->LastModifiedTrack = 0;
                }
            }
        }
    }
#ifdef UDF_DBG
    if(!Found) {
        UDFPrint(("Partition (%d) not found in partition map\n", (p->partitionNumber) ));
    } else {
        UDFPrint(("Partition (%d:%d type %x) starts at physical %x, length %x\n",
            p->partitionNumber, i-1, Vcb->Partitions[i-1].PartitionType,
            Vcb->Partitions[i-1].PartitionRoot, Vcb->Partitions[i-1].PartitionLen));
    }
#endif // UDF_DBG
    return STATUS_SUCCESS;
} // end UDFLoadPartDesc()

Referenced by UDFProcessSequence().

◆ UDFLoadPartition()

OSSTATUS UDFLoadPartition	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb,
		OUT lb_addr *	fileset
	)

Definition at line 2607 of file mount.cpp.

{
    OSSTATUS            RC = STATUS_UNRECOGNIZED_VOLUME;
    OSSTATUS            RC2 = STATUS_UNRECOGNIZED_VOLUME;
    AnchorVolDescPtr    *anchor;
    uint16              ident;
    int8*               Buf = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
    uint32              main_s, main_e;
    uint32              reserve_s, reserve_e;
    int                 i;
 
    if(!Buf) return STATUS_INSUFFICIENT_RESOURCES;
    // walk through all available Anchors & load data
    for (i=0; i<MAX_ANCHOR_LOCATIONS; i++)
    {
        if(Vcb->Anchor[i] && (OS_SUCCESS(UDFReadTagged(Vcb, Buf,
            Vcb->Anchor[i], Vcb->Anchor[i] - Vcb->FirstLBA, &ident))))
        {
            anchor = (AnchorVolDescPtr *)Buf;
 
            // Locate the main sequence
            main_s = ( anchor->mainVolDescSeqExt.extLocation );
            main_e = ( anchor->mainVolDescSeqExt.extLength );
            main_e = main_e >> Vcb->BlockSizeBits;
            main_e += main_s;
 
            // Locate the reserve sequence
            reserve_s = (anchor->reserveVolDescSeqExt.extLocation);
            reserve_e = (anchor->reserveVolDescSeqExt.extLength);
            reserve_e = reserve_e >> Vcb->BlockSizeBits;
            reserve_e += reserve_s;
 
            // Check if it is known bad sequence
            RC = UDFIsCachedBadSequence(Vcb, main_s);
            if(OS_SUCCESS(RC)) {
                // Process the main & reserve sequences
                // responsible for finding the PartitionDesc(s)
                UDFPrint(("-----------------------------------\n"));
                UDFPrint(("UDF: Main sequence:\n"));
                RC = UDFProcessSequence(DeviceObject, Vcb, main_s, main_e, fileset);
            }
 
            if(!OS_SUCCESS(RC)) {
                // Remenber bad sequence
                UDFRememberBadSequence(Vcb, main_s, RC);
 
                UDFPrint(("-----------------------------------\n"));
                UDFPrint(("UDF: Main sequence failed.\n"));
                UDFPrint(("UDF: Reserve sequence\n"));
                if(Vcb->LVid) MyFreePool__(Vcb->LVid);
                Vcb->LVid = NULL;
 
                RC2 = UDFIsCachedBadSequence(Vcb, reserve_s);
                if(OS_SUCCESS(RC2)) {
                    RC2 = UDFProcessSequence(DeviceObject, Vcb, reserve_s, reserve_e, fileset);
                }
 
                if(OS_SUCCESS(RC2)) {
                    UDFPrint(("-----------------------------------\n"));
                    Vcb->VDS2_Len = reserve_e - reserve_s;
                    Vcb->VDS2 = reserve_s;
                    RC = STATUS_SUCCESS;
                    // Vcb is already Zero-filled
//                    Vcb->VDS1_Len = 0;
//                    Vcb->VDS1 = 0;
                    break;
                } else {
                    // This is also bad sequence. Remenber it too
                    UDFRememberBadSequence(Vcb, reserve_s, RC);
                }
            } else {
                // remember these values for umount__
                Vcb->VDS1_Len = main_e - main_s;
                Vcb->VDS1 = main_s;
/*                if(Vcb->LVid) MyFreePool__(Vcb->LVid);
                Vcb->LVid = NULL;*/
                if(OS_SUCCESS(UDFVerifySequence(DeviceObject, Vcb, reserve_s, reserve_e, fileset)))
                {
                    UDFPrint(("-----------------------------------\n"));
                    Vcb->VDS2_Len = reserve_e - reserve_s;
                    Vcb->VDS2 = reserve_s;
                    break;
                } else {
                    UDFPrint(("UDF: Reserve sequence verification failed.\n"));
                    switch(Vcb->PartitialDamagedVolumeAction) {
                    case UDF_PART_DAMAGED_RO:
                        UDFPrint(("UDF: Switch to r/o mode.\n"));
                        Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
                        break;
                    case UDF_PART_DAMAGED_NO:
                        UDFPrint(("UDF: Switch to raw mount mode, return UNRECOGNIZED_VOLUME.\n"));
                        Vcb->VCBFlags |= UDF_VCB_FLAGS_RAW_DISK;
                        RC = STATUS_WRONG_VOLUME;
                        break;
                    case UDF_PART_DAMAGED_RW:
                    default:
                        UDFPrint(("UDF: Keep r/w mode for your own risk.\n"));
                        break;
                    }
                }
                break;
            }
        }
    }
 
    if(Vcb->SparingCount &&
       (Vcb->NoFreeRelocationSpaceVolumeAction != UDF_PART_DAMAGED_RW)) {
        UDFPrint(("UDF: No free Sparing Entries -> Switch to r/o mode.\n"));
        Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
    }
 
    if(i == sizeof(Vcb->Anchor)/sizeof(int)) {
        UDFPrint(("No Anchor block found\n"));
        RC = STATUS_UNRECOGNIZED_VOLUME;
#ifdef UDF_DBG
    } else {
        UDFPrint(("Using anchor in block %x\n", Vcb->Anchor[i]));
#endif // UDF_DBG
    }
    MyFreePool__(Buf);
    return RC;
} // end UDFLoadPartition()

Referenced by UDFGetDiskInfoAndVerify().

◆ UDFLoadPVolDesc()

void UDFLoadPVolDesc	(	PVCB	Vcb,
		int8 *	Buf
	)

Definition at line 1194 of file mount.cpp.

{
    PrimaryVolDesc *pvoldesc;
//    OSSTATUS    RC = STATUS_SUCCESS;
 
    pvoldesc = (PrimaryVolDesc *)Buf;
    UDFPrint(("UDF: PrimaryVolDesc:\n"));
    UDFPrint(("volDescSeqNum     = %d\n", pvoldesc->volDescSeqNum));
    UDFPrint(("primaryVolDescNum = %d\n", pvoldesc->primaryVolDescNum));
    // remember recording time...
    Vcb->VolCreationTime = UDFTimeToNT(&(pvoldesc->recordingDateAndTime));
    // ...VolIdent...
#define CUR_IDENT_SZ (sizeof(pvoldesc->volIdent))
    if (Vcb->VolIdent.Buffer) {
        MyFreePool__(Vcb->VolIdent.Buffer);
    }
    UDFGetDstring(&(Vcb->VolIdent), (dstring*)&(pvoldesc->volIdent), CUR_IDENT_SZ);
#undef CUR_IDENT_SZ
    UDFPrint(("volIdent[] = '%ws'\n", Vcb->VolIdent.Buffer));
#ifdef UDF_DBG
    UDFPrint(("volSeqNum         = %d\n", pvoldesc->volSeqNum));
    UDFPrint(("maxVolSeqNum      = %d\n", pvoldesc->maxVolSeqNum));
    UDFPrint(("interchangeLvl    = %d\n", pvoldesc->interchangeLvl));
    UDFPrint(("maxInterchangeLvl = %d\n", pvoldesc->maxInterchangeLvl));
    UDFPrint(("charSetList       = %d\n", pvoldesc->charSetList));
    UDFPrint(("maxCharSetList    = %d\n", pvoldesc->maxCharSetList));
    // ...& just print VolSetIdent
    UNICODE_STRING      instr;
#define CUR_IDENT_SZ (sizeof(pvoldesc->volSetIdent))
    UDFGetDstring(&instr, (dstring*)&(pvoldesc->volSetIdent), CUR_IDENT_SZ);
#undef CUR_IDENT_SZ
    UDFPrint(("volSetIdent[] = '%ws'\n", instr.Buffer));
//    UDFPrint(("maxInterchangeLvl = %d\n", pvoldesc->maxInterchangeLvl));
    UDFPrint(("flags             = %x\n", pvoldesc->flags));
    if(instr.Buffer) MyFreePool__(instr.Buffer);
#endif // UDF_DBG
} // end UDFLoadPVolDesc()

Referenced by UDFProcessSequence().

◆ UDFLoadSparingTable()

OSSTATUS UDFLoadSparingTable	(	IN PVCB	Vcb,
		IN PSPARABLE_PARTITION_MAP	PartMap
	)

Definition at line 2783 of file mount.cpp.

{
    PSPARING_MAP RelocMap;
    PSPARING_MAP NewRelocMap;
    OSSTATUS status;
    uint32 i=0, BC, BC2;
    PSPARING_TABLE SparTable;
    uint32 TabSize, NewSize;
    SIZE_T ReadBytes;
    uint32 SparTableLoc;
#ifdef UDF_TRACK_FS_STRUCTURES
    uint32 j;
#endif //UDF_TRACK_FS_STRUCTURES
    uint32 n,m;
    BOOLEAN merged;
 
    Vcb->SparingCountFree = -1;
 
    UDFPrint(("UDF: Sparable Part Map:\n"));
    Vcb->SparingTableLength = PartMap->sizeSparingTable;
    BC = (PartMap->sizeSparingTable >> Vcb->BlockSizeBits) + 1;
    UDFPrint((" partitionMapType   = %x\n", PartMap->partitionMapType));
    UDFPrint((" partitionMapLength = %x\n", PartMap->partitionMapLength));
    UDFPrint((" volSeqNum          = %x\n", PartMap->volSeqNum));
    UDFPrint((" partitionNum       = %x\n", PartMap->partitionNum));
    UDFPrint((" packetLength       = %x\n", PartMap->packetLength));
    UDFPrint((" numSparingTables   = %x\n", PartMap->numSparingTables));
    UDFPrint((" sizeSparingTable   = %x\n", PartMap->sizeSparingTable));
    SparTable = (PSPARING_TABLE)MyAllocatePool__(NonPagedPool, BC*Vcb->BlockSize);
    if(!SparTable) return STATUS_INSUFFICIENT_RESOURCES;
    if(Vcb->SparingTable) {
        // if a part of Sparing Table is already loaded,
        // update it with data from another one
        RelocMap = Vcb->SparingTable;
        TabSize = Vcb->SparingCount * sizeof(SPARING_ENTRY);
    } else {
        // do some init to load first part of Sparing Table
        RelocMap = (PSPARING_MAP)MyAllocatePool__(NonPagedPool, RELOC_MAP_GRAN);
        if(!RelocMap) {
            MyFreePool__(SparTable);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        TabSize = RELOC_MAP_GRAN;
        Vcb->SparingBlockSize = PartMap->packetLength;
    }
    // walk through all available Sparing Tables
    for(i=0;i<PartMap->numSparingTables;i++) {
        // read (next) table
        SparTableLoc = ((uint32*)(PartMap+1))[i];
        for(n=0; n<Vcb->SparingTableCount; n++) {
            if(Vcb->SparingTableLoc[i] == SparTableLoc) {
                UDFPrint((" already processed @%x\n",
                    SparTableLoc
                    ));
                continue;
            }
        }
        status = UDFReadSectors(Vcb, FALSE, SparTableLoc, 1, FALSE, (int8*)SparTable, &ReadBytes);
        // tag should be set to TID_UNUSED_DESC
        if(OS_SUCCESS(status) && (SparTable->descTag.tagIdent == TID_UNUSED_DESC)) {
 
            UDFRegisterFsStructure(Vcb,  SparTableLoc, Vcb->BlockSize);
            BC2 = ((sizeof(SPARING_TABLE) +
                    SparTable->reallocationTableLen*sizeof(SparingEntry) +
                    Vcb->BlockSize-1)
                                      >> Vcb->BlockSizeBits);
            if(BC2 > BC) {
                UDFPrint((" sizeSparingTable @%x too long: %x > %x\n",
                    SparTableLoc, BC2, BC
                    ));
                continue;
            }
            status = UDFReadSectors(Vcb, FALSE, SparTableLoc,
                BC2, FALSE, (int8*)SparTable, &ReadBytes);
            UDFRegisterFsStructure(Vcb,  SparTableLoc, BC2<<Vcb->BlockSizeBits);
 
            if(!OS_SUCCESS(status)) {
                UDFPrint((" Error reading sizeSparingTable @%x (%x)\n",
                    SparTableLoc, BC2
                    ));
                continue;
            }
            // process sparing table
            NewSize = sizeof(SparingEntry)*SparTable->reallocationTableLen;
            TabSize = MyReallocPool__((int8*)RelocMap, TabSize, (int8**)&RelocMap, TabSize+NewSize);
            if(!TabSize) {
                MyFreePool__(SparTable);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
 
#ifdef UDF_TRACK_FS_STRUCTURES
            for(j=0; j<SparTable->reallocationTableLen; j++) {
                UDFRegisterFsStructure(Vcb,  ((SparingEntry*)(SparTable+1))[j].mappedLocation, Vcb->WriteBlockSize);
            }
#endif //UDF_TRACK_FS_STRUCTURES
 
            Vcb->SparingTableLoc[Vcb->SparingTableCount] = SparTableLoc;
            Vcb->SparingTableCount++;
 
            NewRelocMap = (PSPARING_MAP)(SparTable+1);
            for(n=0; n<SparTable->reallocationTableLen; n++) {
                merged = TRUE;
                for(m=0; m<Vcb->SparingCount; m++) {
                    if(RelocMap[m].mappedLocation == NewRelocMap[n].mappedLocation) {
                        UDFPrint(("  dup @%x (%x) vs @%x (%x)\n",
                            RelocMap[m].origLocation, RelocMap[m].mappedLocation,
                            NewRelocMap[m].origLocation, NewRelocMap[m].mappedLocation));
                        merged = FALSE;
                    }
                    if((RelocMap[m].origLocation   == NewRelocMap[n].origLocation) &&
                       (RelocMap[m].mappedLocation != NewRelocMap[n].mappedLocation) &&
                       (RelocMap[m].origLocation != SPARING_LOC_AVAILABLE) &&
                       (RelocMap[m].origLocation != SPARING_LOC_CORRUPTED)) {
                        UDFPrint(("  conflict @%x (%x) vs @%x (%x)\n",
                            RelocMap[m].origLocation, RelocMap[m].mappedLocation,
                            NewRelocMap[n].origLocation, NewRelocMap[n].mappedLocation));
                        merged = FALSE;
                    }
                }
                if(merged) {
                    RelocMap[Vcb->SparingCount] = NewRelocMap[n];
                    UDFPrint(("  reloc %x -> %x\n",
                        RelocMap[Vcb->SparingCount].origLocation, RelocMap[Vcb->SparingCount].mappedLocation));
                    Vcb->SparingCount++;
                    if(RelocMap[Vcb->SparingCount].origLocation == SPARING_LOC_AVAILABLE) {
                        Vcb->NoFreeRelocationSpaceVolumeAction = UDF_PART_DAMAGED_RW;
                    }
                }
            }
 
/*
            RtlCopyMemory((int8*)(RelocMap+Vcb->SparingCount),
                          (int8*)(SparTable+1), NewSize);
            Vcb->SparingCount += NewSize/sizeof(SPARING_ENTRY);
*/
            if(Vcb->SparingTableCount >= MAX_SPARING_TABLE_LOCATIONS) {
                UDFPrint(("    too many Sparing Tables\n"));
                break;
            }
        }
    }
    Vcb->SparingTable = RelocMap;
    MyFreePool__(SparTable);
    return STATUS_SUCCESS;
} // end UDFLoadSparingTable()

Referenced by UDFLoadLogicalVol().

◆ UDFLoadVAT()

OSSTATUS UDFLoadVAT	(	IN PVCB	Vcb,
		IN uint32	PartNdx
	)

Definition at line 3602 of file udf_info.cpp.

{
    lb_addr VatFELoc;
    OSSTATUS status;
    PUDF_FILE_INFO VatFileInfo;
    uint32 len, i=0, j, to_read;
    uint32 Offset, hdrOffset;
    SIZE_T ReadBytes;
    uint32 root;
    uint16 PartNum;
//    uint32 VatFirstLba = 0;
    int8* VatOldData;
    uint32 VatLba[6] = { Vcb->LastLBA,
                        Vcb->LastLBA - 2,
                        Vcb->LastLBA - 3,
                        Vcb->LastLBA - 5,
                        Vcb->LastLBA - 7,
                        0 };
 
    if(Vcb->Vat) return STATUS_SUCCESS;
    if(!Vcb->CDR_Mode) return STATUS_SUCCESS;
    // disable VAT for now. We'll reenable it if VAT is successfuly loaded
    Vcb->CDR_Mode = FALSE;
    PartNum = Vcb->Partitions[PartNdx].PartitionNum;
    root = Vcb->Partitions[PartNdx].PartitionRoot;
    if(Vcb->LBlockSize != Vcb->BlockSize) {
        // don't know how to operate... :(((
        return STATUS_UNRECOGNIZED_VOLUME;
    }
    if((Vcb->LastTrackNum > 1) &&
       (Vcb->LastLBA == Vcb->TrackMap[Vcb->LastTrackNum-1].LastLba)) {
        UDFPrint(("Hardware Read-only volume\n"));
        Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
    }
 
    VatFileInfo = Vcb->VatFileInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT, sizeof(UDF_FILE_INFO), MEM_VATFINF_TAG);
    if(!VatFileInfo) return STATUS_INSUFFICIENT_RESOURCES;
    // load VAT FE (we know its location)
    VatFELoc.partitionReferenceNum = PartNum;
retry_load_vat:
    VatFELoc.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, VatLba[i]);
    if(!OS_SUCCESS(status = UDFOpenRootFile__(Vcb, &VatFELoc, VatFileInfo))) {
        UDFCleanUpFile__(Vcb, VatFileInfo);
        // try another location
        i++;
        if( VatLba[i] &&
           (status != STATUS_FILE_CORRUPT_ERROR) &&
           (status != STATUS_CRC_ERROR)) goto retry_load_vat;
        MyFreePool__(VatFileInfo);
        Vcb->VatFileInfo = NULL;
        return status;
    }
    len = (uint32)UDFGetFileSize(VatFileInfo);
    if(Vcb->Partitions[PartNdx].PartitionType == UDF_VIRTUAL_MAP15) {
        // load Vat 1.50 header
        UDFPrint(("Load VAT 1.50\n"));
        VirtualAllocationTable15* Buf;
        if(((icbtag*)(VatFileInfo->Dloc->FileEntry+1))->fileType != UDF_FILE_TYPE_VAT15) {
            status = STATUS_FILE_CORRUPT_ERROR;
            goto err_vat_15;
        }
        Buf = (VirtualAllocationTable15*)MyAllocatePool__(NonPagedPool, sizeof(VirtualAllocationTable15));
        if(!Buf) {
err_vat_15_2:
            status = STATUS_INSUFFICIENT_RESOURCES;
err_vat_15:
            UDFCloseFile__(Vcb, VatFileInfo);
            UDFCleanUpFile__(Vcb, VatFileInfo);
            MyFreePool__(VatFileInfo);
            Vcb->VatFileInfo = NULL;
            return status;
        }
        Offset = 0;
        to_read =
        hdrOffset = len - sizeof(VirtualAllocationTable15);
        MyFreePool__(Buf);
 
        Vcb->minUDFReadRev  =
        Vcb->minUDFWriteRev =
        Vcb->maxUDFWriteRev = 0x0150;
 
        Vcb->numFiles =
        Vcb->numDirs  = -1;
 
    } else
    if(Vcb->Partitions[PartNdx].PartitionType == UDF_VIRTUAL_MAP20) {
        // load Vat 2.00 header
        UDFPrint(("Load VAT 2.00\n"));
        VirtualAllocationTable20* Buf;
        if(((icbtag*)(VatFileInfo->Dloc->FileEntry+1))->fileType != UDF_FILE_TYPE_VAT20) {
            status = STATUS_FILE_CORRUPT_ERROR;
            goto err_vat_15;
        }
        Buf = (VirtualAllocationTable20*)MyAllocatePool__(NonPagedPool, sizeof(VirtualAllocationTable20));
        if(!Buf) goto err_vat_15_2;
        Offset = Buf->lengthHeader;
        to_read = len - Offset;
        hdrOffset = 0;
        MyFreePool__(Buf);
 
        Vcb->minUDFReadRev  = Buf->minReadRevision;
        Vcb->minUDFWriteRev = Buf->minWriteRevision;
        Vcb->maxUDFWriteRev = Buf->maxWriteRevision;
 
        Vcb->numFiles = Buf->numFIDSFiles;
        Vcb->numDirs  = Buf->numFIDSDirectories;
 
    } else {
        // unknown (or wrong) VAT format
        UDFPrint(("unknown (or wrong) VAT format\n"));
        status = STATUS_FILE_CORRUPT_ERROR;
        goto err_vat_15;
    }
    // read VAT & remember old version
    Vcb->Vat = (uint32*)DbgAllocatePool(NonPagedPool, (Vcb->LastPossibleLBA+1)*sizeof(uint32) );
    if(!Vcb->Vat) {
        goto err_vat_15_2;
    }
    // store base version of VAT in memory
    VatOldData = (int8*)DbgAllocatePool(PagedPool, len);
    if(!VatOldData) {
        DbgFreePool(Vcb->Vat);
        Vcb->Vat = NULL;
        goto err_vat_15_2;
    }
    status = UDFReadFile__(Vcb, VatFileInfo, 0, len, FALSE, VatOldData, &ReadBytes);
    if(!OS_SUCCESS(status)) {
        UDFCloseFile__(Vcb, VatFileInfo);
        UDFCleanUpFile__(Vcb, VatFileInfo);
        MyFreePool__(VatFileInfo);
        DbgFreePool(Vcb->Vat);
        DbgFreePool(VatOldData);
        Vcb->Vat = NULL;
        Vcb->VatFileInfo = NULL;
    } else {
        // initialize VAT
        // !!! NOTE !!!
        // Both VAT copies - in-memory & on-disc
        // contain _relative_ addresses
        len = Vcb->NWA - root;
        for(i=0; i<=len; i++) {
            Vcb->Vat[i] = i;
        }
        RtlCopyMemory(Vcb->Vat, VatOldData+Offset, to_read);
        Vcb->InitVatCount =
        Vcb->VatCount = to_read/sizeof(uint32);
        Vcb->VatPartNdx = PartNdx;
        Vcb->CDR_Mode = TRUE;
        len = Vcb->VatCount;
        RtlFillMemory(&(Vcb->Vat[Vcb->NWA-root]), (Vcb->LastPossibleLBA-Vcb->NWA+1)*sizeof(uint32), 0xff);
        // sync VAT and FSBM
        for(i=0; i<len; i++) {
            if(Vcb->Vat[i] == UDF_VAT_FREE_ENTRY) {
                UDFSetFreeBit(Vcb->FSBM_Bitmap, root+i);
            }
        }
        len = Vcb->LastPossibleLBA;
        // "pre-format" reserved area
        for(i=Vcb->NWA; i<len;) {
            for(j=0; (j<PACKETSIZE_UDF) && (i<len); j++, i++)
                UDFSetFreeBit(Vcb->FSBM_Bitmap, i);
            for(j=0; (j<7) && (i<len); j++, i++)
                UDFSetUsedBit(Vcb->FSBM_Bitmap, i);
        }
        DbgFreePool(VatOldData);
    }
    return status;
} // end UDFLoadVAT()

Referenced by UDFLoadPartDesc().

◆ UDFLocateAnyParallelFI()

PUDF_FILE_INFO UDFLocateAnyParallelFI ( PUDF_FILE_INFO fi )

Definition at line 1439 of file dirtree.cpp.

{
    if(!fi->ParentFile) {
        if(fi->NextLinkedFile == fi)
            return NULL;
        return fi->NextLinkedFile;
    }
    PUDF_FILE_INFO    ParFileInfo = fi->NextLinkedFile;
    PUDF_DATALOC_INFO Dloc = fi->ParentFile->Dloc;
    uint_di i = fi->Index;
    BOOLEAN NotFound = TRUE;
    while((ParFileInfo != fi) &&
          (NotFound =
           ((ParFileInfo->Index != i) ||
            (ParFileInfo->ParentFile->Dloc != Dloc))) ) {
        ParFileInfo = ParFileInfo->NextLinkedFile;
    }
/*    if(NotFound) {
        if((ParFileInfo->Index == i) &&
           (ParFileInfo->ParentFile->Dloc == Dloc))
            return ParFileInfo;
        return NULL;
    }
    return ParFileInfo;*/
    return NotFound ? NULL : ParFileInfo;
//   BrutePoint();
} // end UDFLocateAnyParallelFI()

Referenced by UDFCleanUpFile__().

◆ UDFLocateLbaInExtent()

ULONG UDFLocateLbaInExtent	(	IN PVCB	Vcb,
		IN PEXTENT_MAP	Extent,
		IN lba_t	lba
	)

Definition at line 116 of file extent.cpp.

{
    uint32 l, BSh = Vcb->BlockSizeBits;
    uint32 i=0;
 
    while((l = ((Extent->extLength & UDF_EXTENT_LENGTH_MASK) >> BSh))) {
 
        if(Extent->extLocation   >= lba &&
           Extent->extLocation+l <  lba) {
            return i;
        }
        i++; //frag offset
        Extent++;
    }
    return LBA_OUT_OF_EXTENT;// index of item in extent, containing out Lba
} // end UDFLocateLbaInExtent()

Referenced by UDFUpdateNonAllocated().

◆ UDFLocateParallelFI()

PUDF_FILE_INFO UDFLocateParallelFI	(	PUDF_FILE_INFO	di,
		uint_di	i,
		PUDF_FILE_INFO	fi
	)

Definition at line 1417 of file dirtree.cpp.

{
    PUDF_FILE_INFO    ParFileInfo = fi->NextLinkedFile;
//    PUDF_DATALOC_INFO Dloc = di->Dloc;
    while((ParFileInfo != fi) &&
          ((ParFileInfo->ParentFile != di) ||
           (ParFileInfo->Index != i)) ) {
        ParFileInfo = ParFileInfo->NextLinkedFile;
    }
    return ParFileInfo;
//   BrutePoint();
} // end UDFLocateParallelFI()

Referenced by UDFDirIndexScan(), UDFOpenFile__(), and UDFOpenStreamDir__().

◆ UDFLongAllocDescToMapping()

PEXTENT_MAP UDFLongAllocDescToMapping	(	IN PVCB	Vcb,
		IN PLONG_AD	AllocDesc,
		IN uint32	AllocDescLength,
		IN uint32	SubCallCount,
		OUT PEXTENT_INFO	AllocLoc
	)

Definition at line 457 of file extent.cpp.

{
    uint32 i, lim, l, len, type;
//    uint32 BSh;
    PEXTENT_MAP Extent, Extent2, AllocMap;
    EXTENT_AD AllocExt;
    PALLOC_EXT_DESC NextAllocDesc;
    SIZE_T ReadBytes;
    EXTENT_INFO NextAllocLoc;
 
    ExtPrint(("UDFLongAllocDescToMapping: len=%x\n", AllocDescLength));
 
    if(SubCallCount > ALLOC_DESC_MAX_RECURSE) return NULL;
 
//    BSh = Vcb->BlockSizeBits;
    l = ((lim = (AllocDescLength/sizeof(LONG_AD))) + 1 ) * sizeof(EXTENT_AD);
    Extent = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool, l, MEM_EXTMAP_TAG);
    if(!Extent) return NULL;
 
    NextAllocLoc.Offset = 0;
 
    for(i=0;i<lim;i++) {
        type = AllocDesc[i].extLength >> 30;
        len  = AllocDesc[i].extLength & UDF_EXTENT_LENGTH_MASK;
        ExtPrint(("LnExt: type %x, loc %x (%x:%x), len %x\n", type, UDFPartLbaToPhys(Vcb,&(AllocDesc[i].extLocation)),
            AllocDesc[i].extLocation.partitionReferenceNum, AllocDesc[i].extLocation.logicalBlockNum,
            len));
        if(type == EXTENT_NEXT_EXTENT_ALLOCDESC) {
            // read next frag of allocation descriptors if encountered
            if(len < sizeof(ALLOC_EXT_DESC)) {
                MyFreePool__(Extent);
                return NULL;
            }
            NextAllocDesc = (PALLOC_EXT_DESC)MyAllocatePoolTag__(NonPagedPool, len, MEM_ALLOCDESC_TAG);
            if(!NextAllocDesc) {
                MyFreePool__(Extent);
                return NULL;
            }
            // record information about this frag
            AllocExt.extLength = len;
            AllocExt.extLocation = UDFPartLbaToPhys(Vcb,&(AllocDesc[i].extLocation));
            if(AllocExt.extLocation == LBA_OUT_OF_EXTENT) {
                UDFPrint(("bad address\n"));
                MyFreePool__(NextAllocDesc);
                MyFreePool__(Extent);
                return NULL;
            }
            NextAllocLoc.Mapping =
            AllocMap = UDFExtentToMapping(&AllocExt);
            NextAllocLoc.Length = len;
            if(!AllocMap) {
                MyFreePool__(NextAllocDesc);
                MyFreePool__(Extent);
                return NULL;
            }
            AllocLoc->Mapping = UDFMergeMappings(AllocLoc->Mapping, AllocMap);
            if(!AllocLoc->Mapping ||
            // read this frag
               !OS_SUCCESS(UDFReadExtent(Vcb, &NextAllocLoc,
                                0, len, FALSE, (int8*)NextAllocDesc, &ReadBytes)))
            {
                MyFreePool__(AllocMap);
                MyFreePool__(NextAllocDesc);
                MyFreePool__(Extent);
                return NULL;
            }
            MyFreePool__(AllocMap);
            // check integrity
            if((NextAllocDesc->descTag.tagIdent != TID_ALLOC_EXTENT_DESC) ||
               (NextAllocDesc->lengthAllocDescs > (len - sizeof(ALLOC_EXT_DESC))) ) {
                UDFPrint(("Integrity check failed\n"));
                UDFPrint(("NextAllocDesc->descTag.tagIdent = %x\n", NextAllocDesc->descTag.tagIdent));
                UDFPrint(("NextAllocDesc->lengthAllocDescs = %x\n", NextAllocDesc->lengthAllocDescs));
                UDFPrint(("len = %x\n", len));
                MyFreePool__(NextAllocDesc);
                MyFreePool__(Extent);
                return NULL;
            }
            // perform recursive call to obtain mapping
            Extent2 = UDFLongAllocDescToMapping(Vcb, (PLONG_AD)(NextAllocDesc+1),
                                      NextAllocDesc->lengthAllocDescs, SubCallCount+1, AllocLoc);
            if(!Extent2) {
                MyFreePool__(NextAllocDesc);
                MyFreePool__(Extent);
                return NULL;
            }
            // and merge this 2 mappings into 1
            Extent[i].extLength = 0;
            Extent[i].extLocation = 0;
            Extent = UDFMergeMappings(Extent, Extent2);
            MyFreePool__(Extent2);
            return Extent;
        }
        //
        Extent[i].extLength = len;
#ifdef UDF_CHECK_EXTENT_SIZE_ALIGNMENT
        ASSERT(!(len & (Vcb->LBlockSize-1) ));
#endif //UDF_CHECK_EXTENT_SIZE_ALIGNMENT
        Extent[i].extLength = (len+Vcb->LBlockSize-1) & ~(Vcb->LBlockSize-1);
        // Note: for compatibility Adaptec DirectCD we check 'len' here
        //       That strange implementation records bogus extLocation in terminal entries
        if(type != EXTENT_NOT_RECORDED_NOT_ALLOCATED && len) {
            Extent[i].extLocation = UDFPartLbaToPhys(Vcb,&(AllocDesc[i].extLocation));
            if(Extent[i].extLocation == LBA_OUT_OF_EXTENT) {
                UDFPrint(("bad address (2)\n"));
                MyFreePool__(Extent);
                return NULL;
            }
        } else {
            Extent[i].extLocation = 0;
        }
        if(!len) {
            // some UDF implementations set strange AllocDesc sequence length,
            // but terminates it with zeros in proper place, so handle
            // this case
            Extent[i].extLocation = 0;
            return Extent;
        }
        Extent[i].extLength |= (type << 30);
    }
    // set terminator
    Extent[i].extLength = 0;
    Extent[i].extLocation = 0;
 
    return Extent;
} // end UDFLongAllocDescToMapping()

Referenced by UDFLongAllocDescToMapping(), and UDFReadMappingFromXEntry().

◆ UDFMarkAllocatedAsNotXXX()

OSSTATUS UDFMarkAllocatedAsNotXXX	(	IN PVCB	Vcb,
		IN int64	Offset,
		IN uint32	Length,
		IN PEXTENT_INFO	ExtInfo,
		IN BOOLEAN	Deallocate
	)

Definition at line 2094 of file extent.cpp.

{
    uint32 i, len, /*lba, d,*/ l, BOffs, j;
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    PEXTENT_MAP NewExtent;
//    EXTENT_MAP TmpExtent;
//    uint32 BS = Vcb->BlockSize;
    uint32 BSh = Vcb->BlockSizeBits;
//    OSSTATUS status;
    EXTENT_INFO TmpExtInf;
    uint32 aLen, sLen;
    uint32 flags;
    uint32 target_flags = Deallocate ?
                             EXTENT_NOT_RECORDED_NOT_ALLOCATED :
                             EXTENT_NOT_RECORDED_ALLOCATED;
    SIZE_T LBS = Vcb->LBlockSize;
    EXTENT_MAP DeadMapping[2];
    // I don't know what else comment can be added here.
    // Just belive that it works
    /*lba = */
#ifndef ALLOW_SPARSE
    if(Deallocate) {
        BrutePoint();
    }
#endif
 
    AdPrint(("Alloc->Not ExtInfo %x, Extent %x\n", ExtInfo, Extent));
 
    DeadMapping[0].extLocation =
        UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, Offset, NULL, NULL, NULL, &i);
    if(i == (ULONG)-1) {
        BrutePoint();
        return STATUS_INVALID_PARAMETER;
    }
    DeadMapping[0].extLength = Extent[i].extLength;
    DeadMapping[1].extLocation =
    DeadMapping[1].extLength = 0;
    TmpExtInf.Mapping = (PEXTENT_MAP)&DeadMapping;
    TmpExtInf.Offset = 0;
    TmpExtInf.Length = Extent[i].extLength & UDF_EXTENT_LENGTH_MASK;
 
    flags = Extent[i].extLength >> 30;
    if(flags == target_flags) return STATUS_SUCCESS;
 
//    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, Extent[0].extLocation);
    BOffs = (uint32)(Offset >> BSh);
    // length of existing Alloc-(Not-)Rec frag (in sectors)
    sLen = (( (((uint32)Offset) & (LBS-1)) + Length+LBS-1) & ~(LBS-1)) >> BSh;
    // required deallocation length increment (in bytes)
    aLen = (uint32)( ((Offset+Length+LBS-1) & ~(LBS-1)) - (Offset & ~(LBS-1)) );
 
    l=0;
    for(j=0; j<i; j++) {
        l += (uint32)((Extent[j].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
    }
    flags <<= 30;
    if( (l == BOffs) && (((Extent[j].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) == sLen) ) {
        // xxxxxx ->  RRRRRR
        Extent[i].extLocation = 0;
        Extent[i].extLength = (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) | flags;
        NewExtent = Extent;
        Extent = NULL;
        AdPrint(("Alloc->Not (1) NewExtent = Extent = %x\n", NewExtent));
    } else
    if(l < BOffs) {
        // .ExtLength, BOffs & l are already aligned...
        if( (((Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) - (BOffs-l)) > sLen ) {
            // xxxxxx ->  xxRRxx
            NewExtent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + 2*sizeof(EXTENT_MAP) );
            if(!NewExtent) {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+3]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLength = (BOffs - l) << BSh;
            NewExtent[i].extLength |= flags;
            NewExtent[i+1].extLocation = 0;
            NewExtent[i+1].extLength = aLen | (target_flags << 30);
            NewExtent[i+2].extLength = (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) -
                                       (NewExtent[i].extLength & UDF_EXTENT_LENGTH_MASK) - aLen ;
            NewExtent[i+2].extLocation = Extent[i].extLocation +
                                       (NewExtent[i+2].extLength >> BSh);
            NewExtent[i+2].extLength |= flags;
            AdPrint(("Alloc->Not (2) new %x\n", NewExtent));
        } else {
            // xxxxxx ->  xxRRRR
            NewExtent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + sizeof(EXTENT_MAP) );
            if(!NewExtent) {
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+2]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLength = ((BOffs - l) << BSh) | flags;
            NewExtent[i+1].extLocation = 0;
            NewExtent[i+1].extLength = aLen | (target_flags << 30);
            AdPrint(("Alloc->Not (3) new %x\n", NewExtent));
        }
    } else {
        // xxxxxx ->  RRRRxx
        NewExtent = (PEXTENT_MAP)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + sizeof(EXTENT_MAP) );
        if(!NewExtent) {
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
        RtlCopyMemory((int8*)&(NewExtent[i+2]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
        NewExtent[i+1].extLength = (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) - aLen;
        NewExtent[i+1].extLength |= flags;
        NewExtent[i].extLocation = 0;
        NewExtent[i].extLength = aLen | (target_flags << 30);
        AdPrint(("Alloc->Not (4) new %x\n", NewExtent));
    }
 
    if(Deallocate)
        UDFMarkSpaceAsXXX(Vcb, (-1), TmpExtInf.Mapping, AS_DISCARDED); // mark as free
 
    ExtInfo->Modified = TRUE;
    ExtInfo->Mapping = NewExtent;
 
    AdPrint(("Alloc->Not: ExtInfo %x, Extent %x\n", ExtInfo, ExtInfo->Mapping));
 
    if(Extent) {
        AdPrint(("Alloc->Not kill %x\n", Extent));
        MyFreePool__(Extent);
    } else {
        AdPrint(("Alloc->Not keep %x\n", Extent));
    }
 
    return STATUS_SUCCESS;
} // end UDFMarkAllocatedAsNotXXX()

◆ UDFMarkAllocatedAsRecorded()

OSSTATUS UDFMarkAllocatedAsRecorded	(	IN PVCB	Vcb,
		IN int64	Offset,
		IN uint32	Length,
		IN PEXTENT_INFO	ExtInfo
	)

Definition at line 1814 of file extent.cpp.

{
    uint32 i, len, lba, sLen;
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    PEXTENT_MAP NewExtent;
    uint32 BS = Vcb->BlockSize;
    uint32 LBS = Vcb->LBlockSize;
    uint32 BSh = Vcb->BlockSizeBits;
    BOOLEAN TryPack = TRUE;
#ifdef UDF_DBG
    int64 check_size;
#endif //UDF_DBG
    // I don't know what else comment can be added here.
    // Just belive that it works
    lba = UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, (Offset & ~((int64)LBS-1)), NULL, NULL, NULL, &i);
    if(i == (ULONG)-1) return STATUS_INVALID_PARAMETER;
#ifdef UDF_DBG
    check_size = UDFGetExtentLength(ExtInfo->Mapping);
    ASSERT(!(check_size & (LBS-1)));
#endif //UDF_DBG
    AdPrint(("Alloc->Rec  ExtInfo %x, Extent %x\n", ExtInfo, Extent));
    if((Extent[i].extLength >> 30) == EXTENT_RECORDED_ALLOCATED) return STATUS_SUCCESS;
    if((Extent[i].extLength >> 30) == EXTENT_NOT_RECORDED_NOT_ALLOCATED) return STATUS_INVALID_PARAMETER;
    ASSERT((((uint32)Offset) & (LBS-1)) + Length <= (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK));
    sLen = (( (((uint32)Offset) & (LBS-1)) + Length+LBS-1) & ~(LBS-1)) >> BSh;
    if((Extent[i].extLocation == lba) && (((Extent[i].extLength & UDF_EXTENT_LENGTH_MASK ) >> BSh) == sLen)) {
        // xxxxxx ->  RRRRRR
        Extent[i].extLength &= UDF_EXTENT_LENGTH_MASK;
//      Extent[i].extLength |= (EXTENT_RECORDED_ALLOCATED << 30); // = 0;
        ExtInfo->Modified = TRUE;
        if(i &&
           ((Extent[i-1].extLength >> 30) == EXTENT_RECORDED_ALLOCATED) &&
           (lba == (Extent[i-1].extLocation + ((len = Extent[i-1].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh))) &&
           ((len + (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK)) <= UDF_MAX_EXTENT_LENGTH) &&
           (i == ((UDFGetMappingLength(Extent) / sizeof(EXTENT_MAP)) - 2)) &&
           TRUE) {
            // make optimization for sequentially written files
            Extent[i-1].extLength += Extent[i].extLength;
            Extent[i].extLocation = 0;
            Extent[i].extLength = 0;
        } else {
            UDFPackMapping(Vcb, ExtInfo);
        }
        AdPrint(("Alloc->Rec (1) new %x\n", ExtInfo->Mapping));
#ifdef UDF_DBG
        ASSERT(check_size == UDFGetExtentLength(ExtInfo->Mapping));
#endif
        AdPrint(("Alloc->Rec: ExtInfo %x, Extent %x\n", ExtInfo, ExtInfo->Mapping));
        return STATUS_SUCCESS;
    }
    if(Extent[i].extLocation < lba) {
        if(  (((Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) - (lba - Extent[i].extLocation))
             > sLen ) {
            // xxxxxx ->  xxRRxx
            NewExtent = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , UDFGetMappingLength(Extent) + sizeof(EXTENT_MAP)*2,
                                                               MEM_EXTMAP_TAG);
            if(!NewExtent) return STATUS_INSUFFICIENT_RESOURCES;
            Extent[i].extLength &= UDF_EXTENT_LENGTH_MASK;
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+3]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLocation = Extent[i].extLocation;
            NewExtent[i].extLength = (lba - Extent[i].extLocation) << BSh;
            NewExtent[i+1].extLength = (Length+BS-1) & ~(BS-1);
            NewExtent[i+1].extLocation = lba;
            NewExtent[i+2].extLength = Extent[i].extLength - NewExtent[i].extLength - NewExtent[i+1].extLength;
            NewExtent[i+2].extLocation = lba + ((Length+BS-1) >> BSh);
            ASSERT(!(NewExtent[i].extLength >> 30));
            ASSERT(!(NewExtent[i+2].extLength >> 30));
            NewExtent[i].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
            NewExtent[i+2].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
            TryPack = FALSE;
            AdPrint(("Alloc->Rec (2) new %x\n", NewExtent));
        } else {
            // xxxxxx ->  xxRRRR
            NewExtent = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , UDFGetMappingLength(Extent) + sizeof(EXTENT_MAP),
                                                               MEM_EXTMAP_TAG);
            if(!NewExtent) return STATUS_INSUFFICIENT_RESOURCES;
            Extent[i].extLength &= UDF_EXTENT_LENGTH_MASK;
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+2]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLocation = Extent[i].extLocation;
            NewExtent[i].extLength = (lba - Extent[i].extLocation) << BSh;
            NewExtent[i+1].extLength = Extent[i].extLength - NewExtent[i].extLength;
            NewExtent[i+1].extLocation = lba;
            ASSERT(!(NewExtent[i].extLength >> 30));
            NewExtent[i].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
            AdPrint(("Alloc->Rec (3) new %x\n", NewExtent));
        }
    } else {
        // xxxxxx ->  RRRRxx
        NewExtent = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , UDFGetMappingLength(Extent) + sizeof(EXTENT_MAP),
                                                           MEM_EXTMAP_TAG);
        if(!NewExtent) return STATUS_INSUFFICIENT_RESOURCES;
        Extent[i].extLength &= UDF_EXTENT_LENGTH_MASK;
        RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
        RtlCopyMemory((int8*)&(NewExtent[i+2]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
        NewExtent[i].extLocation = Extent[i].extLocation;
        NewExtent[i].extLength = (Length+BS-1) & ~(BS-1);
        NewExtent[i+1].extLength = Extent[i].extLength - NewExtent[i].extLength;
        NewExtent[i+1].extLocation = Extent[i].extLocation + (NewExtent[i].extLength >> BSh);
        ASSERT(!(NewExtent[i+1].extLength >> 30));
        NewExtent[i+1].extLength |= (EXTENT_NOT_RECORDED_ALLOCATED << 30);
        AdPrint(("Alloc->Rec (4) new %x\n", NewExtent));
    }
 
    //ASSERT(check_size == UDFGetExtentLength(Extent));
    //ASSERT(!(check_size & (LBS-1)));
 
    AdPrint(("Free Extent %x (new %x)\n", Extent, NewExtent));
    MyFreePool__(Extent);
    ExtInfo->Modified = TRUE;
    ExtInfo->Mapping = NewExtent;
    if(TryPack)
        UDFPackMapping(Vcb, ExtInfo);
#ifdef UDF_DBG
    ASSERT(check_size == UDFGetExtentLength(ExtInfo->Mapping));
    ASSERT(!(check_size & (LBS-1)));
#endif
 
    AdPrint(("Alloc->Rec: ExtInfo %x, Extent %x\n", ExtInfo, ExtInfo->Mapping));
 
    return STATUS_SUCCESS;
} // end UDFMarkAllocatedAsRecorded()

Referenced by UDFWriteExtent().

◆ UDFMarkNotAllocatedAsAllocated()

OSSTATUS UDFMarkNotAllocatedAsAllocated	(	IN PVCB	Vcb,
		IN int64	Offset,
		IN uint32	Length,
		IN PEXTENT_INFO	ExtInfo
	)

Definition at line 1948 of file extent.cpp.

{
    uint32 i, len, /*lba,*/ d, l, BOffs, j;
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    PEXTENT_MAP NewExtent;
//    uint32 BS = Vcb->BlockSize;
    uint32 BSh = Vcb->BlockSizeBits;
    OSSTATUS status;
    EXTENT_INFO TmpExtInf;
    SIZE_T aLen, sLen;
    SIZE_T LBS = Vcb->LBlockSize;
    // I don't know what else comment can be added here.
    // Just belive that it works
    /*lba = */
#ifndef ALLOW_SPARSE
    BrutePoint();
#endif
    AdPrint(("Not->Alloc  ExtInfo %x, Extent %x\n", ExtInfo, Extent));
    UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, Offset, NULL, NULL, NULL, &i);
    if(i == (ULONG)-1) return STATUS_INVALID_PARAMETER;
    if((Extent[i].extLength >> 30) != EXTENT_NOT_RECORDED_NOT_ALLOCATED) return STATUS_SUCCESS;
 
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, Extent[0].extLocation);
    BOffs = (uint32)(Offset >> BSh);
    // length of existing Not-Alloc-Not-Rec frag
    sLen = (( (((uint32)Offset) & (LBS-1)) + Length+LBS-1) & ~(LBS-1)) >> BSh;
    // required allocation length increment (in bytes)
    aLen = (uint32)( ((Offset+Length+LBS-1) & ~(LBS-1)) - (Offset & ~(LBS-1)));
 
    // try to extend previous frag or allocate space _after_ it to
    // avoid backward seeks, if previous frag is not Not-Rec-Not-Alloc
    if(i && ((Extent[i-1].extLength >> 30) != EXTENT_NOT_RECORDED_NOT_ALLOCATED) ) {
        status = UDFAllocFreeExtent(Vcb, aLen,
                                      Extent[i-1].extLocation + ((Extent[i-1].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh),
                                      min(UDFPartEnd(Vcb, PartNum), Extent[i-1].extLocation + ((Extent[i-1].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) + sLen ),
                                      &TmpExtInf, ExtInfo->Flags /*& EXTENT_FLAG_ALLOC_MASK*/);
        if(status == STATUS_DISK_FULL)
            // if there are not enough free blocks after that frag...
            goto try_alloc_anywhere;
    } else {
try_alloc_anywhere:
        // ... try to alloc required disk space anywhere
        status = UDFAllocFreeExtent(Vcb, aLen,
                                      UDFPartStart(Vcb, PartNum),
                                      UDFPartEnd(Vcb, PartNum),
                                      &TmpExtInf, ExtInfo->Flags /*& EXTENT_FLAG_ALLOC_MASK*/);
    }
    // check for successfull allocation
    if(!OS_SUCCESS(status)) {
        AdPrint(("Not->Alloc  no free\n"));
        return status;
    }
    // get number of frags in allocated block
    d = (UDFGetMappingLength(TmpExtInf.Mapping) / sizeof(EXTENT_MAP)) - 1;
    // calculate number of existing blocks before the frag to be changed
    l=0;
    for(j=0; j<i; j++) {
        l += (uint32)((Extent[j].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
    }
    // and now just update mapping...
    if( (l == BOffs) && (((Extent[j].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) == sLen) ) {
        // xxxxxx ->  RRRRRR
        // (d-1) - since we have to raplace last frag of Extent with 1 or more frags of TmpExtInf.Mapping
        NewExtent = (PEXTENT_AD)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + (d-1)*sizeof(EXTENT_MAP) );
        if(!NewExtent) {
            MyFreePool__(TmpExtInf.Mapping);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
        RtlCopyMemory((int8*)&(NewExtent[i]), (int8*)(TmpExtInf.Mapping), d*sizeof(EXTENT_MAP) );
        RtlCopyMemory((int8*)&(NewExtent[i+d]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
        AdPrint(("Not->Alloc (1) new %x\n", NewExtent));
    } else
    if(l < BOffs) {
        // .ExtLength, BOffs & l are already aligned...
        if( (((Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh) - (BOffs-l)) > sLen ) {
            // xxxxxx ->  xxRRxx
            NewExtent = (PEXTENT_AD)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + (d+1)*sizeof(EXTENT_MAP) );
            if(!NewExtent) {
                MyFreePool__(TmpExtInf.Mapping);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+1]), (int8*)(TmpExtInf.Mapping), d*sizeof(EXTENT_MAP) );
            RtlCopyMemory((int8*)&(NewExtent[i+d+2]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLocation = 0;
            NewExtent[i].extLength = (BOffs - l) << BSh;
            NewExtent[i+d+1].extLength = Extent[i].extLength - NewExtent[i].extLength - aLen;
            NewExtent[i+d+1].extLocation = 0;
            NewExtent[i].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
            NewExtent[i+d+1].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
            AdPrint(("Not->Alloc (2) new %x\n", NewExtent));
        } else {
            // xxxxxx ->  xxRRRR
            NewExtent = (PEXTENT_AD)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + d*sizeof(EXTENT_MAP) );
            if(!NewExtent) {
                MyFreePool__(TmpExtInf.Mapping);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
            RtlCopyMemory((int8*)&(NewExtent[i+1]), (int8*)(TmpExtInf.Mapping), d*sizeof(EXTENT_MAP) );
            RtlCopyMemory((int8*)&(NewExtent[i+d+1]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
            NewExtent[i].extLocation = 0;
            NewExtent[i].extLength = (BOffs - l) << BSh;
            NewExtent[i].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
            AdPrint(("Not->Alloc (3) new %x\n", NewExtent));
        }
    } else {
        // xxxxxx ->  RRRRxx
        NewExtent = (PEXTENT_AD)MyAllocatePool__(NonPagedPool, UDFGetMappingLength(Extent) + d*sizeof(EXTENT_MAP) );
        if(!NewExtent) {
            MyFreePool__(TmpExtInf.Mapping);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlCopyMemory((int8*)NewExtent, (int8*)Extent, i*sizeof(EXTENT_MAP));
        RtlCopyMemory((int8*)&(NewExtent[i]), (int8*)(TmpExtInf.Mapping), d*sizeof(EXTENT_MAP) );
        RtlCopyMemory((int8*)&(NewExtent[i+d+1]), (int8*)&(Extent[i+1]), len = UDFGetMappingLength(&(Extent[i+1])) );
        NewExtent[i+d].extLength = (Extent[i].extLength & UDF_EXTENT_LENGTH_MASK) - aLen;
        NewExtent[i+d].extLocation = 0;
        NewExtent[i+d].extLength |= (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
        AdPrint(("Not->Alloc (4) new %x\n", NewExtent));
    }
 
    AdPrint(("Free Extent %x, TmpExtInf.Mapping, (new %x)\n", Extent, TmpExtInf.Mapping, NewExtent));
    MyFreePool__(Extent);
    MyFreePool__(TmpExtInf.Mapping);
    ExtInfo->Modified = TRUE;
    ExtInfo->Mapping = NewExtent;
 
    AdPrint(("Not->Alloc: ExtInfo %x, Extent %x\n", ExtInfo, ExtInfo->Mapping));
 
    return STATUS_SUCCESS;
} // end UDFMarkNotAllocatedAsAllocated()

Referenced by UDFWriteExtent().

◆ UDFMarkSpaceAsXXX_()

void UDFMarkSpaceAsXXX_	(	IN PVCB	Vcb,
		IN PEXTENT_MAP	Map,
		IN uint32	asXXX
	)

Definition at line 928 of file alloc.cpp.

{
    if(!Map) return;
    if(!Map[0].extLength) {
#ifdef UDF_DBG
        ASSERT(!Map[0].extLocation);
#endif // UDF_DBG
        return;
    }
 
    UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
#ifdef UDF_TRACK_ONDISK_ALLOCATION
    UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX, FE_lba, BugCheckId, Line);
#else //UDF_TRACK_ONDISK_ALLOCATION
    UDFMarkSpaceAsXXXNoProtect_(Vcb, Map, asXXX);
#endif //UDF_TRACK_ONDISK_ALLOCATION
    UDFReleaseResource(&(Vcb->BitMapResource1));
 
} // end UDFMarkSpaceAsXXX_()

◆ UDFMarkSpaceAsXXXNoProtect_()

void UDFMarkSpaceAsXXXNoProtect_	(	IN PVCB	Vcb,
		IN PEXTENT_MAP	Map,
		IN uint32	asXXX
	)

Definition at line 782 of file alloc.cpp.

{
    uint32 i=0;
    uint32 lba, j, len, BS, BSh;
    uint32 root;
    BOOLEAN asUsed = (asXXX == AS_USED || (asXXX & AS_BAD));
#ifdef UDF_TRACK_ONDISK_ALLOCATION
    BOOLEAN bit_before, bit_after;
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
 
    if(!Map) return;
 
    BS = Vcb->BlockSize;
    BSh = Vcb->BlockSizeBits;
    Vcb->BitmapModified = TRUE;
    UDFSetModified(Vcb);
    // walk through all frags in data area specified
    while(Map[i].extLength & UDF_EXTENT_LENGTH_MASK) {
        if((Map[i].extLength >> 30) == EXTENT_NOT_RECORDED_NOT_ALLOCATED) {
            // skip unallocated frags
            i++;
            continue;
        }
        ASSERT(Map[i].extLocation);
 
#ifdef UDF_TRACK_ONDISK_ALLOCATION
        AdPrint(("Alloc:%x:%s:%x:@:%x:File:%x:Line:%d\n",
            FE_lba,
            asUsed ? ((asXXX & AS_BAD) ? "B" : "U") : "F",
            (Map[i].extLength & UDF_EXTENT_LENGTH_MASK) >> Vcb->BlockSizeBits,
            Map[i].extLocation,
            BugCheckId,
            Line
            ));
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
#ifdef UDF_DBG
#ifdef UDF_CHECK_EXTENT_SIZE_ALIGNMENT
        ASSERT(!(Map[i].extLength & (BS-1)));
#endif //UDF_CHECK_EXTENT_SIZE_ALIGNMENT
//        len = ((Map[i].extLength & UDF_EXTENT_LENGTH_MASK)+BS-1) >> BSh;
#else // UDF_DBG
//        len = (Map[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh;
#endif // UDF_DBG
        len = ((Map[i].extLength & UDF_EXTENT_LENGTH_MASK)+BS-1) >> BSh;
        lba = Map[i].extLocation;
        if((lba+len) > Vcb->LastPossibleLBA) {
            // skip blocks beyond media boundary
            if(lba > Vcb->LastPossibleLBA) {
                ASSERT(FALSE);
                i++;
                continue;
            }
            len = Vcb->LastPossibleLBA - lba;
        }
 
#ifdef UDF_TRACK_ONDISK_ALLOCATION
        if(lba)
            bit_before = UDFGetBit(Vcb->FSBM_Bitmap, lba-1);
        bit_after = UDFGetBit(Vcb->FSBM_Bitmap, lba+len);
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
        // mark frag as XXX (see asUsed parameter)
        if(asUsed) {
/*            for(j=0;j<len;j++) {
                UDFSetUsedBit(Vcb->FSBM_Bitmap, lba+j);
            }*/
            ASSERT(len);
            UDFSetUsedBits(Vcb->FSBM_Bitmap, lba, len);
#ifdef UDF_TRACK_ONDISK_ALLOCATION
            for(j=0;j<len;j++) {
                ASSERT(UDFGetUsedBit(Vcb->FSBM_Bitmap, lba+j));
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
            if(Vcb->Vat) {
                // mark logical blocks in VAT as used
                for(j=0;j<len;j++) {
                    root = UDFPartStart(Vcb, UDFGetPartNumByPhysLba(Vcb, lba));
                    if((Vcb->Vat[lba-root+j] == UDF_VAT_FREE_ENTRY) &&
                       (lba > Vcb->LastLBA)) {
                         Vcb->Vat[lba-root+j] = 0x7fffffff;
                    }
                }
            }
        } else {
/*            for(j=0;j<len;j++) {
                UDFSetFreeBit(Vcb->FSBM_Bitmap, lba+j);
            }*/
            ASSERT(len);
            UDFSetFreeBits(Vcb->FSBM_Bitmap, lba, len);
#ifdef UDF_TRACK_ONDISK_ALLOCATION
            for(j=0;j<len;j++) {
                ASSERT(UDFGetFreeBit(Vcb->FSBM_Bitmap, lba+j));
            }
#endif //UDF_TRACK_ONDISK_ALLOCATION
            if(asXXX & AS_BAD) {
                UDFSetBits(Vcb->BSBM_Bitmap, lba, len);
            }
            UDFMarkBadSpaceAsUsed(Vcb, lba, len);
 
            if(asXXX & AS_DISCARDED) {
                UDFUnmapRange(Vcb, lba, len);
                WCacheDiscardBlocks__(&(Vcb->FastCache), Vcb, lba, len);
                UDFSetZeroBits(Vcb->ZSBM_Bitmap, lba, len);
            }
            if(Vcb->Vat) {
                // mark logical blocks in VAT as free
                // this operation can decrease resulting VAT size
                for(j=0;j<len;j++) {
                    root = UDFPartStart(Vcb, UDFGetPartNumByPhysLba(Vcb, lba));
                    Vcb->Vat[lba-root+j] = UDF_VAT_FREE_ENTRY;
                }
            }
            // mark discarded extent as Not-Alloc-Not-Rec to
            // prevent writes there
            Map[i].extLength = (len << BSh) | (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
            Map[i].extLocation = 0;
        }
 
#ifdef UDF_TRACK_ONDISK_ALLOCATION
        if(lba)
            ASSERT(bit_before == UDFGetBit(Vcb->FSBM_Bitmap, lba-1));
        ASSERT(bit_after == UDFGetBit(Vcb->FSBM_Bitmap, lba+len));
#endif //UDF_TRACK_ONDISK_ALLOCATION
 
        i++;
    }
} // end UDFMarkSpaceAsXXXNoProtect_()

Referenced by UDFMarkSpaceAsXXX_().

◆ UDFMemRealloc()

uint32 UDFMemRealloc	(	IN int8 *	OldBuff,
		IN uint32	OldLength,
		OUT int8 **	NewBuff,
		IN uint32	NewLength
	)

◆ UDFMergeMappings()

PEXTENT_MAP __fastcall UDFMergeMappings	(	IN PEXTENT_MAP	Extent,
		IN PEXTENT_MAP	Extent2
	)

Definition at line 266 of file extent.cpp.

{
    PEXTENT_MAP NewExt;
    uint32 len, len2;
 
    len = UDFGetMappingLength(Extent);
    len2 = UDFGetMappingLength(Extent2);
    ASSERT(len2 && len);
    if(!len2) {
        return Extent;
    }
    if(MyReallocPool__((int8*)Extent, len, (int8**)(&NewExt), len+len2-sizeof(EXTENT_MAP))) {
        RtlCopyMemory(((int8*)NewExt)+len-sizeof(EXTENT_MAP), (int8*)Extent2, len2);
    } else {
        ExtPrint(("UDFMergeMappings failed\n"));
        BrutePoint();
    }
    return NewExt;
} // end UDFMergeMappings()

Referenced by UDFAllocFreeExtent_(), UDFBuildFreeSpaceBitmap(), UDFExtAllocDescToMapping(), UDFLongAllocDescToMapping(), UDFRelocateSectors(), UDFResizeExtent(), UDFShortAllocDescToMapping(), UDFUpdateNonAllocated(), and UDFVerifyFreeSpaceBitmap().

◆ UDFModifyVAT()

OSSTATUS UDFModifyVAT	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	Length
	)

◆ UDFOpenFile__()

OSSTATUS UDFOpenFile__	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN BOOLEAN	NotDeleted,
		IN PUNICODE_STRING	fn,
		IN PUDF_FILE_INFO	DirInfo,
		OUT PUDF_FILE_INFO *	_FileInfo,
		IN uint_di *	IndexToOpen
	)

Definition at line 2004 of file udf_info.cpp.

{
    OSSTATUS status;
    uint_di i=0;
    EXTENT_AD FEExt;
    uint16 Ident;
    PDIR_INDEX_HDR hDirNdx = DirInfo->Dloc->DirIndex;
    PDIR_INDEX_ITEM DirNdx;
    PUDF_FILE_INFO FileInfo;
    PUDF_FILE_INFO ParFileInfo;
    SIZE_T ReadBytes;
    *_FileInfo = NULL;
    if(!hDirNdx) return STATUS_NOT_A_DIRECTORY;
 
    // find specified file in directory index
    // if it is already known, skip this foolish code
    if(IndexToOpen) {
        i=*IndexToOpen;
    } else
        if(!OS_SUCCESS(status = UDFFindFile(Vcb, IgnoreCase, NotDeleted, fn, DirInfo, &i)))
            return status;
    // do this check for OpenByIndex
    // some routines may send invalid Index
    if(!(DirNdx = UDFDirIndex(hDirNdx,i)))
        return STATUS_OBJECT_NAME_NOT_FOUND;
    if((FileInfo = DirNdx->FileInfo)) {
        // file is already opened.
        if((DirNdx->FileCharacteristics & FILE_DELETED) && NotDeleted) {
            AdPrint(("  FILE_DELETED on open\n"));
            return STATUS_FILE_DELETED;
        }
        if((FileInfo->ParentFile != DirInfo) &&
           (FileInfo->Index >= 2)) {
            ParFileInfo = UDFLocateParallelFI(DirInfo, i, FileInfo);
            BrutePoint();
            if(ParFileInfo->ParentFile != DirInfo) {
                FileInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_FINF_TAG);
                *_FileInfo = FileInfo;
                if(!FileInfo) return STATUS_INSUFFICIENT_RESOURCES;
                RtlCopyMemory(FileInfo, DirNdx->FileInfo, sizeof(UDF_FILE_INFO));
    //          FileInfo->NextLinkedFile = DirNdx->FileInfo->NextLinkedFile; // is already done
                UDFInsertLinkedFile(FileInfo, DirNdx->FileInfo);
                DirNdx->FI_Flags |= UDF_FI_FLAG_LINKED;
                FileInfo->RefCount = 0;
                FileInfo->ParentFile = DirInfo;
                FileInfo->Fcb = NULL;
            } else {
                FileInfo = ParFileInfo;
            }
        }
        // Just increase some counters & exit
        UDFReferenceFile__(FileInfo);
 
        ASSERT(FileInfo->ParentFile == DirInfo);
        ValidateFileInfo(FileInfo);
 
        *_FileInfo = FileInfo;
        return STATUS_SUCCESS;
    } else
    if(IndexToOpen) {
        if((DirNdx->FileCharacteristics & FILE_DELETED) && NotDeleted) {
            AdPrint(("  FILE_DELETED on open (2)\n"));
            return STATUS_FILE_DELETED;
        }
    }
    FileInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_FINF_TAG);
    *_FileInfo = FileInfo;
    if(!FileInfo) return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(FileInfo, sizeof(UDF_FILE_INFO));
    // init horizontal links
    FileInfo->NextLinkedFile =
    FileInfo->PrevLinkedFile = FileInfo;
    // read FileIdent
    FileInfo->FileIdent = (PFILE_IDENT_DESC)MyAllocatePoolTag__(NonPagedPool, DirNdx->Length, MEM_FID_TAG);
    if(!(FileInfo->FileIdent)) return STATUS_INSUFFICIENT_RESOURCES;
    FileInfo->FileIdentLen = DirNdx->Length;
    if(!OS_SUCCESS(status = UDFReadExtent(Vcb, &(DirInfo->Dloc->DataLoc), DirNdx->Offset,
                             DirNdx->Length, FALSE, (int8*)(FileInfo->FileIdent), &ReadBytes) ))
        return status;
    if(FileInfo->FileIdent->descTag.tagIdent != TID_FILE_IDENT_DESC) {
        BrutePoint();
        return STATUS_FILE_CORRUPT_ERROR;
    }
    // check for opened links
    if(!OS_SUCCESS(status = UDFStoreDloc(Vcb, FileInfo, UDFPartLbaToPhys(Vcb, &(FileInfo->FileIdent->icb.extLocation)))))
        return status;
    // init pointer to parent object
    FileInfo->Index = i;
    FileInfo->ParentFile = DirInfo;
    // init pointers to linked files (if any)
    if(FileInfo->Dloc->LinkedFileInfo != FileInfo)
        UDFInsertLinkedFile(FileInfo, FileInfo->Dloc->LinkedFileInfo);
    if(FileInfo->Dloc->FileEntry)
        goto init_tree_entry;
    // read (Ex)FileEntry
    FileInfo->Dloc->FileEntry = (tag*)MyAllocatePoolTag__(NonPagedPool, Vcb->LBlockSize, MEM_FE_TAG);
    if(!(FileInfo->Dloc->FileEntry)) return STATUS_INSUFFICIENT_RESOURCES;
    if(!OS_SUCCESS(status = UDFReadFileEntry(Vcb, &(FileInfo->FileIdent->icb), (PFILE_ENTRY)(FileInfo->Dloc->FileEntry), &Ident)))
        return status;
    // build mappings for Data & AllocDescs
    if(!FileInfo->Dloc->AllocLoc.Mapping) {
        FEExt.extLength = FileInfo->FileIdent->icb.extLength;
        FEExt.extLocation = UDFPartLbaToPhys(Vcb, &(FileInfo->FileIdent->icb.extLocation) );
        if(FEExt.extLocation == LBA_OUT_OF_EXTENT)
            return STATUS_FILE_CORRUPT_ERROR;
        FileInfo->Dloc->AllocLoc.Mapping = UDFExtentToMapping(&FEExt);
        if(!(FileInfo->Dloc->AllocLoc.Mapping))
            return STATUS_INSUFFICIENT_RESOURCES;
    }
    // read location info
    status = UDFLoadExtInfo(Vcb, (PFILE_ENTRY)(FileInfo->Dloc->FileEntry), &(FileInfo->FileIdent->icb),
                           &(FileInfo->Dloc->DataLoc), &(FileInfo->Dloc->AllocLoc) );
    if(!OS_SUCCESS(status))
        return status;
    // init (Ex)FileEntry mapping
    FileInfo->Dloc->FELoc.Length = (FileInfo->Dloc->DataLoc.Offset) ? FileInfo->Dloc->DataLoc.Offset :
                                                          FileInfo->Dloc->AllocLoc.Offset;
//    FileInfo->Dloc->FELoc.Offset = 0;
    FileInfo->Dloc->FELoc.Mapping = UDFExtentToMapping(&FEExt);
    FileInfo->Dloc->FileEntryLen = (uint32)(FileInfo->Dloc->FELoc.Length);
    // we get here immediately when opened link encountered
init_tree_entry:
    // init back pointer from parent object
    ASSERT(!DirNdx->FileInfo);
    DirNdx->FileInfo = FileInfo;
    // init DirIndex
    if(UDFGetFileLinkCount(FileInfo) > 1) {
        DirNdx->FI_Flags |= UDF_FI_FLAG_LINKED;
    } else {
        DirNdx->FI_Flags &= ~UDF_FI_FLAG_LINKED;
    }
    // resize FE cache (0x800 instead of 0x40 is not a good idea)
    if(!MyReallocPool__((int8*)((FileInfo->Dloc->FileEntry)), Vcb->LBlockSize,
                     (int8**)&((FileInfo->Dloc->FileEntry)), FileInfo->Dloc->FileEntryLen))
        return STATUS_INSUFFICIENT_RESOURCES;
    // check if this file has a SDir
    if((FileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY) &&
       ((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLength )
        FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_HAS_SDIR;
    if(!(FileInfo->FileIdent->fileCharacteristics & FILE_DIRECTORY)) {
        UDFReferenceFile__(FileInfo);
        ASSERT(FileInfo->ParentFile == DirInfo);
        UDFReleaseDloc(Vcb, FileInfo->Dloc);
        return STATUS_SUCCESS;
    }
 
    UDFCheckSpaceAllocation(Vcb, 0, FileInfo->Dloc->DataLoc.Mapping, AS_USED); // check if used
 
    // build index for directories
    if(!FileInfo->Dloc->DirIndex) {
        status = UDFIndexDirectory(Vcb, FileInfo);
        if(!OS_SUCCESS(status))
            return status;
#ifndef UDF_READ_ONLY_BUILD
        if((FileInfo->Dloc->DirIndex->DelCount > Vcb->PackDirThreshold) &&
           !(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)) {
            status = UDFPackDirectory__(Vcb, FileInfo);
            if(!OS_SUCCESS(status))
                return status;
        }
#endif //UDF_READ_ONLY_BUILD
    }
    UDFReferenceFile__(FileInfo);
    UDFReleaseDloc(Vcb, FileInfo->Dloc);
    ASSERT(FileInfo->ParentFile == DirInfo);
 
    return status;
} // end UDFOpenFile__()

Referenced by UDFCommonCreate(), UDFCompleteMount(), UDFCreateFile__(), UDFHardLinkFile__(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFRenameMoveFile__(), UDFUnlinkAllFilesInDir(), and UDFWriteSecurity().

◆ UDFOpenRootFile__()

OSSTATUS UDFOpenRootFile__	(	IN PVCB	Vcb,
		IN lb_addr *	RootLoc,
		OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 2187 of file udf_info.cpp.

{
    uint32 RootLBA;
    OSSTATUS status;
//    uint32 PartNum = RootLoc->partitionReferenceNum;
    uint32 LBS = Vcb->LBlockSize;
    uint16 Ident;
    LONG_AD FELoc;
    EXTENT_AD FEExt;
    uint8 FileType;
 
    RtlZeroMemory(FileInfo, sizeof(UDF_FILE_INFO));
    RootLBA = UDFPartLbaToPhys(Vcb,RootLoc);
    if(RootLBA == LBA_OUT_OF_EXTENT)
        return STATUS_FILE_CORRUPT_ERROR;
    FELoc.extLocation = *RootLoc;
    FELoc.extLength = LBS;
    // init horizontal links
    FileInfo->NextLinkedFile =
    FileInfo->PrevLinkedFile = FileInfo;
    // check for opened links
    if(!OS_SUCCESS(status = UDFStoreDloc(Vcb, FileInfo, RootLBA)))
        return status;
    if(FileInfo->Dloc->FileEntry)
        goto init_tree_entry;
    // read (Ex)FileEntry
    FileInfo->Dloc->FileEntry = (tag*)MyAllocatePoolTag__(NonPagedPool, LBS, MEM_FE_TAG);
    if(!(FileInfo->Dloc->FileEntry)) return STATUS_INSUFFICIENT_RESOURCES;
 
    if(!OS_SUCCESS(status = UDFReadFileEntry(Vcb, &FELoc, (PFILE_ENTRY)(FileInfo->Dloc->FileEntry), &Ident)))
        return status;
    // build mappings for Data & AllocDescs
    FEExt.extLength = LBS;
    FEExt.extLocation = UDFPartLbaToPhys(Vcb, &(FELoc.extLocation) );
    if(FEExt.extLocation == LBA_OUT_OF_EXTENT)
        return STATUS_FILE_CORRUPT_ERROR;
    FileInfo->Dloc->FELoc.Mapping = UDFExtentToMapping(&FEExt);
    if(!(FileInfo->Dloc->FELoc.Mapping)) return STATUS_INSUFFICIENT_RESOURCES;
    // build mappings for AllocDescs
    if(!FileInfo->Dloc->AllocLoc.Mapping) {
        FileInfo->Dloc->AllocLoc.Mapping = UDFExtentToMapping(&FEExt);
        if(!(FileInfo->Dloc->AllocLoc.Mapping)) return STATUS_INSUFFICIENT_RESOURCES;
    }
    if(!OS_SUCCESS(status = UDFLoadExtInfo(Vcb, (PFILE_ENTRY)(FileInfo->Dloc->FileEntry), &FELoc,
                       &(FileInfo->Dloc->DataLoc), &(FileInfo->Dloc->AllocLoc) ) ))
        return status;
    FileInfo->Dloc->FileEntryLen = (uint32)
    (FileInfo->Dloc->FELoc.Length = (FileInfo->Dloc->DataLoc.Offset) ? FileInfo->Dloc->DataLoc.Offset :
                                                          FileInfo->Dloc->AllocLoc.Offset);
init_tree_entry:
    // resize FE cache (0x800 instead of 0x40 is not a good idea)
    if(!MyReallocPool__((int8*)((FileInfo->Dloc->FileEntry)), LBS,
                     (int8**)&((FileInfo->Dloc->FileEntry)), FileInfo->Dloc->FileEntryLen))
        return STATUS_INSUFFICIENT_RESOURCES;
    // init DirIndex
    if( (FileType = ((icbtag*)((FileInfo->Dloc->FileEntry)+1))->fileType) != UDF_FILE_TYPE_DIRECTORY &&
        (FileType != UDF_FILE_TYPE_STREAMDIR) ) {
        UDFReferenceFile__(FileInfo);
        UDFReleaseDloc(Vcb, FileInfo->Dloc);
        return STATUS_SUCCESS;
    }
    // build index for directories
    if(!FileInfo->Dloc->DirIndex) {
        status = UDFIndexDirectory(Vcb, FileInfo);
        if(!OS_SUCCESS(status))
            return status;
#ifndef UDF_READ_ONLY_BUILD
        if((FileInfo->Dloc->DirIndex->DelCount > Vcb->PackDirThreshold) &&
           !(Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)) {
            status = UDFPackDirectory__(Vcb, FileInfo);
            if(!OS_SUCCESS(status))
                return status;
        }
#endif //UDF_READ_ONLY_BUILD
    }
    UDFReferenceFile__(FileInfo);
    UDFReleaseDloc(Vcb, FileInfo->Dloc);
 
    return status;
} // end UDFOpenRootFile__()

Referenced by UDFCompareVcb(), UDFCompleteMount(), UDFLoadVAT(), and UDFOpenStreamDir__().

◆ UDFOpenStreamDir__()

OSSTATUS UDFOpenStreamDir__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		OUT PUDF_FILE_INFO *	_SDirInfo
	)

Definition at line 4965 of file udf_info.cpp.

{
    OSSTATUS status;
    PUDF_FILE_INFO SDirInfo;
    PUDF_FILE_INFO ParSDirInfo;
    uint16 Ident;
 
    *_SDirInfo = NULL;
    ValidateFileInfo(FileInfo);
    // check if this file has ExtendedFileEntry
    if((Ident = FileInfo->Dloc->FileEntry->tagIdent) != TID_EXTENDED_FILE_ENTRY) {
        return STATUS_NOT_FOUND;
    }
    if((SDirInfo = FileInfo->Dloc->SDirInfo)) {
        // it is already opened. Good...
 
        // check if we have Deleted SDir
        if(FileInfo->Dloc->SDirInfo &&
           UDFIsSDirDeleted(FileInfo->Dloc->SDirInfo))
            return STATUS_FILE_DELETED;
        // All right. Look for parallel SDir (if any)
        if(SDirInfo->ParentFile != FileInfo) {
            ParSDirInfo = UDFLocateParallelFI(FileInfo, 0, SDirInfo);
            BrutePoint();
            if(ParSDirInfo->ParentFile != FileInfo) {
                SDirInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_SDFINF_TAG);
                *_SDirInfo = SDirInfo;
                if(!SDirInfo) return STATUS_INSUFFICIENT_RESOURCES;
                RtlCopyMemory(SDirInfo, FileInfo->Dloc->SDirInfo, sizeof(UDF_FILE_INFO));
    //          SDirInfo->NextLinkedFile = FileInfo->Dloc->SDirInfo->NextLinkedFile; // is already done
                UDFInsertLinkedFile(SDirInfo, FileInfo->Dloc->SDirInfo);
                SDirInfo->RefCount = 0;
                SDirInfo->ParentFile = FileInfo;
                SDirInfo->Fcb = NULL;
            } else {
                SDirInfo = ParSDirInfo;
            }
        }
        UDFReferenceFile__(SDirInfo);
        *_SDirInfo = SDirInfo;
        return STATUS_SUCCESS;
    }
    // normal open
    if(!((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLength)
        return STATUS_NOT_FOUND;
    SDirInfo = (PUDF_FILE_INFO)MyAllocatePoolTag__(UDF_FILE_INFO_MT,sizeof(UDF_FILE_INFO), MEM_SDFINF_TAG);
    if(!SDirInfo) return STATUS_INSUFFICIENT_RESOURCES;
    *_SDirInfo = SDirInfo;
    status = UDFOpenRootFile__(Vcb, &(((PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry))->streamDirectoryICB.extLocation) ,SDirInfo);
    if(!OS_SUCCESS(status)) return status;
    // open & finalize linkage
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_HAS_SDIR;
    SDirInfo->Dloc->FE_Flags |= UDF_FE_FLAG_IS_SDIR;
    FileInfo->Dloc->SDirInfo = SDirInfo;
    SDirInfo->ParentFile = FileInfo;
 
    UDFInterlockedIncrement((PLONG)&(FileInfo->OpenCount));
 
    return STATUS_SUCCESS;
} // end UDFOpenStreamDir__()

Referenced by UDFCommonCreate(), UDFMarkStreamsForDeletion(), UDFReadSecurity(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFPackDirectory__()

OSSTATUS UDFPackDirectory__	(	IN PVCB	Vcb,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 743 of file dirtree.cpp.

{
#ifdef UDF_PACK_DIRS
    uint32 d, LBS;
    uint_di i, j;
    uint32 IUl, FIl, l;
    uint32 DataLocOffset;
    uint32 Offset, curOffset;
    int8* Buf;
    OSSTATUS status;
    SIZE_T ReadBytes;
    int8* storedFI;
    PUDF_FILE_INFO curFileInfo;
    PDIR_INDEX_ITEM DirNdx, DirNdx2;
    UDF_DIR_SCAN_CONTEXT ScanContext;
    uint_di dc=0;
    uint16 PartNum;
#endif //UDF_PACK_DIRS
 
    ValidateFileInfo(FileInfo);
    PDIR_INDEX_HDR hDirNdx = FileInfo->Dloc->DirIndex;
    if(!hDirNdx) return STATUS_NOT_A_DIRECTORY;
#ifndef UDF_PACK_DIRS
    return STATUS_SUCCESS;
#else // UDF_PACK_DIRS
 
    // do not pack dirs on unchanged disks
    if(!Vcb->Modified)
        return STATUS_SUCCESS;
    // start packing
    LBS = Vcb->LBlockSize;
    Buf = (int8*)DbgAllocatePool(PagedPool, LBS*2);
    if(!Buf) return STATUS_INSUFFICIENT_RESOURCES;
    // we shall never touch 1st entry 'cause it can't be deleted
    Offset = UDFDirIndex(hDirNdx,2)->Offset;
    DataLocOffset = FileInfo->Dloc->DataLoc.Offset;
 
    i=j=2;
 
    if(!UDFDirIndexInitScan(FileInfo, &ScanContext, i)) {
        DbgFreePool(Buf);
        return STATUS_SUCCESS;
    }
 
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    PartNum = (uint16)UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    ASSERT(PartNum != -1);
 
    while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
 
        if(UDFIsDeleted(DirNdx))
            dc++;
 
        if(!UDFIsDeleted(DirNdx) ||
             DirNdx->FileInfo) {
            // move down valid entry
            status = UDFReadFile__(Vcb, FileInfo, curOffset = DirNdx->Offset,
                                                          l = DirNdx->Length, FALSE, Buf, &ReadBytes);
            if(!OS_SUCCESS(status)) {
                DbgFreePool(Buf);
                return status;
            }
            // remove ImpUse field
            IUl = ((PFILE_IDENT_DESC)Buf)->lengthOfImpUse;
            curFileInfo = DirNdx->FileInfo;
            // align next entry
            if((d = LBS - ((curOffset + (l - IUl) + DataLocOffset) & (LBS-1)) ) < sizeof(FILE_IDENT_DESC)) {
 
                // insufficient space at the end of last sector for
                // next FileIdent's tag. fill it with ImpUse data
 
                // generally, all data should be DWORD-aligned, but if it is not so
                // this opearation will help us to avoid glitches
                d = (d+3) & ~(3);
                if(d != IUl) {
                    l = l + d - IUl;
                    FIl = ((PFILE_IDENT_DESC)Buf)->lengthFileIdent;
                    // copy filename to upper addr
                    RtlMoveMemory(Buf+sizeof(FILE_IDENT_DESC)+d,
                                  Buf+sizeof(FILE_IDENT_DESC)+IUl, FIl);
                    RtlZeroMemory(Buf+sizeof(FILE_IDENT_DESC), d);
                    ((PFILE_IDENT_DESC)Buf)->lengthOfImpUse = (uint16)d;
 
                    if(curFileInfo && curFileInfo->FileIdent) {
                        // update stored FI if any
                        if(!MyReallocPool__((int8*)(curFileInfo->FileIdent), l,
                                     (int8**)&(curFileInfo->FileIdent), (l+IUl-d) )) {
                            DbgFreePool(Buf);
                            return STATUS_INSUFFICIENT_RESOURCES;
                        }
                        storedFI = (int8*)(curFileInfo->FileIdent);
                        RtlMoveMemory(storedFI+sizeof(FILE_IDENT_DESC)+d,
                                      storedFI+sizeof(FILE_IDENT_DESC)+IUl, FIl);
                        RtlZeroMemory(storedFI+sizeof(FILE_IDENT_DESC), d);
                        ((PFILE_IDENT_DESC)storedFI)->lengthOfImpUse = (uint16)d;
                        FileInfo->Dloc->FELoc.Modified = TRUE;
                        FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
                    }
                }
            } else {
                d = 0;
            }
            // write modified to new addr
            if((d != IUl) ||
               (curOffset != Offset)) {
 
                UDFSetUpTag(Vcb, (tag*)Buf, (uint16)l,
                          UDFPhysLbaToPart(Vcb, PartNum,
                                     UDFExtentOffsetToLba(Vcb, FileInfo->Dloc->DataLoc.Mapping,
                                                Offset, NULL, NULL, NULL, NULL)));
 
                status = UDFWriteFile__(Vcb, FileInfo, Offset, l, FALSE, Buf, &ReadBytes);
                if(!OS_SUCCESS(status)) {
                    DbgFreePool(Buf);
                    return status;
                }
            }
            DirNdx2 = UDFDirIndex(hDirNdx, j);
            *DirNdx2 = *DirNdx;
            DirNdx2->Offset = Offset;
            DirNdx2->Length = l;
            if(curFileInfo) {
                curFileInfo->Index = j;
                DirNdx2->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
            }
            Offset += l;
            j++;
        }
    }
    // resize DirIndex
    DbgFreePool(Buf);
    if(dc) {
        if(!OS_SUCCESS(status = UDFDirIndexTrunc(&(FileInfo->Dloc->DirIndex), dc))) {
            return status;
        }
    }
    // terminator is set by UDFDirIndexTrunc()
    FileInfo->Dloc->DirIndex->DelCount = 0;
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
 
    // now Offset points to EOF. Let's truncate directory
    return UDFResizeFile__(Vcb, FileInfo, Offset);
#endif // UDF_PACK_DIRS
} // end UDFPackDirectory__()

Referenced by UDFOpenFile__(), and UDFOpenRootFile__().

◆ UDFPackMapping()

void __fastcall UDFPackMapping	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo
	)

Definition at line 2747 of file extent.cpp.

{
    PEXTENT_MAP NewMap, OldMap;
    uint32 i, j, l;
    uint32 LastLba, LastType, OldLen;
    uint32 OldSize, NewSize;
#ifdef UDF_DBG
    int64 check_size;
#endif //UDF_DBG
 
    AdPrint(("Pack ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
    AdPrint(("  Length %x\n", ExtInfo->Length));
 
    OldMap = ExtInfo->Mapping;
    LastLba = OldMap[0].extLocation;
    OldLen = (OldMap[0].extLength & UDF_EXTENT_LENGTH_MASK) >> Vcb->BlockSizeBits;
    LastType = OldMap[0].extLength >> 30;
    OldSize =
    NewSize = UDFGetMappingLength(OldMap);
#ifdef UDF_DBG
    check_size = UDFGetExtentLength(ExtInfo->Mapping);
    ASSERT(!(check_size & (2048-1)));
#endif //UDF_DBG
 
    l=OldMap[0].extLength & UDF_EXTENT_LENGTH_MASK;
    // calculate required length
    for(i=1; OldMap[i].extLength; i++) {
        if((LastType == (OldMap[i].extLength >> 30))
            &&
           ((OldMap[i].extLocation == LastLba + OldLen) ||
            (!OldMap[i].extLocation && !LastLba && (LastType == EXTENT_NOT_RECORDED_NOT_ALLOCATED)))
            &&
           (l + (OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK) <= UDF_MAX_EXTENT_LENGTH)) {
            // we can pack two blocks in one
            l += OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK;
            NewSize -= sizeof(EXTENT_MAP);
        } else {
            l = OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK;
        }
        LastLba = OldMap[i].extLocation;
        LastType = OldMap[i].extLength >> 30;
        OldLen = (OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK) >> Vcb->BlockSizeBits;
    }
    // no changes ?
    if(OldSize <= (NewSize + PACK_MAPPING_THRESHOLD)) {
        if(OldSize == NewSize)
            return;
        if(NewSize >= PACK_MAPPING_THRESHOLD)
            return;
    }
    AdPrint(("Pack ExtInfo %x, Mapping %x, realloc\n", ExtInfo, ExtInfo->Mapping));
    NewMap = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , NewSize,
                                                       MEM_EXTMAP_TAG);
    // can't alloc ?
    if(!NewMap) return;
    // Ok, lets pack it...
    j=0;
    NewMap[0] = OldMap[0];
    LastLba = OldMap[0].extLocation;
    OldLen = (OldMap[0].extLength & UDF_EXTENT_LENGTH_MASK) >> Vcb->BlockSizeBits;
    LastType = OldMap[0].extLength >> 30;
    for(i=1; OldMap[i].extLength; i++) {
 
        ExtPrint(("oShExt: type %x, loc %x, len %x\n",
            OldMap[i].extLength >> 30, OldMap[i].extLocation, OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK));
 
        if((LastType == (OldMap[i].extLength >> 30))
            &&
           ((OldMap[i].extLocation == LastLba + OldLen) ||
            (!OldMap[i].extLocation && !LastLba && (LastType == EXTENT_NOT_RECORDED_NOT_ALLOCATED)))
            &&
           ((NewMap[j].extLength & UDF_EXTENT_LENGTH_MASK) + (OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK) <= UDF_MAX_EXTENT_LENGTH)) {
            NewMap[j].extLength += OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK;
        } else {
            j++;
            NewMap[j] = OldMap[i];
        }
 
        ExtPrint(("nShExt: type %x, loc %x, len %x\n",
            NewMap[j].extLength >> 30, NewMap[j].extLocation, NewMap[j].extLength & UDF_EXTENT_LENGTH_MASK));
 
        LastLba = OldMap[i].extLocation;
        LastType = OldMap[i].extLength >> 30;
        OldLen = (OldMap[i].extLength & UDF_EXTENT_LENGTH_MASK) >> Vcb->BlockSizeBits;
    }
    // write terminator
    j++;
    ASSERT(NewSize == (j+1)*sizeof(EXTENT_MAP));
    NewMap[j].extLength =
    NewMap[j].extLocation = 0;
 
#ifdef UDF_DBG
    ASSERT(check_size == UDFGetExtentLength(ExtInfo->Mapping));
    ASSERT(check_size == UDFGetExtentLength(NewMap));
#endif
 
    AdPrint(("Pack ExtInfo %x, NewMap %x, OldMap %x\n", ExtInfo, NewMap, OldMap));
 
    ExtInfo->Mapping = NewMap;
    MyFreePool__(OldMap);
 
    AdPrint(("Pack ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
    AdPrint(("  Length %x\n", ExtInfo->Length));
} // end UDFPackMapping()

Referenced by UDFMarkAllocatedAsRecorded(), UDFRecordVAT(), UDFResizeExtent(), and UDFUpdateNonAllocated().

◆ UDFPadLastSector()

OSSTATUS UDFPadLastSector	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo
	)

Definition at line 2962 of file udf_info.cpp.

{
    if(!ExtInfo || !(ExtInfo->Mapping) || !(ExtInfo->Length)) return STATUS_INVALID_PARAMETER;
 
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    SIZE_T to_write, WrittenBytes;
    uint32 Lba, sect_offs, flags;
    OSSTATUS status;
    // Length should not be zero
    int64 Offset = ExtInfo->Length + ExtInfo->Offset;
    // data is sector-size-aligned, we needn't any padding
    if(Offset && !((uint32)Offset & (Vcb->LBlockSize-1) )) return STATUS_SUCCESS;
    // get Lba of the last sector
    Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
    // EOF check. If we have valid ExtInfo this will not happen, but who knows..
    if((Lba == (uint32)-1) ||
       (flags == EXTENT_NOT_RECORDED_NOT_ALLOCATED))
        return STATUS_END_OF_FILE;
    // write tail
    status = UDFWriteData(Vcb, TRUE, (((int64)Lba) << Vcb->BlockSizeBits) + sect_offs, to_write, FALSE, Vcb->ZBuffer, &WrittenBytes);
    return status;
} // UDFPadLastSector()

Referenced by UDFFlushFE().

◆ UDFPartEnd()

uint32 __fastcall UDFPartEnd	(	PVCB	Vcb,
		uint32	PartNum
	)

Definition at line 242 of file alloc.cpp.

{
    uint32 i;
    if(PartNum == (uint32)-1) return Vcb->LastLBA;
    if(PartNum == (uint32)-2) PartNum = Vcb->PartitionMaps-1;
    for(i=PartNum; i<Vcb->PartitionMaps; i++) {
        if(Vcb->Partitions[i].PartitionNum == PartNum)
            return (Vcb->Partitions[i].PartitionRoot +
                    Vcb->Partitions[i].PartitionLen);
    }
    return (Vcb->Partitions[i-1].PartitionRoot +
            Vcb->Partitions[i-1].PartitionLen);
} // end UDFPartEnd()

Referenced by UDFAllocateFESpace(), UDFGetPartFreeSpace(), UDFMarkNotAllocatedAsAllocated(), UDFPartLen(), UDFPrepareXSpaceBitmap(), and UDFResizeExtent().

◆ UDFPartLbaToPhys()

uint32 __fastcall UDFPartLbaToPhys	(	IN PVCB	Vcb,
		IN lb_addr *	Addr
	)

Definition at line 114 of file alloc.cpp.

{
    uint32 i, a;
    if(Addr->partitionReferenceNum >= Vcb->PartitionMaps) {
        AdPrint(("UDFPartLbaToPhys: part %x, lbn %x (err)\n",
            Addr->partitionReferenceNum, Addr->logicalBlockNum));
        if(Vcb->PartitionMaps &&
           (Vcb->CompatFlags & UDF_VCB_IC_INSTANT_COMPAT_ALLOC_DESCS)) {
            AdPrint(("UDFPartLbaToPhys: try to recover: part %x -> %x\n",
                Addr->partitionReferenceNum, Vcb->PartitionMaps-1));
            Addr->partitionReferenceNum = (USHORT)(Vcb->PartitionMaps-1);
        } else {
            return LBA_OUT_OF_EXTENT;
        }
    }
    // walk through partition maps & transform relative address
    // to physical
    for(i=Addr->partitionReferenceNum; i<Vcb->PartitionMaps; i++) {
        if(Vcb->Partitions[i].PartitionNum == Addr->partitionReferenceNum) {
            a = Vcb->Partitions[i].PartitionRoot +
                    (Addr->logicalBlockNum << Vcb->LB2B_Bits);
            if(a > Vcb->LastPossibleLBA) {
                AdPrint(("UDFPartLbaToPhys: root %x, lbn %x, lba %x (err1)\n",
                    Vcb->Partitions[i].PartitionRoot, Addr->logicalBlockNum, a));
                BrutePoint();
                return LBA_OUT_OF_EXTENT;
            }
            return a;
        }
    }
    a = Vcb->Partitions[i-1].PartitionRoot +
            (Addr->logicalBlockNum << Vcb->LB2B_Bits);
    if(a > Vcb->LastPossibleLBA) {
        AdPrint(("UDFPartLbaToPhys: i %x, root %x, lbn %x, lba %x (err2)\n",
            i, Vcb->Partitions[i-1].PartitionRoot, Addr->logicalBlockNum, a));
        BrutePoint();
        return LBA_OUT_OF_EXTENT;
    }
    return a;
} // end UDFPartLbaToPhys()

Referenced by UDFAddXSpaceBitmap(), UDFBuildFreeSpaceBitmap(), UDFExtAllocDescToMapping(), UDFFindLastFileSet(), UDFIndexDirectory(), UDFLoadExtInfo(), UDFLongAllocDescToMapping(), UDFOpenFile__(), UDFOpenRootFile__(), UDFPhysLbaToPart(), UDFPrepareXSpaceBitmap(), UDFReadFileEntry(), UDFShortAllocDescToMapping(), UDFVerifyFreeSpaceBitmap(), and UDFVerifyXSpaceBitmap().

◆ UDFPartLen()

uint32 __fastcall UDFPartLen	(	PVCB	Vcb,
		uint32	PartNum
	)

Definition at line 265 of file alloc.cpp.

{
 
    if(PartNum == (uint32)-2) return UDFPartEnd(Vcb, -2) - UDFPartStart(Vcb, -2);
/*#ifdef _X86_
    uint32 ret_val;
    __asm {
        mov  ebx,Vcb
        mov  eax,PartNum
        cmp  eax,-1
        jne  short NOT_last_gpl
        mov  eax,[ebx]Vcb.LastLBA
        jmp  short EO_gpl
NOT_last_gpl:
        mov  esi,eax
        xor  eax,eax
        mov  ecx,[ebx]Vcb.PartitionMaps
        jecxz EO_gpl
 
        mov  eax,esi
        mov  edx,size UDFTrackMap
        mul  edx
        add  ebx,eax
        mov  eax,esi
gpl_loop:
        cmp  [ebx]Vcb.PartitionMaps.PartitionNum,ax
        je   short EO_gpl_1
        add  ebx,size UDFTrackMap
        inc  eax
        cmp  eax,ecx
        jb   short gpl_loop
        sub  ebx,size UDFTrackMap
EO_gpl_1:
        mov  eax,[ebx]Vcb.PartitionMaps.PartitionLen
        add  eax,[ebx]Vcb.PartitionMaps.PartitionRoot
EO_gpl:
        mov  ret_val,eax
    }
    return ret_val;
#else   // NO X86 optimization , use generic C/C++*/
    uint32 i;
    if(PartNum == (uint32)-1) return Vcb->LastLBA;
    for(i=PartNum; i<Vcb->PartitionMaps; i++) {
        if(Vcb->Partitions[i].PartitionNum == PartNum)
            return Vcb->Partitions[i].PartitionLen;
    }
    return (Vcb->Partitions[i-1].PartitionRoot +
            Vcb->Partitions[i-1].PartitionLen);
/*#endif // _X86_*/
} // end UDFPartLen()

Referenced by UDFPrepareXSpaceBitmap(), UDFRecordVAT(), UDFUpdateNonAllocated(), and UDFUpdateXSpaceBitmaps().

◆ UDFPartStart()

uint32 __fastcall UDFPartStart	(	PVCB	Vcb,
		uint32	PartNum
	)

Definition at line 222 of file alloc.cpp.

{
    uint32 i;
    if(PartNum == (uint32)-1) return 0;
    if(PartNum == (uint32)-2) return Vcb->Partitions[0].PartitionRoot;
    for(i=PartNum; i<Vcb->PartitionMaps; i++) {
        if(Vcb->Partitions[i].PartitionNum == PartNum) return Vcb->Partitions[i].PartitionRoot;
    }
    return 0;
} // end UDFPartStart(

Referenced by UDFAddXSpaceBitmap(), UDFAllocateFESpace(), UDFGetPartFreeSpace(), UDFMarkNotAllocatedAsAllocated(), UDFMarkSpaceAsXXXNoProtect_(), UDFPartLen(), UDFPrepareXSpaceBitmap(), UDFRecordVAT(), UDFResizeExtent(), UDFUpdateNonAllocated(), and UDFUpdateXSpaceBitmaps().

◆ UDFPhysLbaToPart()

uint32 UDFPhysLbaToPart	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN uint32	Addr
	)

Definition at line 46 of file alloc.cpp.

{
    PUDFPartMap pm = Vcb->Partitions;
#if defined (_X86_) && defined (_MSC_VER) && !defined(__clang__)
    uint32 retval;
    __asm {
        push ebx
        push ecx
        push edx
 
        mov  ebx,Vcb
        mov  edx,[ebx]Vcb.PartitionMaps
        mov  ebx,pm
        mov  ecx,PartNum
        xor  eax,eax
loop_pl2p:
        cmp  ecx,edx
        jae  short EO_pl2p
        cmp  [ebx]pm.PartitionNum,cx
        jne  short cont_pl2p
        mov  eax,Addr
        sub  eax,[ebx]pm.PartitionRoot
        mov  ecx,Vcb
        mov  ecx,[ecx]Vcb.LB2B_Bits
        shr  eax,cl
        jmp  short EO_pl2p
cont_pl2p:
        add  ebx,size UDFPartMap
        inc  ecx
        jmp  short loop_pl2p
EO_pl2p:
        mov  retval,eax
 
        pop  edx
        pop  ecx
        pop  ebx
    }
#ifdef UDF_DBG
    {
        // validate return value
        lb_addr locAddr;
        locAddr.logicalBlockNum = retval;
        locAddr.partitionReferenceNum = (uint16)PartNum;
        UDFPartLbaToPhys(Vcb, &locAddr);
    }
#endif // UDF_DBG
    return retval;
#else   // NO X86 optimization , use generic C/C++
    uint32 i;
    // walk through partition maps to find suitable one...
    for(i=PartNum; i<Vcb->PartitionMaps; i++, pm++) {
        if(pm->PartitionNum == PartNum)
            // wow! return relative address
            return (Addr - pm->PartitionRoot) >> Vcb->LB2B_Bits;
    }
    return 0;
#endif // _X86_
} // end UDFPhysLbaToPart()

Referenced by UDFBuildFileEntry(), UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFCloseFile__(), UDFCreateFile__(), UDFCreateRootFile__(), UDFCreateStreamDir__(), UDFFlushFE(), UDFFlushFI(), UDFIndexDirectory(), UDFLoadVAT(), UDFPackDirectory__(), UDFPrepareXSpaceBitmap(), UDFRecordDirectory__(), UDFRecordVAT(), and UDFReTagDirectory().

◆ UDFPrepareXSpaceBitmap()

OSSTATUS UDFPrepareXSpaceBitmap	(	IN PVCB	Vcb,
		IN OUT PSHORT_AD	XSpaceBitmap,
		IN OUT PEXTENT_INFO	XSBMExtInfo,
		IN OUT int8 **	XSBM,
		IN OUT uint32 *	XSl
	)

Definition at line 52 of file mount.cpp.

{
    uint32 BS, j, LBS;
    uint32 plen;
    OSSTATUS status;
    EXTENT_MAP TmpExt;
    lb_addr locAddr;
    int8* _XSBM;
    uint16 Ident;
    SIZE_T ReadBytes;
    uint32 PartNum;
 
    if(!(XSpaceBitmap->extLength)) {
        *XSl = 0;
        *XSBM = NULL;
        return STATUS_SUCCESS;
    }
 
    PartNum = UDFGetPartNumByPartNdx(Vcb, Vcb->PartitionMaps-1);
    locAddr.partitionReferenceNum = (uint16)PartNum;
    plen = UDFPartStart(Vcb, PartNum) + UDFPartLen(Vcb, PartNum);
 
    BS = Vcb->BlockSize;
    LBS = Vcb->LBlockSize;
 
    *XSl = sizeof(SPACE_BITMAP_DESC) + ((plen+7)>>3);
    _XSBM = (int8*)DbgAllocatePool(NonPagedPool, (*XSl + BS - 1) & ~(BS-1) );
    *XSBM = _XSBM;
 
    switch (XSpaceBitmap->extLength >> 30) {
    case EXTENT_RECORDED_ALLOCATED: {
        locAddr.logicalBlockNum = XSpaceBitmap->extPosition;
        *XSl = min(XSpaceBitmap->extLength, *XSl);
        TmpExt.extLength = XSpaceBitmap->extLength = *XSl;
        TmpExt.extLocation = UDFPartLbaToPhys(Vcb, &locAddr);
        if(TmpExt.extLocation == LBA_OUT_OF_EXTENT) {
            BrutePoint();
        }
        XSBMExtInfo->Mapping = UDFExtentToMapping(&TmpExt);
        XSBMExtInfo->Offset = 0;
        XSBMExtInfo->Length = *XSl;
        break;
    }
    case EXTENT_NEXT_EXTENT_ALLOCDESC:
    case EXTENT_NOT_RECORDED_NOT_ALLOCATED: {
        // allocate space for bitmap
        if(!OS_SUCCESS(status = UDFAllocFreeExtent(Vcb, *XSl,
               UDFPartStart(Vcb, PartNum), UDFPartEnd(Vcb, PartNum), XSBMExtInfo, EXTENT_FLAG_ALLOC_SEQUENTIAL) ))
            return status;
        if(XSBMExtInfo->Mapping[1].extLength) {
            UDFPrint(("Can't allocate space for Freed Space bitmap\n"));
            *XSl = 0;
        } else {
            *XSl = (uint32)(XSBMExtInfo->Length);
            XSpaceBitmap->extPosition = UDFPhysLbaToPart(Vcb, PartNum, XSBMExtInfo->Mapping[0].extLocation);
        }
        break;
    }
    case EXTENT_NOT_RECORDED_ALLOCATED: {
        // record Alloc-Not-Rec
        locAddr.logicalBlockNum = XSpaceBitmap->extPosition;
        *XSl = min((XSpaceBitmap->extLength & UDF_EXTENT_LENGTH_MASK), *XSl);
        TmpExt.extLength = XSpaceBitmap->extLength = *XSl;
        TmpExt.extLocation = UDFPartLbaToPhys(Vcb, &locAddr);
        if(TmpExt.extLocation == LBA_OUT_OF_EXTENT) {
            BrutePoint();
        }
        XSBMExtInfo->Mapping = UDFExtentToMapping(&TmpExt);
        XSBMExtInfo->Offset = 0;
        XSBMExtInfo->Length = *XSl;
        break;
    }
    }
 
    if(!_XSBM) {
        BrutePoint();
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    switch (XSpaceBitmap->extLength >> 30) {
    case EXTENT_RECORDED_ALLOCATED: {
        // read descriptor & bitmap
        if((!OS_SUCCESS(status = UDFReadTagged(Vcb, *XSBM, (j = TmpExt.extLocation),
                             locAddr.logicalBlockNum, &Ident))) ||
           (Ident != TID_SPACE_BITMAP_DESC) ||
           (!OS_SUCCESS(status = UDFReadExtent(Vcb, XSBMExtInfo, 0, *XSl, FALSE, *XSBM, &ReadBytes))) ) {
            if(OS_SUCCESS(status)) {
                BrutePoint();
                status = STATUS_FILE_CORRUPT_ERROR;
            }
            if(XSBMExtInfo->Mapping) {
                MyFreePool__(XSBMExtInfo->Mapping);
                XSBMExtInfo->Mapping = NULL;
            }
            DbgFreePool(*XSBM);
            *XSl = 0;
            *XSBM = NULL;
            return status;
        } else {
//            BrutePoint();
        }
        return STATUS_SUCCESS;
    }
#if 0
    case EXTENT_NEXT_EXTENT_ALLOCDESC:
    case EXTENT_NOT_RECORDED_NOT_ALLOCATED:
    case EXTENT_NOT_RECORDED_ALLOCATED: {
        break;
    }
#endif
    }
 
    PSPACE_BITMAP_DESC XSDesc = (PSPACE_BITMAP_DESC)(*XSBM);
 
    XSpaceBitmap->extLength = (*XSl + LBS -1) & ~(LBS-1);
    RtlZeroMemory(*XSBM, *XSl);
    XSDesc->descTag.tagIdent = TID_SPACE_BITMAP_DESC;
    UDFSetUpTag(Vcb, &(XSDesc->descTag), 0, XSpaceBitmap->extPosition);
    XSDesc->numOfBits = plen;
    XSDesc->numOfBytes = (*XSl)-sizeof(SPACE_BITMAP_DESC);
 
    return STATUS_SUCCESS;
} // end UDFPrepareXSpaceBitmap()

Referenced by UDFUpdateXSpaceBitmaps().

◆ UDFPretendFileDeleted__()

OSSTATUS UDFPretendFileDeleted__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 5566 of file udf_info.cpp.

{
    AdPrint(("UDFPretendFileDeleted__:\n"));
 
    NTSTATUS RC;
    PDIR_INDEX_HDR hDirNdx = UDFGetDirIndexByFileInfo(FileInfo);
    if(!hDirNdx) return STATUS_CANNOT_DELETE;
    PDIR_INDEX_ITEM DirNdx = UDFDirIndex(hDirNdx, FileInfo->Index);
    if(!DirNdx) return STATUS_CANNOT_DELETE;
 
 
    // we can't hide file that is not marked as deleted
    RC = UDFDoesOSAllowFilePretendDeleted__(FileInfo);
    if(!NT_SUCCESS(RC))
        return RC;
 
    AdPrint(("UDFPretendFileDeleted__: set UDF_FI_FLAG_FI_INTERNAL\n"));
 
    DirNdx->FI_Flags |= UDF_FI_FLAG_FI_INTERNAL;
    if(DirNdx->FName.Buffer) {
        MyFreePool__(DirNdx->FName.Buffer);
        DirNdx->FName.Buffer = NULL;
        DirNdx->FName.Length =
        DirNdx->FName.MaximumLength = 0;
    }
    return STATUS_SUCCESS;
} // end UDFPretendFileDeleted__()

Referenced by UDFCommonCleanup(), and UDFCreateFile__().

◆ UDFProcessSequence()

OSSTATUS UDFProcessSequence	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb,
		IN uint32	block,
		IN uint32	lastblock,
		OUT lb_addr *	fileset
	)

Definition at line 2360 of file mount.cpp.

{
    OSSTATUS    RC = STATUS_SUCCESS;
    int8*       Buf = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
    UDF_VDS_RECORD vds[VDS_POS_LENGTH];
//    GenericDesc   *gd;
    uint32   i,j;
    uint16  ident;
    int8*  Buf2 = NULL;
 
    _SEH2_TRY {
        if(!Buf) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
        RtlZeroMemory(vds, sizeof(UDF_VDS_RECORD) * VDS_POS_LENGTH);
        if(!OS_SUCCESS(RC = UDFReadVDS(Vcb, block, lastblock, (PUDF_VDS_RECORD)&vds, Buf)))
            try_return(RC);
        // walk through Vol Desc Sequence according to locations gained by
        // UDFReadVDS() & do some procesing for each one
        // It is very simple dispath routine...
        for (i=0; i<VDS_POS_LENGTH; i++)
        {
            if(vds[i].block)
            {
                if(!OS_SUCCESS(RC = UDFReadTagged(Vcb, Buf, vds[i].block, vds[i].block, &ident)))
                    try_return(RC);
                UDFRegisterFsStructure(Vcb, vds[i].block, Vcb->BlockSize);
 
                if(i == VDS_POS_PRIMARY_VOL_DESC) {
                    UDFLoadPVolDesc(Vcb,Buf);
                    if(!Vcb->PVolDescAddr.block) {
                        Vcb->PVolDescAddr = vds[i];
                    } else {
                        Vcb->PVolDescAddr2 = vds[i];
                    }
                } else
                if(i == VDS_POS_LOGICAL_VOL_DESC) {
                    RC = UDFLoadLogicalVol(DeviceObject,Vcb, Buf, fileset);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                } else
 
                if(i == VDS_POS_IMP_USE_VOL_DESC) {
                    UDFLoadImpUseVolDesc(Vcb, Buf);
                } else
                if(i == VDS_POS_UNALLOC_SPACE_DESC) {
                    UDFLoadUnallocatedSpaceDesc(Vcb, Buf);
                } else
 
                if(i == VDS_POS_PARTITION_DESC)
                {
                    Buf2 = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
                    if(!Buf2) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
                    RC = UDFLoadPartDesc(Vcb,Buf);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                    for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++)
                    {
                        RC = UDFReadTagged(Vcb,Buf2, j, j, &ident);
                        if(!OS_SUCCESS(RC)) try_return(RC);
                        UDFRegisterFsStructure(Vcb, j, Vcb->BlockSize);
//                        gd = (struct GenericDesc *)Buf2;
                        if(ident == TID_PARTITION_DESC) {
                            RC = UDFLoadPartDesc(Vcb,Buf2);
                            if(!OS_SUCCESS(RC)) try_return(RC);
                        } else if(ident == TID_UNALLOC_SPACE_DESC) {
                            RC = UDFBuildFreeSpaceBitmap(Vcb,0,NULL,j);
                            //Vcb->Modified = FALSE;
                            UDFPreClrModified(Vcb);
                            UDFClrModified(Vcb);
                            if(!OS_SUCCESS(RC))
                                try_return(RC);
                        }
                    }
                    MyFreePool__(Buf2);
                    Buf2 = NULL;
                }
            } else {
                if(i == VDS_POS_LOGICAL_VOL_DESC) {
                    RC = UDFLoadBogusLogicalVol(DeviceObject,Vcb, Buf, fileset);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                }
            }
        }
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
        if(Buf) MyFreePool__(Buf);
        if(Buf2) MyFreePool__(Buf2);
    } _SEH2_END;
 
    return RC;
} // end UDFProcessSequence()

Referenced by UDFLoadPartition().

◆ UDFReadEntityID_Domain()

void UDFReadEntityID_Domain	(	PVCB	Vcb,
		EntityID *	eID
	)

Definition at line 1559 of file udf_info.cpp.

{
    domainIdentSuffix* dis;
    uint8 flags;
 
    dis = (domainIdentSuffix*)&(eID->identSuffix);
 
    UDFPrint(("UDF: Entity Id:\n"));
    UDFPrint(("flags: %x\n", eID->flags));
    UDFPrint(("ident[0]: %x\n", eID->ident[0]));
    UDFPrint(("ident[1]: %x\n", eID->ident[1]));
    UDFPrint(("ident[2]: %x\n", eID->ident[2]));
    UDFPrint(("ident[3]: %x\n", eID->ident[3]));
    UDFPrint(("UDF: Entity Id Domain:\n"));
    // Get current UDF revision
    Vcb->CurrentUDFRev = max(dis->currentRev, Vcb->CurrentUDFRev);
    UDFPrint(("Effective Revision: %x\n", Vcb->CurrentUDFRev));
    // Get Read-Only flags
    flags = dis->flags;
    UDFPrint(("Flags: %x\n", flags));
    if((flags & ENTITYID_FLAGS_SOFT_RO) &&
        (Vcb->CompatFlags & UDF_VCB_IC_SOFT_RO)) {
        Vcb->VCBFlags |= UDF_VCB_FLAGS_VOLUME_READ_ONLY;
        Vcb->UserFSFlags |= UDF_USER_FS_FLAGS_SOFT_RO;
        UDFPrint(("       Soft-RO\n"));
    }
    if((flags & ENTITYID_FLAGS_HARD_RO) &&
       (Vcb->CompatFlags & UDF_VCB_IC_HW_RO)) {
        Vcb->VCBFlags |= UDF_VCB_FLAGS_MEDIA_READ_ONLY;
        Vcb->UserFSFlags |= UDF_USER_FS_FLAGS_HW_RO;
        UDFPrint(("       Hard-RO\n"));
    }
 
} // end UDFReadEntityID_Domain()

Referenced by UDFLoadFileset(), and UDFLoadLogicalVol().

◆ UDFReadExtent()

OSSTATUS UDFReadExtent	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo,
		IN int64	Offset,
		IN SIZE_T	Length,
		IN BOOLEAN	Direct,
		OUT int8 *	Buffer,
		OUT PSIZE_T	ReadBytes
	)

Definition at line 3021 of file extent.cpp.

{
    (*ReadBytes) = 0;
    if(!ExtInfo || !ExtInfo->Mapping) return STATUS_INVALID_PARAMETER;
    ASSERT((uintptr_t)Buffer > 0x1000);
 
    AdPrint(("Read ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
 
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    SIZE_T to_read, _ReadBytes;
    uint32 Lba, sect_offs, flags;
    uint32 index;
    OSSTATUS status;
    // prevent reading out of data space
    if(Offset > ExtInfo->Length) return STATUS_END_OF_FILE;
    if(Offset+Length > ExtInfo->Length) Length = (uint32)(ExtInfo->Length - Offset);
    Offset += ExtInfo->Offset;               // used for in-ICB data
    // read maximal possible part of each frag of extent
    Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_read, &flags, &index);
    _ReadBytes = index;
    while(Length) {
        // EOF check
        if(Lba == LBA_OUT_OF_EXTENT) return STATUS_END_OF_FILE;
        Extent += (_ReadBytes + 1);
        // check for reading tail
        to_read = min(to_read, Length);
        if(flags == EXTENT_RECORDED_ALLOCATED) {
            status = UDFReadData(Vcb, TRUE, ( ((uint64)Lba) << Vcb->BlockSizeBits) + sect_offs, to_read, Direct, Buffer, &_ReadBytes);
            (*ReadBytes) += _ReadBytes;
            if(!OS_SUCCESS(status)) return status;
        } else {
            RtlZeroMemory(Buffer, to_read);
            (*ReadBytes) += to_read;
        }
        // prepare for reading next frag...
        Length -= to_read;
        if(!Length)
            break;
        ASSERT(to_read);
        Buffer += to_read;
//        Offset += to_read;
        Lba = UDFNextExtentToLba(Vcb, Extent, &to_read, &flags, &index);
        _ReadBytes = index;
        sect_offs = 0;
    }
    return STATUS_SUCCESS;
} // end UDFReadExtent()

Referenced by UDFConvertFEToNonInICB(), UDFCreateFile__(), UDFExtAllocDescToMapping(), UDFIndexDirectory(), UDFLongAllocDescToMapping(), UDFOpenFile__(), UDFPrepareXSpaceBitmap(), UDFReadFile__(), UDFResizeFile__(), UDFShortAllocDescToMapping(), and UDFWriteFile__().

◆ UDFReadExtentLocation()

OSSTATUS UDFReadExtentLocation	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo,
		IN int64	Offset,
		OUT PEXTENT_MAP *	_SubExtInfo,
		IN OUT uint32 *	_SubExtInfoSz,
		OUT int64 *	_NextOffset
	)

Definition at line 3083 of file extent.cpp.

{
    if(!ExtInfo || !ExtInfo->Mapping)
        return STATUS_INVALID_PARAMETER;
 
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    PEXTENT_MAP SubExtInfo;
    SIZE_T to_read;
    uint32 Lba, sect_offs, flags, Skip_MapEntries;
    int32 SubExtInfoSz = *_SubExtInfoSz;
    int64 Length;
    int64 NextOffset;
//    OSSTATUS status = STATUS_BUFFER_OVERFLOW;
 
    (*_SubExtInfo) = NULL;
    (*_SubExtInfoSz) = 0;
    NextOffset = Offset;
    // prevent reading out of data space
    if(Offset >= ExtInfo->Length)
        return STATUS_END_OF_FILE;
    Length = ExtInfo->Length - Offset;
    Offset += ExtInfo->Offset;               // used for in-ICB data
    // read maximal possible part of each frag of extent
    SubExtInfo = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , SubExtInfoSz*sizeof(EXTENT_MAP),
                                                       MEM_EXTMAP_TAG);
    (*_SubExtInfo) = SubExtInfo;
    if(!SubExtInfo)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_read, &flags, &Skip_MapEntries);
    while(Length && SubExtInfoSz) {
        // EOF check
        if(Lba == LBA_OUT_OF_EXTENT) {
            BrutePoint();
            return STATUS_END_OF_FILE;
        }
        Extent += (Skip_MapEntries + 1);
        // check for reading tail
        to_read = (int32)min((int64)to_read, Length);
        SubExtInfo->extLength   = to_read;
        if(flags == EXTENT_NOT_RECORDED_NOT_ALLOCATED) {
            SubExtInfo->extLocation = LBA_NOT_ALLOCATED;
        } else
        if(flags == EXTENT_NOT_RECORDED_ALLOCATED) {
            ASSERT(!(Lba & 0x80000000));
            SubExtInfo->extLocation = Lba | 0x80000000;
        } else {
            SubExtInfo->extLocation = Lba;
        }
        (*_SubExtInfoSz)++;
        SubExtInfoSz--;
        NextOffset += to_read;
        // prepare for reading next frag...
        Length -= to_read;
        if(!Length) {
//            status = STATUS_SUCCESS;
            break;
        }
        ASSERT(to_read);
        Lba = UDFNextExtentToLba(Vcb, Extent, &to_read, &flags, &Skip_MapEntries);
        sect_offs = 0;
    }
    (*_NextOffset) = NextOffset;
    return STATUS_SUCCESS;
} // end UDFReadExtentLocation()

Referenced by UDFReadFileLocation__().

◆ UDFReadFile__()

__inline OSSTATUS UDFReadFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64	Offset,
		IN SIZE_T	Length,
		IN BOOLEAN	Direct,
		OUT int8 *	Buffer,
		OUT PSIZE_T	ReadBytes
	)

Definition at line 666 of file udf_info.h.

{
    ValidateFileInfo(FileInfo);
 
    return UDFReadExtent(Vcb, &(FileInfo->Dloc->DataLoc), Offset, Length, Direct, Buffer, ReadBytes);
} // end UDFReadFile__()*/

Referenced by UDFCommonRead(), UDFCompleteMount(), UDFConvertFEToExtended(), UDFLoadVAT(), UDFPackDirectory__(), UDFReadSecurity(), UDFRecordVAT(), and UDFReTagDirectory().

◆ UDFReadFileEntry()

OSSTATUS UDFReadFileEntry	(	IN PVCB	Vcb,
		IN long_ad *	Icb,
		IN OUT PFILE_ENTRY	FileEntry,
		IN OUT uint16 *	Ident
	)

Definition at line 306 of file udf_info.cpp.

{
    OSSTATUS status;
 
    if(!OS_SUCCESS(status = UDFReadTagged(Vcb, (int8*)FileEntry,
                         UDFPartLbaToPhys(Vcb,&(Icb->extLocation)),
                         Icb->extLocation.logicalBlockNum,
                         Ident))) return status;
    if((FileEntry->descTag.tagIdent != TID_FILE_ENTRY) &&
       (FileEntry->descTag.tagIdent != TID_EXTENDED_FILE_ENTRY)) {
        UDFPrint(("  Not a FileEntry (lbn=%x, tag=%x)\n", Icb->extLocation.logicalBlockNum, FileEntry->descTag.tagIdent));
        return STATUS_FILE_CORRUPT_ERROR;
    }
    return STATUS_SUCCESS;
} // UDFReadFileEntry()

Referenced by UDFFileDirInfoToNT(), UDFOpenFile__(), and UDFOpenRootFile__().

◆ UDFReadFileLocation__()

__inline OSSTATUS UDFReadFileLocation__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64	Offset,
		OUT PEXTENT_MAP *	SubExtInfo,
		IN OUT uint32 *	SubExtInfoSz,
		OUT int64 *	NextOffset
	)

Definition at line 683 of file udf_info.h.

{
    ValidateFileInfo(FileInfo);
 
    return UDFReadExtentLocation(Vcb, &(FileInfo->Dloc->DataLoc), Offset, SubExtInfo, SubExtInfoSz, NextOffset);
} // end UDFReadFile__()*/

Referenced by UDFGetRetrievalPointers().

◆ UDFReadMappingFromXEntry()

PEXTENT_MAP UDFReadMappingFromXEntry	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN tag *	XEntry,
		IN OUT uint32 *	Offset,
		OUT PEXTENT_INFO	AllocLoc
	)

Definition at line 735 of file extent.cpp.

{
    PEXTENT_AD Extent;
    uint16 AllocMode;
    int8* AllocDescs;
    uint32 len;
//    EntityID* eID;  // for compatibility with Adaptec DirectCD
 
    Extent = NULL;
    (*Offset) = 0;
 
 
    if(XEntry->tagIdent == TID_FILE_ENTRY) {
//        UDFPrint(("Standard FileEntry\n"));
        PFILE_ENTRY FileEntry = (PFILE_ENTRY)XEntry;
        ExtPrint(("Standard FileEntry\n"));
 
        AllocDescs = (int8*)(((int8*)(FileEntry+1))+(FileEntry->lengthExtendedAttr));
        len = FileEntry->lengthAllocDescs;
        AllocLoc->Offset = sizeof(FILE_ENTRY) + FileEntry->lengthExtendedAttr;
//        eID = &(FileEntry->impIdent);
 
        AllocMode = FileEntry->icbTag.flags & ICB_FLAG_ALLOC_MASK;
 
    } else if(XEntry->tagIdent == TID_EXTENDED_FILE_ENTRY) {
//        UDFPrint(("Extended FileEntry\n"));
        ExtPrint(("Extended FileEntry\n"));
        PEXTENDED_FILE_ENTRY ExFileEntry = (PEXTENDED_FILE_ENTRY)XEntry;
 
        AllocDescs = (((int8*)(ExFileEntry+1))+(ExFileEntry->lengthExtendedAttr));
        len = ExFileEntry->lengthAllocDescs;
        AllocLoc->Offset = sizeof(EXTENDED_FILE_ENTRY) + ExFileEntry->lengthExtendedAttr;
//        eID = &(FileEntry->impIdent);
 
        AllocMode = ExFileEntry->icbTag.flags & ICB_FLAG_ALLOC_MASK;
 
    } else {
        return NULL;
    }
 
    // for compatibility with Adaptec DirectCD
//    if(!(Vcb->UDF_VCB_IC_ADAPTEC_NONALLOC_COMPAT))
 
    AllocLoc->Length=len;
    AllocLoc->Flags |= EXTENT_FLAG_VERIFY; // for metadata
 
    switch (AllocMode) {
    case ICB_FLAG_AD_SHORT: {
        Extent = UDFShortAllocDescToMapping(Vcb, PartNum, (PSHORT_AD)AllocDescs, len, 0, AllocLoc);
        break;
    }
    case ICB_FLAG_AD_LONG: {
        Extent = UDFLongAllocDescToMapping(Vcb, (PLONG_AD)AllocDescs, len, 0, AllocLoc);
        break;
    }
    case ICB_FLAG_AD_EXTENDED: {
        Extent = UDFExtAllocDescToMapping(Vcb, (PEXT_AD)AllocDescs, len, 0, AllocLoc);
        break;
    }
    default : {  // case ICB_FLAG_AD_IN_ICB
        Extent = NULL;
        *Offset = (uintptr_t)AllocDescs - (uintptr_t)XEntry;
        AllocLoc->Offset=0;
        AllocLoc->Length=0;
        if(AllocLoc->Mapping) MyFreePool__(AllocLoc->Mapping);
        AllocLoc->Mapping=NULL;
        break;
    }
    }
 
    ExtPrint(("UDFReadMappingFromXEntry: mode %x, loc %x, len %x\n", AllocMode,
        AllocLoc->Mapping ? AllocLoc->Mapping[0].extLocation : -1, len));
 
    UDFCheckSpaceAllocation(Vcb, 0, Extent, AS_USED); // check if used
 
    return Extent;
}// end UDFReadMappingFromXEntry()

Referenced by UDFLoadExtInfo().

◆ UDFReadTagged()

OSSTATUS UDFReadTagged	(	IN PVCB	Vcb,
		IN int8 *	Buf,
		IN uint32	Block,
		IN uint32	Location,
		OUT uint16 *	Ident
	)

◆ UDFReadVDS()

OSSTATUS UDFReadVDS	(	IN PVCB	Vcb,
		IN uint32	block,
		IN uint32	lastblock,
		IN PUDF_VDS_RECORD	vds,
		IN int8 *	Buf
	)

Definition at line 2239 of file mount.cpp.

{
    OSSTATUS status;
    GenericDesc* gd;
    BOOLEAN done=FALSE;
    uint32 vdsn;
    uint16 ident;
 
    UDFPrint(("UDF: Read VDS (%x - %x)\n", block, lastblock ));
    // Read the main descriptor sequence
    for (;(!done && block <= lastblock); block++)
    {
        status = UDFReadTagged(Vcb, Buf, block, block, &ident);
        if(!OS_SUCCESS(status))
            return status;
        UDFRegisterFsStructure(Vcb, block, Vcb->BlockSize);
 
        // Process each descriptor (ISO 13346 3/8.3-8.4)
        gd = (struct GenericDesc *)Buf;
        vdsn = gd->volDescSeqNum;
        UDFPrint(("LBA %x, Ident = %x, vdsn = %x\n", block, ident, vdsn ));
        switch (ident)
        {
            case TID_PRIMARY_VOL_DESC: // ISO 13346 3/10.1
                if(vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum)
                {
                    vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn;
                    vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
                }
                break;
            case TID_VOL_DESC_PTR: // ISO 13346 3/10.3
                struct VolDescPtr* pVDP;
                if(vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum)
                {
                    vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
                    vds[VDS_POS_VOL_DESC_PTR].block = block;
                    vds[VDS_POS_RECURSION_COUNTER].volDescSeqNum++;
                    if(vds[VDS_POS_RECURSION_COUNTER].volDescSeqNum > MAX_VDS_PARTS) {
                       UDFPrint(("too long multipart VDS -> abort\n"));
                        return STATUS_DISK_CORRUPT_ERROR;
                    }
                    pVDP = (struct VolDescPtr*)Buf;
                    UDFPrint(("multipart VDS...\n"));
                    return UDFReadVDS(Vcb, pVDP->nextVolDescSeqExt.extLocation,
                                         pVDP->nextVolDescSeqExt.extLocation + (pVDP->nextVolDescSeqExt.extLocation >> Vcb->BlockSizeBits),
                                         vds, Buf);
                }
                break;
            case TID_IMP_USE_VOL_DESC: // ISO 13346 3/10.4
                if(vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum)
                {
                    vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn;
                    vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
                }
                break;
            case TID_PARTITION_DESC: // ISO 13346 3/10.5
                if(!vds[VDS_POS_PARTITION_DESC].block)
                    vds[VDS_POS_PARTITION_DESC].block = block;
                break;
            case TID_LOGICAL_VOL_DESC: // ISO 13346 3/10.6
            case TID_ADAPTEC_LOGICAL_VOL_DESC: // Adaptec Compressed UDF extesion
                if(vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum)
                {
                    vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn;
                    vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
                }
                break;
            case TID_UNALLOC_SPACE_DESC: // ISO 13346 3/10.8
                if(vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum)
                {
                    vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn;
                    vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
                }
                break;
            case TID_TERMINATING_DESC: // ISO 13346 3/10.9
                vds[VDS_POS_TERMINATING_DESC].block = block;
                done = TRUE;
                break;
        }
    }
    return STATUS_SUCCESS;
} // UDFReadVDS()

Referenced by UDFProcessSequence(), UDFReadVDS(), UDFUpdateVDS(), and UDFVerifySequence().

◆ UDFRecordDirectory__()

OSSTATUS UDFRecordDirectory__	(	IN PVCB	Vcb,
		IN OUT PUDF_FILE_INFO	DirInfo
	)

Definition at line 3384 of file udf_info.cpp.

{
    OSSTATUS status;
    LONG_AD FEicb;
    UDF_FILE_INFO FileInfo;
    UDF_DATALOC_INFO Dloc;
    UNICODE_STRING PName;
    uint32 PartNum;
    SIZE_T WrittenBytes;
    PDIR_INDEX_ITEM CurDirNdx;
    uint32 lba;
 
    // validate DirInfo
    ValidateFileInfo(DirInfo);
    if(DirInfo->ParentFile && UDFIsAStreamDir(DirInfo->ParentFile))
        return STATUS_ACCESS_DENIED;
    // file should be empty
    if(UDFGetFileSize(DirInfo)) {
        if( DirInfo->FileIdent &&
           (DirInfo->FileIdent->fileCharacteristics & FILE_DIRECTORY)) return STATUS_FILE_IS_A_DIRECTORY;
        return STATUS_NOT_A_DIRECTORY;
    }
    if(DirInfo->Dloc->DirIndex) return STATUS_FILE_IS_A_DIRECTORY;
    // create empty DirIndex
    if(DirInfo->FileIdent) DirInfo->FileIdent->fileCharacteristics |= FILE_DIRECTORY;
    if((CurDirNdx = UDFDirIndex(UDFGetDirIndexByFileInfo(DirInfo),DirInfo->Index)))
        CurDirNdx->FileCharacteristics |= FILE_DIRECTORY;
    ((icbtag*)(DirInfo->Dloc->FileEntry+1))->fileType = UDF_FILE_TYPE_DIRECTORY;
    // init temporary FileInfo
    RtlZeroMemory(&FileInfo, sizeof(UDF_FILE_INFO));
    FileInfo.Dloc = &Dloc;
    FileInfo.Dloc->FileEntry = DirInfo->ParentFile->Dloc->FileEntry;
    FileInfo.Dloc->FileEntryLen = DirInfo->ParentFile->Dloc->FileEntryLen;
    FileInfo.Dloc->DataLoc = DirInfo->Dloc->DataLoc;
    FileInfo.Dloc->FELoc = DirInfo->Dloc->FELoc;
    FileInfo.ParentFile = DirInfo;
    // prepare FileIdent for 'parent Dir'
    lba = DirInfo->Dloc->FELoc.Mapping[0].extLocation;
    ASSERT(lba);
    PartNum = UDFGetPartNumByPhysLba(Vcb, lba);
    FEicb.extLength = Vcb->LBlockSize;
    FEicb.extLocation.logicalBlockNum = UDFPhysLbaToPart(Vcb, PartNum, lba);
    FEicb.extLocation.partitionReferenceNum = (uint16)PartNum;
    RtlZeroMemory(&(FEicb.impUse), sizeof(FEicb.impUse));
    PName.Buffer = (PWCH)L"";
    PName.Length = (PName.MaximumLength = sizeof(L"")) - sizeof(WCHAR);
    if(!OS_SUCCESS(status =
        UDFBuildFileIdent(Vcb, &PName, &FEicb, 0,
                &(FileInfo.FileIdent), &(FileInfo.FileIdentLen)) ))
        return status;
    FileInfo.FileIdent->fileCharacteristics |= (FILE_PARENT | FILE_DIRECTORY);
    UDFDecFileCounter(Vcb);
    UDFIncDirCounter(Vcb);
    // init structure
    UDFSetUpTag(Vcb, &(FileInfo.FileIdent->descTag), (uint16)(FileInfo.FileIdentLen),
              FEicb.extLocation.logicalBlockNum);
    FileInfo.Dloc->DataLoc.Flags |= EXTENT_FLAG_VERIFY; // for metadata
    // flush
    status = UDFWriteFile__(Vcb, DirInfo, 0, FileInfo.FileIdentLen, FALSE, (int8*)(FileInfo.FileIdent), &WrittenBytes);
//    status = UDFFlushFI(Vcb, &FileInfo, PartNum);
 
#ifdef UDF_DBG
    if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
        ASSERT(UDFGetFileSize(DirInfo) <= UDFGetExtentLength(DirInfo->Dloc->DataLoc.Mapping));
    } else {
        ASSERT(((UDFGetFileSize(DirInfo)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)) ==
               ((UDFGetExtentLength(DirInfo->Dloc->DataLoc.Mapping)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)));
    }
#endif // UDF_DBG
 
    MyFreePool__(FileInfo.FileIdent);
    if(!OS_SUCCESS(status)) return status;
    if(CurDirNdx) CurDirNdx->FileCharacteristics =
        DirInfo->FileIdent->fileCharacteristics;
    return UDFIndexDirectory(Vcb, DirInfo);
} // end UDFRecordDirectory__()

Referenced by UDFCommonCreate(), and UDFCreateStreamDir__().

◆ UDFRecordVAT()

OSSTATUS UDFRecordVAT ( IN PVCB Vcb )

Definition at line 5036 of file udf_info.cpp.

{
    uint32 Offset;
    uint32 to_read;
    uint32 hdrOffset, hdrOffsetNew;
    uint32 hdrLen;
    OSSTATUS status;
    SIZE_T ReadBytes;
    uint32 len;
    uint16 PartNdx = (uint16)Vcb->VatPartNdx;
    uint16 PartNum = UDFGetPartNumByPartNdx(Vcb, PartNdx);
    uint32 root = UDFPartStart(Vcb, PartNum);
    PUDF_FILE_INFO VatFileInfo = Vcb->VatFileInfo;
    uint32 i;
    PEXTENT_MAP Mapping;
    uint32 off, BS, NWA;
    int8* Old;
    int8* New;
    uint32* Vat;
    uint8 AllocMode;
    uint32 VatLen;
    uint32 PacketOffset;
    uint32 BSh = Vcb->BlockSizeBits;
    uint32 MaxPacket = Vcb->WriteBlockSize >> BSh;
    uint32 OldLen;
    EntityID* eID;
 
    if(!(Vat = Vcb->Vat) || !VatFileInfo) return STATUS_INVALID_PARAMETER;
    // Disable VAT-based translation
    Vcb->Vat = NULL;
    // sync VAT and FSBM
    len = min(UDFPartLen(Vcb, PartNum), Vcb->FSBM_BitCount - root);
    len = min(Vcb->VatCount, len);
    for(i=0; i<len; i++) {
        if(UDFGetFreeBit(Vcb->FSBM_Bitmap, root+i))
            Vat[i] = UDF_VAT_FREE_ENTRY;
    }
    // Ok, now we shall construct new VAT image...
    // !!! NOTE !!!
    // Both VAT copies - in-memory & on-disc
    // contain _relative_ addresses
    OldLen = len = (uint32)UDFGetFileSize(Vcb->VatFileInfo);
    VatLen = (Vcb->LastLBA - root + 1) * sizeof(uint32);
    Old = (int8*)DbgAllocatePool(PagedPool, OldLen);
    if(!Old) {
        DbgFreePool(Vat);
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    // read old one
    status = UDFReadFile__(Vcb, VatFileInfo, 0, OldLen, FALSE, Old, &ReadBytes);
    if(!OS_SUCCESS(status)) {
        DbgFreePool(Vat);
        DbgFreePool(Old);
        return status;
    }
    // prepare some pointers
    // and fill headers
    if(Vcb->Partitions[PartNdx].PartitionType == UDF_VIRTUAL_MAP15) {
        Offset = 0;
        to_read =
        hdrOffset = len - sizeof(VirtualAllocationTable15);
        hdrLen = sizeof(VirtualAllocationTable15);
        hdrOffsetNew = VatLen;
        New = (int8*)DbgAllocatePool(PagedPool, VatLen + hdrLen);
        if(!New) {
            DbgFreePool(Vat);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlCopyMemory(New+hdrOffsetNew, Old+hdrOffset, hdrLen);
        ((VirtualAllocationTable15*)(New + hdrOffset))->previousVATICB =
            VatFileInfo->Dloc->FELoc.Mapping[0].extLocation - root;
        eID = &(((VirtualAllocationTable15*)(New + hdrOffset))->ident);
 
        UDFSetEntityID_imp(eID, UDF_ID_ALLOC);
 
/*        RtlCopyMemory((int8*)&(eID->ident), UDF_ID_ALLOC, sizeof(UDF_ID_ALLOC) );
        iis = (impIdentSuffix*)&(eID->identSuffix);
        iis->OSClass = UDF_OS_CLASS_WINNT;
        iis->OSIdent = UDF_OS_ID_WINNT;*/
    } else {
        VirtualAllocationTable20* Buf;
 
        Offset = ((VirtualAllocationTable20*)Old)->lengthHeader;
        to_read = len - Offset;
        hdrOffset = 0;
        hdrLen = sizeof(VirtualAllocationTable20);
        hdrOffsetNew = 0;
        New = (int8*)DbgAllocatePool(PagedPool, VatLen + hdrLen);
        if(!New) {
            DbgFreePool(Vat);
            return STATUS_INSUFFICIENT_RESOURCES;
        }
        RtlCopyMemory(New+hdrOffsetNew, Old+hdrOffset, hdrLen);
        ((VirtualAllocationTable20*)New)->previousVatICBLoc =
            VatFileInfo->Dloc->FELoc.Mapping[0].extLocation - root;
 
        Buf = (VirtualAllocationTable20*)New;
 
        Buf->minReadRevision  = Vcb->minUDFReadRev;
        Buf->minWriteRevision = Vcb->minUDFWriteRev;
        Buf->maxWriteRevision = Vcb->maxUDFWriteRev;
 
        Buf->numFIDSFiles       = Vcb->numFiles;
        Buf->numFIDSDirectories = Vcb->numDirs;
    }
 
    RtlCopyMemory(New+Offset, Vat, VatLen);
    //
    if(VatFileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY) {
        eID = &(((PEXTENDED_FILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->impIdent);
    } else {
        eID = &(((PFILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->impIdent);
    }
 
#if 0
    UDFSetEntityID_imp(eID, UDF_ID_DEVELOPER);
#endif
 
/*    RtlCopyMemory((int8*)&(eID->ident), UDF_ID_DEVELOPER, sizeof(UDF_ID_DEVELOPER) );
    iis = (impIdentSuffix*)&(eID->identSuffix);
    iis->OSClass = UDF_OS_CLASS_WINNT;
    iis->OSIdent = UDF_OS_ID_WINNT;*/
 
    VatFileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    // drop VAT
    DbgFreePool(Vat);
    len = VatLen;
    // the operation of resize can modifiy WriteCount in WCache due to movement
    // of the data from FE. That's why we should remember PacketOffset now
    if(to_read < VatLen) {
        status = UDFResizeFile__(Vcb, VatFileInfo, len = hdrLen + VatLen);
        if(!OS_SUCCESS(status)) {
            return status;
        }
        UDFMarkSpaceAsXXX(Vcb, VatFileInfo->Dloc, VatFileInfo->Dloc->DataLoc.Mapping, AS_DISCARDED); //free
    }
    PacketOffset = WCacheGetWriteBlockCount__(&(Vcb->FastCache));
    if( ((((PFILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) ) {
        // now we'll place FE & built-in data to the last sector of
        // the last packet will be recorded
        if(!PacketOffset) {
            // add padding
            UDFWriteData(Vcb, TRUE, ((uint64)Vcb->NWA) << Vcb->BlockSizeBits, 1, FALSE, Old, &ReadBytes);
            PacketOffset++;
        } else {
            Vcb->Vat = (uint32*)(New+Offset);
            WCacheSyncReloc__(&(Vcb->FastCache), Vcb);
            Vcb->Vat = NULL;
        }
        VatFileInfo->Dloc->FELoc.Mapping[0].extLocation =
        VatFileInfo->Dloc->DataLoc.Mapping[0].extLocation =
            Vcb->NWA+PacketOffset;
        VatFileInfo->Dloc->FELoc.Modified = TRUE;
        // setup descTag
        ((PFILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->descTag.tagLocation =
            UDFPhysLbaToPart(Vcb, PartNum, VatFileInfo->Dloc->DataLoc.Mapping[0].extLocation);
        // record data
        if(OS_SUCCESS(status = UDFWriteFile__(Vcb, VatFileInfo, 0, VatLen + hdrLen, FALSE, New, &ReadBytes))) {
            status = UDFFlushFile__(Vcb, VatFileInfo);
        }
        return status;
    }
    // We can't fit the whole VAT in FE tail
    // Now lets 'unpack' VAT's mapping to make updating easier
    status = UDFUnPackMapping(Vcb, &(VatFileInfo->Dloc->DataLoc));
    if(!OS_SUCCESS(status)) return status;
    // update VAT with locations of not flushed blocks
    if(PacketOffset) {
        Vcb->Vat = (uint32*)(New+Offset);
        WCacheSyncReloc__(&(Vcb->FastCache), Vcb);
        Vcb->Vat = NULL;
    }
 
    Mapping = VatFileInfo->Dloc->DataLoc.Mapping;
    off=0;
    BS = Vcb->BlockSize;
    NWA = Vcb->NWA;
    VatLen += hdrLen;
    // record modified parts of VAT & update mapping
    for(i=0; Mapping[i].extLength; i++) {
        to_read = (VatLen>=BS) ? BS : VatLen;
        if((OldLen < off) || (RtlCompareMemory(Old+off, New+off, to_read) != to_read)) {
            // relocate frag
            Mapping[i].extLocation = NWA+PacketOffset;
            Mapping[i].extLength &= UDF_EXTENT_LENGTH_MASK;
            PacketOffset++;
            if(PacketOffset >= MaxPacket) {
                NWA += (MaxPacket + 7);
                PacketOffset = 0;
            }
            status = UDFWriteFile__(Vcb, VatFileInfo, off, to_read, FALSE, New+off, &ReadBytes);
            if(!OS_SUCCESS(status)) {
                return status;
            }
        }
        VatLen-=BS;
        off+=BS;
    }
    // pack mapping
    UDFPackMapping(Vcb, &(VatFileInfo->Dloc->DataLoc));
    len = UDFGetMappingLength(VatFileInfo->Dloc->DataLoc.Mapping)/sizeof(EXTENT_MAP) - 1;
    // obtain AllocMode
    AllocMode = ((PFILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK;
    switch(AllocMode) {
    case ICB_FLAG_AD_SHORT: {
        AllocMode = sizeof(SHORT_AD);
        break;
    }
    case ICB_FLAG_AD_LONG: {
        AllocMode = sizeof(LONG_AD);
        break;
    }
    case ICB_FLAG_AD_EXTENDED: {
//            break;
    }
    default: {
        return STATUS_INVALID_PARAMETER;
    }
    }
    // calculate actual AllocSequence length (in blocks)
    len = (len*AllocMode+BS-1+VatFileInfo->Dloc->AllocLoc.Offset) /
//          (((BS - sizeof(ALLOC_EXT_DESC))/sizeof(SHORT_AD))*sizeof(SHORT_AD));
        ((BS - sizeof(ALLOC_EXT_DESC) + AllocMode - 1) & ~(AllocMode-1));
    // Re-init AllocLoc
    if(VatFileInfo->Dloc->AllocLoc.Mapping) MyFreePool__(VatFileInfo->Dloc->AllocLoc.Mapping);
    VatFileInfo->Dloc->AllocLoc.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , (len+1)*sizeof(EXTENT_MAP),
                                                       MEM_EXTMAP_TAG);
    if(!(VatFileInfo->Dloc->AllocLoc.Mapping)) return STATUS_INSUFFICIENT_RESOURCES;
 
    VatFileInfo->Dloc->AllocLoc.Offset = (uint32)(VatFileInfo->Dloc->FELoc.Length);
    VatFileInfo->Dloc->AllocLoc.Length = 0;
    Mapping = VatFileInfo->Dloc->AllocLoc.Mapping;
    Mapping[0].extLength = BS-VatFileInfo->Dloc->AllocLoc.Offset;
//  Mapping[0].extLocation = ???;
    for(i=1; i<len; i++) {
        // relocate frag
        Mapping[i].extLocation = NWA+PacketOffset;
        Mapping[i].extLength = BS;
        PacketOffset++;
        if(PacketOffset >= MaxPacket) {
            NWA += (MaxPacket + 7);
            PacketOffset = 0;
        }
    }
    // Terminator
    Mapping[i].extLocation =
    Mapping[i].extLength = 0;
 
    if( !PacketOffset &&
        (VatFileInfo->Dloc->AllocLoc.Length <= (Vcb->BlockSize - (uint32)(VatFileInfo->Dloc->AllocLoc.Offset)) ) ) {
        // add padding
        UDFWriteData(Vcb, TRUE, ((uint64)NWA) << Vcb->BlockSizeBits, 1, FALSE, Old, &ReadBytes);
        PacketOffset++;
    }
    // now we'll place FE & built-in data to the last sector of
    // the last packet will be recorded
    VatFileInfo->Dloc->FELoc.Mapping[0].extLocation =
    VatFileInfo->Dloc->AllocLoc.Mapping[0].extLocation =
        NWA+PacketOffset;
    VatFileInfo->Dloc->FELoc.Modified = TRUE;
    // setup descTag
    ((PFILE_ENTRY)(VatFileInfo->Dloc->FileEntry))->descTag.tagLocation =
        UDFPhysLbaToPart(Vcb, PartNum, VatFileInfo->Dloc->FELoc.Mapping[0].extLocation);
    VatFileInfo->Dloc->DataLoc.Modified = TRUE;
 
    status = UDFFlushFile__(Vcb, VatFileInfo);
    if(!OS_SUCCESS(status))
        return status;
    WCacheFlushAll__(&(Vcb->FastCache), Vcb);
    return STATUS_SUCCESS;
} // end UDFRecordVAT()

Referenced by UDFUmount__().

◆ UDFReleaseDloc()

OSSTATUS UDFReleaseDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1224 of file dirtree.cpp.

{
    UDFAcquireResourceExclusive(&(Vcb->DlocResource2),TRUE);
    Dloc->FE_Flags &= ~UDF_FE_FLAG_UNDER_INIT;
    UDFReleaseResource(&(Vcb->DlocResource2));
    return STATUS_SUCCESS;
} // end UDFReleaseDloc()

Referenced by UDFCreateFile__(), UDFCreateRootFile__(), UDFOpenFile__(), UDFOpenRootFile__(), and UDFStoreDloc().

◆ UDFReleaseDlocList()

void UDFReleaseDlocList ( IN PVCB Vcb )

Definition at line 1396 of file dirtree.cpp.

{
    if(!Vcb->DlocList) return;
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
    for(uint32 i=0; i<Vcb->DlocCount; i++) {
        if(Vcb->DlocList[i].Dloc)
            MyFreePool__(Vcb->DlocList[i].Dloc);
    }
    MyFreePool__(Vcb->DlocList);
    Vcb->DlocList = NULL;
    Vcb->DlocCount = 0;
    UDFReleaseResource(&(Vcb->DlocResource));
} // end UDFReleaseDlocList()

Referenced by UDFCleanupVCB().

◆ UDFRelocateDloc()

void UDFRelocateDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc,
		IN uint32	NewLba
	)

Definition at line 1374 of file dirtree.cpp.

{
    LONG i;
 
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
 
    if((i = UDFFindDlocInMem(Vcb, Dloc)) != (-1)) {
        ASSERT(Vcb->DlocList);
        Vcb->DlocList[i].Lba = NewLba;
    }
    UDFReleaseResource(&(Vcb->DlocResource));
 
} // end UDFRelocateDloc()

Referenced by UDFFlushFE().

◆ UDFRelocateSector()

uint32 __fastcall UDFRelocateSector	(	IN PVCB	Vcb,
		IN uint32	Lba
	)

Definition at line 934 of file remap.cpp.

{
    uint32 i, max, BS, orig;
 
    if(Vcb->SparingTable) {
        // use sparing table for relocation
        uint32 _Lba;
        PSPARING_MAP Map = Vcb->SparingTable;
 
        max = Vcb->SparingCount;
        BS = Vcb->SparingBlockSize;
        _Lba = Lba & ~(BS-1);
        for(i=0;i<max;i++,Map++) {
            orig = Map->origLocation;
            if(_Lba == (orig & ~(BS-1)) ) {
            //if( (Lba >= (orig = Map->origLocation)) && (Lba < orig + BS) ) {
                return Map->mappedLocation + Lba - orig;
            }
        }
    } else if(Vcb->Vat) {
        // use VAT for relocation
        uint32* Map = Vcb->Vat;
        uint32 root;
        // check if given Lba lays in the partition covered by VAT
        if(Lba >= Vcb->NWA)
            return Vcb->NWA;
        if(Lba < (root = Vcb->Partitions[Vcb->VatPartNdx].PartitionRoot))
            return Lba;
        Map = &(Vcb->Vat[(i = Lba - root)]);
        if((i < Vcb->VatCount) && (i=(*Map)) ) {
            if(i != UDF_VAT_FREE_ENTRY) {
                return i + root;
            } else {
                return 0x7fffffff;
            }
        }
    }
    return Lba;
} // end UDFRelocateSector()

Referenced by UDFRelocateSectors().

◆ UDFRelocateSectors()

PEXTENT_MAP __fastcall UDFRelocateSectors	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BlockCount
	)

Definition at line 1029 of file remap.cpp.

{
    if(!UDFAreSectorsRelocated(Vcb, Lba, BlockCount)) return UDF_NO_EXTENT_MAP;
 
    PEXTENT_MAP Extent=NULL, Extent2;
    uint32 NewLba, LastLba, j, i;
    EXTENT_AD locExt;
 
    LastLba = UDFRelocateSector(Vcb, Lba);
    for(i=0, j=1; i<BlockCount; i++, j++) {
        // create new entry if the extent in not contigous
        if( ((NewLba = UDFRelocateSector(Vcb, Lba+i+1)) != (LastLba+1)) ||
            (i==(BlockCount-1)) ) {
            locExt.extLength = j << Vcb->BlockSizeBits;
            locExt.extLocation = LastLba-j+1;
            Extent2 = UDFExtentToMapping(&locExt);
            if(!Extent) {
                Extent = Extent2;
            } else {
                Extent = UDFMergeMappings(Extent, Extent2);
                MyFreePool__(Extent2);
            }
            if(!Extent) return NULL;
            j = 0;
        }
        LastLba = NewLba;
    }
    return Extent;
} // end UDFRelocateSectors()

Referenced by UDFTRead(), and UDFTWrite().

◆ UDFRemapPacket()

OSSTATUS __fastcall UDFRemapPacket	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN BOOLEAN	RemapSpared
	)

Definition at line 810 of file remap.cpp.

{
    uint32 i, max, BS, orig;
    PSPARING_MAP Map;
    BOOLEAN verified = FALSE;
 
    if(Vcb->SparingTable) {
 
        max = Vcb->SparingCount;
        BS = Vcb->SparingBlockSize;
 
        // use sparing table for relocation
        if(Vcb->SparingCountFree == (ULONG)-1) {
            UDFPrint(("calculate free spare areas\n"));
re_check:
            UDFPrint(("verify spare area\n"));
            Vcb->SparingCountFree = 0;
            Map = Vcb->SparingTable;
            for(i=0;i<max;i++,Map++) {
                if(Map->origLocation == SPARING_LOC_AVAILABLE) {
                    if(UDFCheckArea(Vcb, Map->mappedLocation, BS)) {
                        Vcb->SparingCountFree++;
                    } else {
                        UDFPrint(("initial check: bad spare block @ %x\n", Map->mappedLocation));
                        Map->origLocation = SPARING_LOC_CORRUPTED;
                        Vcb->SparingTableModified = TRUE;
                    }
                }
            }
        }
        if(!Vcb->SparingCountFree) {
            UDFPrint(("sparing table full\n"));
            return STATUS_DISK_FULL;
        }
 
        Map = Vcb->SparingTable;
        Lba &= ~(BS-1);
        for(i=0;i<max;i++,Map++) {
            orig = Map->origLocation;
            if(Lba == (orig & ~(BS-1)) ) {
                // already remapped
 
                UDFPrint(("remap remapped: bad spare block @ %x\n", Map->mappedLocation));
                if(!verified) {
                    verified = TRUE;
                    goto re_check;
                }
 
                if(!RemapSpared) {
                    return STATUS_SHARING_VIOLATION;
                } else {
                    // look for another remap area
                    Map->origLocation = SPARING_LOC_CORRUPTED;
                    Vcb->SparingTableModified = TRUE;
                    Vcb->SparingCountFree--;
                    break;
                }
            }
        }
        Map = Vcb->SparingTable;
        for(i=0;i<max;i++,Map++) {
            if(Map->origLocation == SPARING_LOC_AVAILABLE) {
                UDFPrint(("remap %x -> %x\n", Lba, Map->mappedLocation));
                Map->origLocation = Lba;
                Vcb->SparingTableModified = TRUE;
                Vcb->SparingCountFree--;
                return STATUS_SUCCESS;
            }
        }
        UDFPrint(("sparing table full\n"));
        return STATUS_DISK_FULL;
    }
    return STATUS_UNSUCCESSFUL;
} // end UDFRemapPacket()

◆ UDFRemoveDloc()

OSSTATUS UDFRemoveDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1299 of file dirtree.cpp.

{
    LONG i;
 
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
 
    if((i = UDFFindDlocInMem(Vcb, Dloc)) == (-1)) {
        // FE specified is not in cache. exit
        UDFReleaseResource(&(Vcb->DlocResource));
        return STATUS_INVALID_PARAMETER;
    }
    // remove from cache
    ASSERT(Vcb->DlocList);
    RtlZeroMemory(&(Vcb->DlocList[i]), sizeof(UDF_DATALOC_INDEX));
    UDFReleaseResource(&(Vcb->DlocResource));
    MyFreePool__(Dloc);
    return STATUS_SUCCESS;
} // end UDFRemoveDloc()

Referenced by UDFBuildFileEntry(), UDFCleanUpFile__(), and UDFHardLinkFile__().

◆ UDFRenameMoveFile__()

OSSTATUS UDFRenameMoveFile__	(	IN PVCB	Vcb,
		IN BOOLEAN	IgnoreCase,
		IN OUT BOOLEAN *	Replace,
		IN PUNICODE_STRING	fn,
		IN OUT PUDF_FILE_INFO	DirInfo1,
		IN OUT PUDF_FILE_INFO	DirInfo2,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 3176 of file udf_info.cpp.

{
    PUDF_FILE_INFO FileInfo2;
    OSSTATUS status;
    PDIR_INDEX_ITEM DirNdx1;
    PDIR_INDEX_ITEM DirNdx2;
    uint_di i,j;
    BOOLEAN Recovery = FALSE;
    BOOLEAN SameFE = FALSE;
    uint32 NTAttr = 0;
 
    // validate FileInfo
    ValidateFileInfo(DirInfo1);
    ValidateFileInfo(DirInfo2);
    ValidateFileInfo(FileInfo);
 
    i = j = 0;
    if(DirInfo1 == DirInfo2) {
        if(OS_SUCCESS(status = UDFFindFile(Vcb, IgnoreCase, TRUE, fn, DirInfo2, &j)) &&
           (j==FileInfo->Index) ) {
            // case-only rename
            uint8* CS0;
            SIZE_T Nlen, /* l, FIXME ReactOS */ IUl;
 
            // prepare filename
            UDFCompressUnicode(fn, &CS0, &Nlen);
            if(!CS0) return STATUS_INSUFFICIENT_RESOURCES;
/*            if(Nlen > UDF_NAME_LEN) {
                if(CS0) MyFreePool__(CS0);
                return STATUS_OBJECT_NAME_INVALID;
            }*/
            // allocate memory for FI
            DirNdx2 = UDFDirIndex(DirInfo2->Dloc->DirIndex,j);
            IUl = DirNdx2->FileInfo->FileIdent->lengthOfImpUse;
#if 0
            l = (sizeof(FILE_IDENT_DESC) + Nlen + IUl + 3) & ~((uint32)3);
#endif
 
            RtlCopyMemory( ((uint8*)(DirNdx2->FileInfo->FileIdent+1))+IUl, CS0, Nlen);
            RtlCopyMemory(DirNdx2->FName.Buffer, fn->Buffer, fn->Length);
 
            if(CS0) MyFreePool__(CS0);
 
            DirNdx2->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
            UDFBuildHashEntry(Vcb, &(DirNdx2->FName), &(DirNdx2->hashes), HASH_ALL);
            return STATUS_SUCCESS;
/*        } else
        if(!OS_SUCCESS(status) && (fn->Length == UDFDirIndex(DirInfo2->Dloc->DirIndex, j=FileInfo->Index)->FName.Length)) {
            // target file doesn't exist, but name lengthes are equal
            RtlCopyMemory((DirNdx1 = UDFDirIndex(DirInfo1->Dloc->DirIndex,j))->FName.Buffer, fn->Buffer, fn->Length);
            DirNdx1->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
            UDFBuildHashEntry(Vcb, &(DirNdx1->FName), &(DirNdx1->hashes), HASH_ALL);
            return STATUS_SUCCESS;*/
        }
    }
 
    // PHASE 0
    // try to create new FileIdent & FileEntry in Dir2
 
RenameRetry:
    if(!OS_SUCCESS(status = UDFCreateFile__(Vcb, IgnoreCase, fn, UDFGetFileEALength(FileInfo),
                    0, (FileInfo->Dloc->FileEntry->tagIdent == TID_EXTENDED_FILE_ENTRY),
                    TRUE, DirInfo2, &FileInfo2))) {
        UDFCleanUpFile__(Vcb, FileInfo2);
        if(FileInfo2) MyFreePool__(FileInfo2);
        if(status == STATUS_ACCESS_DENIED) {
            // try to recover >;->
            if((*Replace) && !Recovery) {
                Recovery = TRUE;
                status = UDFOpenFile__(Vcb, IgnoreCase, TRUE, fn, DirInfo2, &FileInfo2, NULL);
                if(OS_SUCCESS(status)) {
                    status = UDFDoesOSAllowFileToBeTargetForRename__(FileInfo2);
                    if(!OS_SUCCESS(status)) {
                        UDFCloseFile__(Vcb, FileInfo2);
                        goto cleanup_and_abort_rename;
                    }
                    status = UDFUnlinkFile__(Vcb, FileInfo2, TRUE);
//                    UDFPretendFileDeleted__(Vcb, FileInfo2);
                    UDFCloseFile__(Vcb, FileInfo2);
                    if(UDFCleanUpFile__(Vcb, FileInfo2)) {
                        MyFreePool__(FileInfo2);
                        FileInfo2 = NULL;
                        if(SameFE)
                            return status;
                    } else {
                        // we get here if the FileInfo has associated
                        // system-specific Fcb
                        // Such fact means that not all system references
                        // has already gone (except Linked file case)
/*                        if(SameFE)
                            return status;*/
//                        UDFRemoveOSReferences__(FileInfo2);
                        if(!OS_SUCCESS(status) ||
                           (UDFGetFileLinkCount(FileInfo2) < 1))
                            status = STATUS_ACCESS_DENIED;
                    }
                    if(OS_SUCCESS(status)) goto RenameRetry;
                }
cleanup_and_abort_rename:
                if(FileInfo2 && UDFCleanUpFile__(Vcb, FileInfo2)) {
                    MyFreePool__(FileInfo2);
                    FileInfo2 = NULL;
                }
            } else {
                status = STATUS_OBJECT_NAME_COLLISION;
            }
        }
        return status;
    }
    // update pointers
    DirNdx1 = UDFDirIndex(DirInfo1->Dloc->DirIndex, i = FileInfo->Index);
    DirNdx2 = UDFDirIndex(DirInfo2->Dloc->DirIndex, j = FileInfo2->Index);
 
    // copy file attributes to newly created FileIdent
    NTAttr = UDFAttributesToNT(DirNdx1, FileInfo->Dloc->FileEntry);
    FileInfo2->FileIdent->fileVersionNum = FileInfo->FileIdent->fileVersionNum;
    // unlink source FileIdent
    if(!OS_SUCCESS(status = UDFUnlinkFile__(Vcb, FileInfo, FALSE))) {
        // kill newly created entry
        UDFFlushFile__(Vcb, FileInfo2);
        UDFUnlinkFile__(Vcb, FileInfo2, TRUE);
        UDFCloseFile__(Vcb, FileInfo2);
        UDFCleanUpFile__(Vcb, FileInfo2);
        MyFreePool__(FileInfo2);
        return status;
    }
 
    // PHASE 1
    // drop all unnecessary info from FileInfo & flush FI
 
    DirNdx1->FileInfo = NULL;
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    UDFFlushFI(Vcb, FileInfo, UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation));
    UDFInterlockedExchangeAdd((PLONG)&(DirInfo1->OpenCount),
                            -((LONG)(FileInfo->RefCount)));
    // PHASE 2
    // copy all necessary info from FileInfo to FileInfo2
 
    FileInfo2->FileIdent->icb = FileInfo->FileIdent->icb;
    FileInfo2->FileIdent->fileCharacteristics = FileInfo->FileIdent->fileCharacteristics;
    FileInfo2->FileIdent->fileVersionNum = FileInfo->FileIdent->fileVersionNum;
    MyFreePool__(FileInfo->FileIdent);
    FileInfo->FileIdent = NULL;
 
    // PHASE 3
    // copy all necessary info from FileInfo2 to FileInfo
 
    DirNdx2->FileInfo = FileInfo;
    DirNdx2->FileCharacteristics = DirNdx1->FileCharacteristics & ~FILE_DELETED;
    DirNdx2->FileEntryLoc = DirNdx1->FileEntryLoc;
    DirNdx2->FI_Flags = (DirNdx1->FI_Flags & ~UDF_FI_FLAG_SYS_ATTR) | UDF_FI_FLAG_FI_MODIFIED;
    UDFInterlockedExchangeAdd((PLONG)&(DirInfo2->OpenCount),
                            FileInfo->RefCount - FileInfo2->RefCount);
 
    UDFAttributesToUDF(DirNdx2, FileInfo2->Dloc->FileEntry, NTAttr);
 
    FileInfo->Index = j;
    FileInfo->FileIdent = FileInfo2->FileIdent;
    FileInfo->FileIdentLen = FileInfo2->FileIdentLen;
    FileInfo->ParentFile = DirInfo2;
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
 
    ((icbtag*)(FileInfo->Dloc->FileEntry+1))->parentICBLocation =
        ((icbtag*)(FileInfo2->Dloc->FileEntry+1))->parentICBLocation;
 
    UDFIncFileLinkCount(FileInfo); // increase to 1
 
//    UDFUpdateModifyTime(Vcb, FileInfo);
 
    // PHASE 4
    // drop all unnecessary info from FileInfo2
 
    UDFFreeFESpace(Vcb, DirInfo2, &(FileInfo2->Dloc->FELoc));
    UDFUnlinkDloc(Vcb, FileInfo2->Dloc);
    UDFDecFileLinkCount(FileInfo2);
 
    FileInfo2->Dloc->FE_Flags &= ~UDF_FE_FLAG_FE_MODIFIED;
/*    MyFreePool__(FileInfo2->Dloc->FileEntry);
    FileInfo2->Dloc->FileEntry = NULL;*/
    FileInfo2->ParentFile = NULL;
    FileInfo2->FileIdent = NULL;
    FileInfo2->RefCount = 0;
    FileInfo2->Dloc->LinkRefCount = 0;
    ASSERT(FileInfo2->Dloc->DataLoc.Mapping);
    FileInfo2->Dloc->DataLoc.Mapping[0].extLocation = 0;
    FileInfo2->Dloc->DataLoc.Mapping[0].extLength = 0;
 
    UDFCleanUpFile__(Vcb, FileInfo2);
    MyFreePool__(FileInfo2);
 
    // return 'delete target' status
    (*Replace) = Recovery;
 
    return STATUS_SUCCESS;
} // end UDFRenameMoveFile__()

Referenced by UDFRename().

◆ UDFResizeExtent()

OSSTATUS UDFResizeExtent	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN int64	Length,
		IN BOOLEAN	AlwaysInIcb,
		OUT PEXTENT_INFO	ExtInfo
	)

Definition at line 2235 of file extent.cpp.

{
    uint32 i, flags, lba;
    SIZE_T lim;
    int64 l;
    OSSTATUS status;
    EXTENT_INFO TmpExtInf;
    EXTENT_MAP  TmpMapping[2];
    uint32 s, pe, BSh, PS;
    SIZE_T req_s;
    SIZE_T LBS = Vcb->LBlockSize;
    BSh = Vcb->BlockSizeBits;
    PS = Vcb->WriteBlockSize >> Vcb->BlockSizeBits;
    uint32 MaxGrow = (UDF_MAX_EXTENT_LENGTH & ~(LBS-1));
    BOOLEAN Sequential = FALSE;
 
    ASSERT(PartNum < 3);
 
    ExtPrint(("Resize ExtInfo %x, %I64x -> %I64x\n", ExtInfo, ExtInfo->Length, Length));
 
    if(ExtInfo->Flags & EXTENT_FLAG_CUT_PREALLOCATED) {
        AdPrint(("  cut preallocated\n"));
    } else
    if(ExtInfo->Length == Length) {
        return STATUS_SUCCESS;
    }
    if((ExtInfo->Flags & EXTENT_FLAG_ALLOC_MASK) == EXTENT_FLAG_ALLOC_SEQUENTIAL) {
        MaxGrow &= ~(Vcb->WriteBlockSize-1);
        Sequential = TRUE;
    }
 
    UDFCheckSpaceAllocation(Vcb, 0, ExtInfo->Mapping, AS_USED); // check if used
    if(ExtInfo->Offset) {
        if(ExtInfo->Offset + Length <= LBS) {
            ExtPrint(("Resize IN-ICB\n"));
            ExtInfo->Length = Length;
            return STATUS_SUCCESS;
        }
        if(!AlwaysInIcb)           // simulate unused 1st sector in extent
            ExtInfo->Offset = LBS; // it'll be truncated later
        Length += ExtInfo->Offset; // convert to real offset in extent
    }
    lba = UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, Length, NULL, NULL, &flags, &i);
    if(ExtInfo->Length < Length) {
        // increase extent
        if(OS_SUCCESS(UDFGetCachedAllocation(Vcb, ExtInfo->Mapping[0].extLocation,
                              &TmpExtInf, NULL, UDF_PREALLOC_CLASS_DIR))) {
            AdPrint(("Resize found cached(1)\n"));
            ExtInfo->Mapping = UDFMergeMappings(ExtInfo->Mapping, TmpExtInf.Mapping);
            MyFreePool__(TmpExtInf.Mapping);
        }
        if((l = UDFGetExtentLength(ExtInfo->Mapping)) >= Length) {
            // we have enough space inside extent
            ExtInfo->Length = Length;
            AdPrint(("Resize do nothing (1)\n"));
        } else /*if(lba == LBA_OUT_OF_EXTENT)*/ {
 
            Length -= ExtInfo->Offset;
            if(/*Length && l &&*/  (l % MaxGrow) &&
               (Length-1)/MaxGrow != (l-1)/MaxGrow) {
                AdPrint(("Crossing MAX_FRAG boundary...\n"));
                int64 l2 = ((l-1)/MaxGrow + 1)*MaxGrow;
                status = UDFResizeExtent(Vcb, PartNum, l2, AlwaysInIcb, ExtInfo);
                if(!OS_SUCCESS(status)) {
                    UDFPrint(("Sub-call to UDFResizeExtent() failed (%x)\n", status));
                    return status;
                }
                l = ExtInfo->Length;
                ASSERT(l == l2);
            }
            while((Length - l) > MaxGrow) {
                status = UDFResizeExtent(Vcb, PartNum, l+MaxGrow, AlwaysInIcb, ExtInfo);
                if(!OS_SUCCESS(status)) {
                    UDFPrint(("Sub-call (2) to UDFResizeExtent() failed (%x)\n", status));
                    return status;
                }
                l = ExtInfo->Length;
            }
            Length += ExtInfo->Offset;
            // at first, try to resize existing frag
#ifndef UDF_ALLOW_FRAG_AD
            i = UDFGetMappingLength(ExtInfo->Mapping);
            if(i > (LBS-sizeof(EXTENDED_FILE_ENTRY))) {
                // this is very important check since we will not
                // be able to _record_ too long AllocDesc because of
                // some DEMO limitations in UDFBuildXXXAllocDescs()
                AdPrint(("  DISK_FULL\n"));
                return STATUS_DISK_FULL;
            }
            i /= sizeof(EXTENT_MAP);
#else //UDF_ALLOW_FRAG_AD
            i = UDFGetMappingLength(ExtInfo->Mapping) / sizeof(EXTENT_MAP);
#endif //UDF_ALLOW_FRAG_AD
#ifdef ALLOW_SPARSE
            if(!AlwaysInIcb && !(ExtInfo->Offset) &&
               (Length - l >= (Vcb->SparseThreshold << BSh))) {
                // last frag will be Not-Alloc-Not-Rec...
                AdPrint(("Resize sparse (2)\n"));
                RtlZeroMemory(&TmpExtInf, sizeof(EXTENT_INFO));
                TmpExtInf.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , sizeof(EXTENT_MAP)*2,
                                                                   MEM_EXTMAP_TAG);
                if(!TmpExtInf.Mapping) return STATUS_INSUFFICIENT_RESOURCES;
                TmpExtInf.Mapping[0].extLength = (((uint32)(Length - l) + LBS-1) & ~(LBS-1)) | (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
                TmpExtInf.Mapping[0].extLocation =// 0;
                TmpExtInf.Mapping[1].extLength =
                TmpExtInf.Mapping[1].extLocation = 0;
                l = Length;
                ExtInfo->Mapping = UDFMergeMappings(ExtInfo->Mapping, TmpExtInf.Mapping);
                MyFreePool__(TmpExtInf.Mapping);
            } else
#endif //ALLOW_SPARSE
            // allocate some sectors
            if(i>1 && !(ExtInfo->Offset)) {
                i-=2;
                // check if Not-Alloc-Not-Rec at the end of mapping
                if((uint32)Length - (uint32)l + (ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK) > MaxGrow) {
                    // do nothing, but jump directly to allocator
                } else
                if((ExtInfo->Mapping[i].extLength >> 30) == EXTENT_NOT_RECORDED_NOT_ALLOCATED) {
                    AdPrint(("Resize grow sparse (3)\n"));
                    ExtInfo->Mapping[i].extLength +=
                        (((uint32)Length-(uint32)l+LBS-1) & ~(LBS-1)) ;
                    l = Length;
                // check if Alloc-Not-Rec at the end of mapping
                } else if((ExtInfo->Mapping[i].extLength >> 30) == EXTENT_NOT_RECORDED_ALLOCATED) {
                    AdPrint(("Resize grow Not-Rec (3)\n"));
                    // current length of last frag
                    s = ((ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
                    // prefered location of the next frag
                    lba = ExtInfo->Mapping[i].extLocation + s;
                    pe=UDFPartEnd(Vcb,PartNum);
                    // maximum frag length
                    if(Sequential) {
                        lim = (((uint32)UDF_MAX_EXTENT_LENGTH) >> BSh) & ~(PS-1);
                    } else {
                        lim = (((uint32)UDF_MAX_EXTENT_LENGTH) >> BSh) & ~(LBS-1);
                    }
                    // required last extent length
                    req_s = s + (uint32)( (((Length + LBS - 1) & ~(LBS-1)) -
                                           ((l      + LBS - 1) & ~(LBS-1))   ) >> BSh);
                    if(lim > req_s) {
                        lim = req_s;
                    }
                    UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
/*                    if((ExtInfo->Flags & EXTENT_FLAG_SEQUENTIAL) &&
                       ((Length & ~(PS-1)) > (l & ~(PS-1))) &&
                       TRUE) {
                        status = UDFResizeExtent(Vcb, PartNum, l+MaxGrow, AlwaysInIcb, ExtInfo);
                    }*/
                    // how many sectors we should add
                    req_s = lim - s;
                    ASSERT(req_s);
                    if((lba < pe) && UDFGetFreeBit(Vcb->FSBM_Bitmap, lba)) {
                        s += UDFGetBitmapLen((uint32*)(Vcb->FSBM_Bitmap), lba, min(pe, lba+req_s-1));
                    }
/*                    for(s1=lba; (s<lim) && (s1<pe) && UDFGetFreeBit(Vcb->FSBM_Bitmap, s1); s1++) {
                        s++;
                    }*/
                    if(s==lim) {
                        // we can just increase the last frag
                        AdPrint(("Resize grow last Not-Rec (4)\n"));
                        ExtInfo->Mapping[i].extLength = (lim << BSh) | (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                        l = Length;
                        UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &(ExtInfo->Mapping[i]), AS_USED); // mark as used
                    } else {
                        // we get here if simple increasing of last frag failed
                        // it worth truncating last frag and try to allocate
                        // all required data as a single frag
 
/*                        if(Sequential && s>=PS) {
                            s &= ~(PS-1);
                            AdPrint(("Resize grow last Not-Rec (4/2)\n"));
                            ExtInfo->Mapping[i].extLength = (s << BSh) | (EXTENT_NOT_RECORDED_ALLOCATED << 30);
                            l += (s << BSh);
                            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &(ExtInfo->Mapping[i]), AS_USED); // mark as used
                        }*/
                        AdPrint(("Resize reloc last Not-Rec (5)\n"));
                        TmpExtInf.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , (i+1)*sizeof(EXTENT_MAP),
                                                                           MEM_EXTMAP_TAG);
                        if(!TmpExtInf.Mapping) {
                            UDFPrint(("UDFResizeExtent: !TmpExtInf.Mapping\n"));
                            UDFReleaseResource(&(Vcb->BitMapResource1));
                            return STATUS_INSUFFICIENT_RESOURCES;
                        }
                        RtlCopyMemory(TmpExtInf.Mapping, ExtInfo->Mapping, i*sizeof(EXTENT_MAP));
                        TmpExtInf.Mapping[i].extLength =
                        TmpExtInf.Mapping[i].extLocation = 0;
                        TmpExtInf.Offset = ExtInfo->Offset;
                        l -= (ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK);
                        TmpExtInf.Length = l;
                        ASSERT(i || !ExtInfo->Offset);
                        UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &(ExtInfo->Mapping[i]), AS_DISCARDED); // mark as free
                        MyFreePool__(ExtInfo->Mapping);
                        (*ExtInfo) = TmpExtInf;
                    }
                    UDFCheckSpaceAllocation(Vcb, 0, ExtInfo->Mapping, AS_USED); // check if used
                    UDFReleaseResource(&(Vcb->BitMapResource1));
                // check if Alloc-Rec
                } else {
                    // current length of last frag
                    s = ((ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK) >> BSh);
                    // prefered location of the next frag
                    lba = ExtInfo->Mapping[i].extLocation + s;
                    pe=UDFPartEnd(Vcb,PartNum);
                    // maximum frag length
                    if(Sequential) {
                        lim = (((uint32)UDF_MAX_EXTENT_LENGTH) >> BSh) & ~(PS-1);
                    } else {
                        lim = (((uint32)UDF_MAX_EXTENT_LENGTH) >> BSh) & ~(LBS-1);
                    }
                    // required last extent length
                    req_s = s + (uint32)( (((Length + LBS - 1) & ~(LBS-1)) -
                                           ((l      + LBS - 1) & ~(LBS-1))   ) >> BSh);
                    if(lim > req_s) {
                        lim = req_s;
                    }
//                    s=0;
                    // how many sectors we should add
                    req_s = lim - s;
                    if(req_s) {
                        uint32 d=0;
 
                        UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
                        //ASSERT(req_s);
                        if((lba < pe) && UDFGetFreeBit(Vcb->FSBM_Bitmap, lba)) {
                            s += (d = UDFGetBitmapLen((uint32*)(Vcb->FSBM_Bitmap), lba, min(pe, lba+req_s-1)));
                        }
    /*                    for(s1=lba; (s<lim) && (s1<pe) && UDFGetFreeBit(Vcb->FSBM_Bitmap, s1); s1++) {
                            s++;
                        }*/
 
                        if(s==lim) {
                            AdPrint(("Resize grow last Rec (6)\n"));
                            // we can just increase last frag
                            TmpMapping[0].extLength = req_s << BSh;
                            TmpMapping[0].extLocation = lba;
                            TmpMapping[1].extLength =
                            TmpMapping[1].extLocation = 0;
                            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &TmpMapping[0], AS_USED); // mark as used
                            l += (s << BSh) - (ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK);
                            ExtInfo->Mapping[i].extLength = (ExtInfo->Mapping[i].extLength & UDF_EXTENT_FLAG_MASK) | (s << BSh);
                        } else if(d) {
                            AdPrint(("Resize part-grow last Rec (6)\n"));
                            // increase last frag, then alloc rest
                            TmpMapping[0].extLength = d << BSh;
                            TmpMapping[0].extLocation = lba;
                            TmpMapping[1].extLength =
                            TmpMapping[1].extLocation = 0;
                            UDFMarkSpaceAsXXXNoProtect(Vcb, 0, &TmpMapping[0], AS_USED); // mark as used
                            l += (s << BSh) - (ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK);
                            ExtInfo->Mapping[i].extLength = (ExtInfo->Mapping[i].extLength & UDF_EXTENT_FLAG_MASK) | (s << BSh);
                        } else {
                            AdPrint(("Can't grow last Rec (6)\n"));
                        }
                        UDFReleaseResource(&(Vcb->BitMapResource1));
                    } else {
                        AdPrint(("Max frag length reached (6)\n"));
                    }
                }
            }
            if(l < Length) {
                // we get here if simple increasing of the last frag failed
                AdPrint(("Resize add new frag (7)\n"));
                if(l < LBS && Length >= LBS &&
                   (ExtInfo->Flags & EXTENT_FLAG_ALLOC_MASK) == EXTENT_FLAG_ALLOC_SEQUENTIAL) {
                    AdPrint(("Resize tune for SEQUENTIAL i/o\n"));
                }
                status = UDFAllocFreeExtent(Vcb, Length - l,
                                                   UDFPartStart(Vcb, PartNum),
                                                   UDFPartEnd(Vcb, PartNum),
                                                   &TmpExtInf,
                                                   ExtInfo->Flags /*& EXTENT_FLAG_ALLOC_MASK*/);
                if(!OS_SUCCESS(status)) {
                    UDFPrint(("UDFResizeExtent: UDFAllocFreeExtent() failed (%x)\n", status));
                    return status;
                }
                ExtInfo->Mapping = UDFMergeMappings(ExtInfo->Mapping, TmpExtInf.Mapping);
                MyFreePool__(TmpExtInf.Mapping);
            }
            UDFPackMapping(Vcb, ExtInfo);
        }
    } else
    if(Length) {
        // decrease extent
        AdPrint(("Resize cut (8)\n"));
        lba = UDFExtentOffsetToLba(Vcb, ExtInfo->Mapping, Length-1, NULL, &lim, &flags, &i);
        i++;
        ASSERT(lba != LBA_OUT_OF_EXTENT);
        ASSERT(lba != LBA_NOT_ALLOCATED);
        ASSERT(i);
        if(ExtInfo->Mapping[i].extLength) {
            UDFCheckSpaceAllocation(Vcb, 0, &(ExtInfo->Mapping[i]), AS_USED); // check if used
            if(!ExtInfo->Offset && (ExtInfo->Flags & EXTENT_FLAG_PREALLOCATED)) {
 
                AdPrint(("Resize try save cutted (8)\n"));
                RtlZeroMemory(&TmpExtInf, sizeof(EXTENT_INFO));
                s = UDFGetMappingLength(&(ExtInfo->Mapping[i]));
 
                TmpExtInf.Mapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , s, MEM_EXTMAP_TAG);
                if(TmpExtInf.Mapping) {
                    RtlCopyMemory(TmpExtInf.Mapping, &(ExtInfo->Mapping[i]), s);
                    AdPrint(("Resize save cutted (8)\n"));
                    if(OS_SUCCESS(UDFStoreCachedAllocation(Vcb, ExtInfo->Mapping[0].extLocation,
                                               &TmpExtInf, 0, UDF_PREALLOC_CLASS_DIR))) {
                        ExtInfo->Mapping[i].extLength = 0;
                        ExtInfo->Mapping[i].extLocation = 0;
                        goto tail_cached;
                    }
                }
            }
            UDFMarkSpaceAsXXX(Vcb, 0, &(ExtInfo->Mapping[i]), AS_DISCARDED); // mark as free
tail_cached:;
        }
        if((lim-1 >= LBS) &&
           (flags != EXTENT_NOT_RECORDED_NOT_ALLOCATED)) {
            AdPrint(("i=%x, lba=%x, len=%x\n",i,lba,lim));
            ASSERT(lim);
//            BrutePoint();
            EXTENT_MAP ClrMap[2];
            ClrMap[0].extLength = lim & ~(LBS-1);
            s = (ExtInfo->Mapping[i-1].extLength - ClrMap[0].extLength) & UDF_EXTENT_LENGTH_MASK;
            ClrMap[0].extLocation = ExtInfo->Mapping[i-1].extLocation +
                                   (s >> BSh);
            ClrMap[1].extLength =
            ClrMap[1].extLocation = 0;
            ASSERT((ExtInfo->Mapping[i].extLocation <   ClrMap[0].extLocation) ||
                   (ExtInfo->Mapping[i].extLocation >= (ClrMap[0].extLocation + (ClrMap[0].extLength >> BSh))));
            UDFCheckSpaceAllocation(Vcb, 0, (PEXTENT_MAP)(&ClrMap), AS_USED); // check if used
            UDFMarkSpaceAsXXX(Vcb, 0, (PEXTENT_MAP)(&ClrMap), AS_DISCARDED); // mark as free
            ExtInfo->Mapping[i-1].extLength = s | (flags << 30);
        }
 
        s = UDFGetMappingLength(ExtInfo->Mapping);
        if(!MyReallocPool__((int8*)(ExtInfo->Mapping), s, (int8**)&(ExtInfo->Mapping), (i+1)*sizeof(EXTENT_MAP))) {
            // This must never happen on truncate !!!
            AdPrint(("ResizeExtent: MyReallocPool__(8) failed\n"));
        }
        ExtInfo->Mapping[i].extLength =
        ExtInfo->Mapping[i].extLocation = 0;
    } else {
        AdPrint(("Resize zero (9)\n"));
        ASSERT(!ExtInfo->Offset);
        UDFMarkSpaceAsXXX(Vcb, 0, ExtInfo->Mapping, AS_DISCARDED); // mark as free
        s = UDFGetMappingLength(ExtInfo->Mapping);
        if(!MyReallocPool__((int8*)(ExtInfo->Mapping), s, (int8**)&(ExtInfo->Mapping), 2*sizeof(EXTENT_MAP))) {
            // This must never happen on truncate !!!
            AdPrint(("ResizeExtent: MyReallocPool__(9) failed\n"));
        }
        ExtInfo->Mapping[0].extLength = LBS | (EXTENT_NOT_RECORDED_NOT_ALLOCATED << 30);
        ExtInfo->Mapping[0].extLocation =
        ExtInfo->Mapping[1].extLength =
        ExtInfo->Mapping[1].extLocation = 0;
    }
    if(ExtInfo->Offset) {
        if(!AlwaysInIcb) {
            // remove 1st entry pointing to FileEntry
            s = UDFGetMappingLength(ExtInfo->Mapping);
            RtlMoveMemory(&(ExtInfo->Mapping[0]), &(ExtInfo->Mapping[1]), s - sizeof(EXTENT_MAP));
            if(!MyReallocPool__((int8*)(ExtInfo->Mapping), s,
                          (int8**)&(ExtInfo->Mapping), s - sizeof(EXTENT_MAP) )) {
                // This must never happen on truncate !!!
                AdPrint(("ResizeExtent: MyReallocPool__(10) failed\n"));
            }
            Length -= ExtInfo->Offset;
            ExtInfo->Offset = 0;
        } else {
            Length -= ExtInfo->Offset; // back to in-icb
        }
    }
    ExtInfo->Length = Length;
    UDFCheckSpaceAllocation(Vcb, 0, ExtInfo->Mapping, AS_USED); // check if used
 
    for(i=0; (ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK); i++) {
        ExtPrint(("Resized Ext: type %x, loc %x, len %x\n",
            ExtInfo->Mapping[i].extLength >> 30, ExtInfo->Mapping[i].extLocation, ExtInfo->Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK));
    }
 
    return STATUS_SUCCESS;
} // end UDFResizeExtent()

Referenced by UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFCloseFile__(), UDFConvertFEToNonInICB(), UDFFlushFile__(), UDFResizeExtent(), UDFResizeFile__(), and UDFWriteFile__().

◆ UDFResizeFile__()

OSSTATUS UDFResizeFile__	(	IN PVCB	Vcb,
		IN OUT PUDF_FILE_INFO	FileInfo,
		IN int64	NewLength
	)

Definition at line 3468 of file udf_info.cpp.

{
    SIZE_T WrittenBytes;
    OSSTATUS status;
    uint32 PartNum;
    int8* OldInIcb = NULL;
    PEXTENT_MAP NewMap;
 
    UDFPrint(("UDFResizeFile__: FI %x, -> %I64x\n", FileInfo, NewLength));
    ValidateFileInfo(FileInfo);
//    ASSERT(FileInfo->RefCount >= 1);
 
    if((NewLength >> Vcb->LBlockSizeBits) > Vcb->TotalAllocUnits) {
        UDFPrint(("STATUS_DISK_FULL\n"));
        return STATUS_DISK_FULL;
    }
    if (NewLength == FileInfo->Dloc->DataLoc.Length) return STATUS_SUCCESS;
    if(FileInfo->ParentFile && (FileInfo->Index >= 2)) {
        UDFDirIndex(FileInfo->ParentFile->Dloc->DirIndex,FileInfo->Index)->FI_Flags &= ~UDF_FI_FLAG_SYS_ATTR;
    }
    if(NewLength > FileInfo->Dloc->DataLoc.Length) {
        // grow file
        return UDFWriteFile__(Vcb, FileInfo, NewLength, 0, FALSE, NULL, &WrittenBytes);
    }
    // truncate file
    if(NewLength <= (Vcb->LBlockSize - FileInfo->Dloc->FileEntryLen)) {
        // check if we are already in IN_ICB mode
        if((((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) != ICB_FLAG_AD_IN_ICB) {
            // read data from old location
            if(NewLength) {
                OldInIcb = (int8*)MyAllocatePool__(NonPagedPool, (uint32)NewLength);
                if(!OldInIcb) return STATUS_INSUFFICIENT_RESOURCES;
                status = UDFReadExtent(Vcb, &(FileInfo->Dloc->DataLoc), 0, (uint32)NewLength, FALSE, OldInIcb, &WrittenBytes);
                if(!OS_SUCCESS(status)) {
                    MyFreePool__(OldInIcb);
                    return status;
                }
            } else {
                OldInIcb = NULL;
            }
            // allocate storage for new mapping
            NewMap = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , 2*sizeof(EXTENT_MAP),
                                                               MEM_EXTMAP_TAG);
            if(!(NewMap)) {
                MyFreePool__(OldInIcb);
                return STATUS_INSUFFICIENT_RESOURCES;
            }
            // free old location...
            if(FileInfo->Dloc->DataLoc.Mapping[0].extLocation !=
               FileInfo->Dloc->FELoc.Mapping[0].extLocation) {
               ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
mark_data_map_0:
                UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, FileInfo->Dloc->DataLoc.Mapping, AS_DISCARDED); // free
            } else {
                if((FileInfo->Dloc->DataLoc.Mapping[0].extLength & UDF_EXTENT_LENGTH_MASK)
                       > Vcb->LBlockSize) {
                    BrutePoint();
                    FileInfo->Dloc->DataLoc.Mapping[0].extLength -= Vcb->LBlockSize;
                    FileInfo->Dloc->DataLoc.Mapping[0].extLocation += (1 << Vcb->LB2B_Bits);
                    goto mark_data_map_0;
                }
                UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, &(FileInfo->Dloc->DataLoc.Mapping[1]), AS_DISCARDED); // free
            }
            if(FileInfo->Dloc->AllocLoc.Mapping) {
                if((FileInfo->Dloc->AllocLoc.Mapping[0].extLength & UDF_EXTENT_LENGTH_MASK)
                       > Vcb->LBlockSize) {
                    FileInfo->Dloc->AllocLoc.Mapping[0].extLength -= Vcb->LBlockSize;
                    FileInfo->Dloc->AllocLoc.Mapping[0].extLocation += (1 << Vcb->LB2B_Bits);
                    UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, FileInfo->Dloc->AllocLoc.Mapping, AS_DISCARDED); // free
                } else {
                    UDFMarkSpaceAsXXX(Vcb, FileInfo->Dloc, &(FileInfo->Dloc->AllocLoc.Mapping[1]), AS_DISCARDED); // free
                }
                MyFreePool__(FileInfo->Dloc->AllocLoc.Mapping);
            }
            MyFreePool__(FileInfo->Dloc->DataLoc.Mapping);
            FileInfo->Dloc->AllocLoc.Mapping = NULL;
            FileInfo->Dloc->AllocLoc.Length = 0;
            FileInfo->Dloc->AllocLoc.Offset = 0;
            FileInfo->Dloc->AllocLoc.Modified = TRUE;
            // switch to IN_ICB mode
            ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags &= ~ICB_FLAG_ALLOC_MASK;
            ((PFILE_ENTRY)(FileInfo->Dloc->FileEntry))->icbTag.flags |= ICB_FLAG_AD_IN_ICB;
            // init new data location descriptors
            FileInfo->Dloc->DataLoc.Mapping = NewMap;
            RtlZeroMemory((int8*)(FileInfo->Dloc->DataLoc.Mapping), 2*sizeof(EXTENT_MAP));
            FileInfo->Dloc->DataLoc.Mapping[0] = FileInfo->Dloc->FELoc.Mapping[0];
            FileInfo->Dloc->DataLoc.Length = NewLength;
            FileInfo->Dloc->DataLoc.Offset = FileInfo->Dloc->FileEntryLen;
            // write data to new location
            if(OldInIcb) {
                status = UDFWriteExtent(Vcb, &(FileInfo->Dloc->DataLoc), 0, (uint32)NewLength, FALSE, OldInIcb, &WrittenBytes);
            } else {
                status = STATUS_SUCCESS;
            }
            FileInfo->Dloc->DataLoc.Modified = TRUE;
            if(OldInIcb) MyFreePool__(OldInIcb);
        } else {
            // just modify Length field
            FileInfo->Dloc->DataLoc.Length = NewLength;
            status = STATUS_SUCCESS;
        }
    } else {
        // resize extent
        ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        PartNum = UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
        status = UDFResizeExtent(Vcb, PartNum, NewLength, FALSE, &(FileInfo->Dloc->DataLoc));
        FileInfo->Dloc->DataLoc.Modified = TRUE;
        FileInfo->Dloc->AllocLoc.Modified = TRUE;
    }
    if(OS_SUCCESS(status)) {
        UDFSetFileSize(FileInfo, NewLength);
    }
 
#ifdef UDF_DBG
    if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
        ASSERT(UDFGetFileSize(FileInfo) <= UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping));
    } else {
        ASSERT(((UDFGetFileSize(FileInfo)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)) ==
               ((UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)));
    }
#endif // UDF_DBG
 
    return status;
} // end UDFResizeFile__()

Referenced by UDFCommonCleanup(), UDFCommonCreate(), UDFCommonWrite(), UDFConvertFEToExtended(), UDFCreateFile__(), UDFPackDirectory__(), UDFRecordVAT(), UDFSetAllocationInformation(), and UDFSetEOF().

◆ UDFReTagDirectory()

OSSTATUS UDFReTagDirectory	(	IN PVCB	Vcb,
		IN OUT PUDF_FILE_INFO	FileInfo
	)

Definition at line 895 of file dirtree.cpp.

{
    uint32 l;
    uint32 Offset;
    int8* Buf;
    OSSTATUS status;
    SIZE_T ReadBytes;
    PUDF_FILE_INFO curFileInfo;
    PDIR_INDEX_ITEM DirNdx;
    UDF_DIR_SCAN_CONTEXT ScanContext;
    uint16 PartNum;
 
    ValidateFileInfo(FileInfo);
    PDIR_INDEX_HDR hDirNdx = FileInfo->Dloc->DirIndex;
    if(!hDirNdx) return STATUS_NOT_A_DIRECTORY;
 
    // do not pack dirs on unchanged disks
    if(!Vcb->Modified)
        return STATUS_SUCCESS;
 
    if( ((hDirNdx->DIFlags & UDF_DI_FLAG_INIT_IN_ICB) ? TRUE : FALSE) ==
        ((FileInfo->Dloc->DataLoc.Offset) ? TRUE : FALSE) ) {
        return STATUS_SUCCESS;
    }
 
    // start packing
    Buf = (int8*)DbgAllocatePool(PagedPool, Vcb->LBlockSize*2);
    if(!Buf) return STATUS_INSUFFICIENT_RESOURCES;
 
    Offset = UDFDirIndex(hDirNdx,1)->Offset;
 
    if(!UDFDirIndexInitScan(FileInfo, &ScanContext, 1)) {
        DbgFreePool(Buf);
        return STATUS_SUCCESS;
    }
 
    ASSERT(FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    PartNum = (uint16)UDFGetPartNumByPhysLba(Vcb, FileInfo->Dloc->FELoc.Mapping[0].extLocation);
    ASSERT(PartNum != -1);
 
    while((DirNdx = UDFDirIndexScan(&ScanContext, NULL))) {
 
        status = UDFReadFile__(Vcb, FileInfo, Offset = DirNdx->Offset,
                                                   l = DirNdx->Length, FALSE, Buf, &ReadBytes);
        if(!OS_SUCCESS(status)) {
            DbgFreePool(Buf);
            return status;
        }
        curFileInfo = DirNdx->FileInfo;
        // write modified
        UDFSetUpTag(Vcb, (tag*)Buf, (uint16)l,
                  UDFPhysLbaToPart(Vcb, PartNum,
                             UDFExtentOffsetToLba(Vcb, FileInfo->Dloc->DataLoc.Mapping,
                                        Offset, NULL, NULL, NULL, NULL)));
 
        if(curFileInfo && curFileInfo->FileIdent) {
            FileInfo->Dloc->FELoc.Modified = TRUE;
            FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
        }
 
        status = UDFWriteFile__(Vcb, FileInfo, Offset, l, FALSE, Buf, &ReadBytes);
        if(!OS_SUCCESS(status)) {
            DbgFreePool(Buf);
            return status;
        }
        if(curFileInfo) {
            DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
        }
    }
    // resize DirIndex
    DbgFreePool(Buf);
 
    hDirNdx->DIFlags &= ~UDF_DI_FLAG_INIT_IN_ICB;
    hDirNdx->DIFlags |= (FileInfo->Dloc->DataLoc.Offset ? UDF_DI_FLAG_INIT_IN_ICB : 0);
    return status;
 
} // end UDFReTagDirectory()

Referenced by UDFFlushFE().

◆ UDFSetAllocDescLen()

void UDFSetAllocDescLen	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 1277 of file udf_info.cpp.

{
    uint16 Ident;
 
    ValidateFileInfo(FileInfo);
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(FileInfo->Dloc->AllocLoc.Length) {
            fe->lengthAllocDescs = min(FileInfo->Dloc->AllocLoc.Mapping[0].extLength -
                                       FileInfo->Dloc->AllocLoc.Offset,
                                       (uint32)(FileInfo->Dloc->AllocLoc.Length));
        } else
        if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
            fe->lengthAllocDescs = (uint32)(FileInfo->Dloc->DataLoc.Length);
        }
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        if(FileInfo->Dloc->AllocLoc.Length) {
            fe->lengthAllocDescs = min(FileInfo->Dloc->AllocLoc.Mapping[0].extLength -
                                       FileInfo->Dloc->AllocLoc.Offset,
                                       (uint32)(FileInfo->Dloc->AllocLoc.Length));
        } else
        if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
            fe->lengthAllocDescs = (uint32)(FileInfo->Dloc->DataLoc.Length);
        }
    }
} // end UDFSetAllocDescLen()

Referenced by UDFFlushFE().

◆ UDFSetEntityID_imp_()

void UDFSetEntityID_imp_	(	IN EntityID *	eID,
		IN uint8 *	Str,
		IN uint32	Len
	)

Definition at line 1542 of file udf_info.cpp.

{
    impIdentSuffix* iis;
 
    RtlCopyMemory( (int8*)&(eID->ident), Str, Len );
    iis = (impIdentSuffix*)&(eID->identSuffix);
    iis->OSClass = UDF_OS_CLASS_WINNT;
    iis->OSIdent = UDF_OS_ID_WINNT;
 
} // end UDFSetEntityID_imp_()

◆ UDFSetFileSize()

void UDFSetFileSize	(	IN PUDF_FILE_INFO	FileInfo,
		IN int64	Size
	)

Definition at line 1157 of file udf_info.cpp.

{
    uint16 Ident;
//    PDIR_INDEX_ITEM DirIndex;
 
    ValidateFileInfo(FileInfo);
    AdPrint(("UDFSetFileSize: %I64x, FI %x\n", Size, FileInfo));
 
    //AdPrint(("  Dloc %x\n", FileInfo->Dloc));
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    //AdPrint(("  FileEntry %x\n", FileInfo->Dloc->FileEntry));
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    //AdPrint(("  Ident %x\n", Ident));
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        //AdPrint(("  fe %x\n", fe));
        fe->informationLength = Size;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        //AdPrint(("  ext-fe %x\n", fe));
        fe->informationLength = Size;
    }
/*    if(DirIndex = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo),FileInfo->Index) ) {
        DirIndex->FileSize = Size;
    }*/
    //AdPrint(("UDFSetFileSize: ok\n"));
    return;
} // end UDFSetFileSize()

Referenced by UDFCreateFile__(), UDFCreateRootFile__(), UDFResizeFile__(), and UDFWriteFile__().

◆ UDFSetFileSizeInDirNdx()

void UDFSetFileSizeInDirNdx	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64 *	ASize
	)

Definition at line 1190 of file udf_info.cpp.

{
    uint16 Ident;
    PDIR_INDEX_ITEM DirIndex;
 
    ValidateFileInfo(FileInfo);
    if(ASize) {
        AdPrint(("UDFSetFileSizeInDirNdx: %I64x\n", *ASize));
    } else {
        AdPrint(("UDFSetFileSizeInDirNdx: sync\n"));
    }
 
    DirIndex = UDFDirIndex(UDFGetDirIndexByFileInfo(FileInfo),FileInfo->Index);
    if(!DirIndex)
       return;
 
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        DirIndex->FileSize = fe->informationLength;
        if(ASize) {
            DirIndex->AllocationSize = *ASize;
//        } else {
//            DirIndex->AllocationSize = (fe->informationLength + Vcb->LBlockSize - 1) & ~(Vcb->LBlockSize - 1);
        }
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        DirIndex->FileSize = fe->informationLength;
        if(ASize) {
            DirIndex->AllocationSize = *ASize;
//        } else {
//            DirIndex->AllocationSize = (fe->informationLength + Vcb->LBlockSize - 1) & ~(Vcb->LBlockSize - 1);
        }
    }
    return;
} // end UDFSetFileSizeInDirNdx()

Referenced by UDFCommonCleanup(), UDFCommonWrite(), UDFFlushAFile(), UDFSetBasicInformation(), and UDFSetEOF().

◆ UDFSetFileUID()

void UDFSetFileUID	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo
	)

Definition at line 1456 of file udf_info.cpp.

{
    uint16 Ident;
    int64 UID;
 
    ValidateFileInfo(FileInfo);
 
    UID = UDFAssingNewFUID(Vcb);
 
/*    UID = FileInfo->Dloc->FELoc.Mapping[0].extLocation |
          ( FileInfo->ParentFile ? (((int64)(FileInfo->ParentFile->Dloc->FELoc.Mapping[0].extLocation)) << 32) : 0);*/
 
    FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    Ident = FileInfo->Dloc->FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileInfo->Dloc->FileEntry);
        fe->uniqueID = UID;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileInfo->Dloc->FileEntry);
        fe->uniqueID = UID;
    }
    if(FileInfo->FileIdent)
        ((FidADImpUse*)&(FileInfo->FileIdent->icb.impUse))->uniqueID = (uint32)UID;
    return;
} // end UDFSetFileUID()

Referenced by UDFCreateFile__(), and UDFCreateRootFile__().

◆ UDFSetUpTag()

void UDFSetUpTag	(	IN PVCB	Vcb,
		IN tag *	Tag,
		IN uint16	DataLen,
		IN uint32	TagLoc
	)

Definition at line 936 of file udf_info.cpp.

{
    uint32 i;
    int8* tb;
 
    AdPrint(("UDF: SetTag Loc=%x(%x), tagIdent=%x\n", TagLoc, Tag->tagLocation, Tag->tagIdent));
 
    if(DataLen) DataLen -= sizeof(tag);
//    int8* Data = ((int8*)Tag) + sizeof(tag);
    // Ecma-167 states, that all implementations
    // shall set this field to '3' even if
    // disc contains descriptors recorded with
    // value '2'
    // But we should ignore this to make happy othe UDF implementations :(
    Tag->descVersion = (Vcb->NSRDesc & VRS_NSR03_FOUND) ? 3 : 2;
    Tag->tagLocation = TagLoc;
    Tag->tagSerialNum = (uint16)(Vcb->SerialNumber + 1);
    Tag->descCRCLength = DataLen;
    Tag->descCRC = UDFCrc((uint8*)(Tag+1), DataLen);
    Tag->tagChecksum = 0;
    tb = ((int8*)Tag);
    for (i=0; i<sizeof(tag); i++,tb++)
        Tag->tagChecksum += (i!=4) ? (*tb) : 0;
} // end UDFSetUpTag()

Referenced by UDFBuildLongAllocDescs(), UDFBuildShortAllocDescs(), UDFFlushFE(), UDFFlushFI(), UDFPackDirectory__(), UDFPrepareXSpaceBitmap(), UDFRecordDirectory__(), UDFReTagDirectory(), UDFUpdateLogicalVol(), UDFUpdateLogicalVolInt(), UDFUpdatePartDesc(), and UDFUpdateVolIdent().

◆ UDFShortAllocDescToMapping()

PEXTENT_MAP UDFShortAllocDescToMapping	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN PLONG_AD	AllocDesc,
		IN uint32	AllocDescLength,
		IN uint32	SubCallCount,
		OUT PEXTENT_INFO	AllocLoc
	)

◆ UDFSparseFile__()

__inline OSSTATUS UDFSparseFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64	Offset,
		IN uint32	Length,
		IN BOOLEAN	Direct,
		OUT uint32 *	ReadBytes
	)

◆ UDFStoreCachedAllocation()

OSSTATUS UDFStoreCachedAllocation	(	IN PVCB	Vcb,
		IN uint32	ParentLocation,
		IN PEXTENT_INFO	Ext,
		IN uint32	Items,
		IN uint32	AllocClass
	)

Definition at line 1457 of file extent.cpp.

{
    PUDF_ALLOCATION_CACHE_ITEM AllocCache;
    uint32 i, lim;
    OSSTATUS status;
 
    UDFAcquireResourceExclusive(&(Vcb->PreallocResource),TRUE);
 
    status = UDFInitAllocationCache(Vcb, AllocClass, &AllocCache, &lim, TRUE);
    if(!OS_SUCCESS(status)) {
        UDFReleaseResource(&(Vcb->PreallocResource));
        return status;
    }
    UDFPrint(("Store AllocationCache for %x, map %x\n", ParentLocation, Ext->Mapping));
 
    for(i=0; i<lim; i++) {
        if(AllocCache[i].ParentLocation == LBA_NOT_ALLOCATED) {
            AdPrint(("    stored in %x\n", i));
            AllocCache[i].Ext = (*Ext);
            AllocCache[i].Items = Items;
            AllocCache[i].ParentLocation = ParentLocation;
            UDFReleaseResource(&(Vcb->PreallocResource));
            return STATUS_SUCCESS;
        }
    }
    //
    AdPrint(("    drop map %x (%x)\n", AllocCache[lim-1].Ext.Mapping, lim-1));
    switch(AllocClass) {
    case UDF_PREALLOC_CLASS_FE:
        UDFDiscardFESpace(Vcb, AllocCache[lim-1].Ext.Mapping, AllocCache[lim-1].Items);
        break;
    case UDF_PREALLOC_CLASS_DIR:
        UDFMarkSpaceAsXXX(Vcb, 0, AllocCache[lim-1].Ext.Mapping, AS_DISCARDED);
        break;
    }
    RtlMoveMemory(&(AllocCache[1]), &(AllocCache[0]), sizeof(UDF_ALLOCATION_CACHE_ITEM)*(lim-1));
    AllocCache[0].Ext = (*Ext);
    AllocCache[0].Items = Items;
    AllocCache[0].ParentLocation = ParentLocation;
    AdPrint(("    stored in 0\n"));
    UDFReleaseResource(&(Vcb->PreallocResource));
    return STATUS_SUCCESS;
} // end UDFStoreCachedAllocation()

Referenced by UDFFlushFESpace(), and UDFResizeExtent().

◆ UDFStoreDloc()

OSSTATUS UDFStoreDloc	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	fi,
		IN uint32	Lba
	)

Definition at line 1240 of file dirtree.cpp.

{
    LONG i;
    PUDF_DATALOC_INFO Dloc;
 
    if(!Lba) return STATUS_INVALID_PARAMETER;
    if(Lba == (ULONG)-1) return STATUS_INVALID_PARAMETER;
 
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
 
    // check if FE specified is already in use
    if((i = UDFFindDloc(Vcb, Lba)) == (-1)) {
        // not used
        if((i = UDFFindFreeDloc(Vcb, Lba)) == (-1)) {
            UDFReleaseResource(&(Vcb->DlocResource));
            return STATUS_INSUFFICIENT_RESOURCES;
        }
    } else {
        if(!OS_SUCCESS(UDFAcquireDloc(Vcb, Dloc = Vcb->DlocList[i].Dloc))) {
            UDFReleaseResource(&(Vcb->DlocResource));
            return STATUS_SHARING_PAUSED;
        }
        // update caller's structures & exit
        fi->Dloc = Dloc;
        UDFReleaseDloc(Vcb, Dloc);
#if defined UDF_DBG && !defined _CONSOLE
        if(fi->Dloc->CommonFcb) {
            ASSERT((uint32)(fi->Dloc->CommonFcb) != 0xDEADDA7A);
            ASSERT(fi->Dloc->CommonFcb->CommonFCBHeader.NodeTypeCode == UDF_NODE_TYPE_NT_REQ_FCB);
        }
#endif // UDF_DBG
        UDFReleaseResource(&(Vcb->DlocResource));
        return STATUS_SUCCESS;
    }
    // allocate common DataLocation (Dloc) descriptor
    Dloc = fi->Dloc = (PUDF_DATALOC_INFO)MyAllocatePoolTag__(UDF_DATALOC_INFO_MT, sizeof(UDF_DATALOC_INFO), MEM_DLOC_INF_TAG);
    if(!Dloc) {
        UDFReleaseResource(&(Vcb->DlocResource));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    Vcb->DlocList[i].Lba = Lba;
    Vcb->DlocList[i].Dloc = Dloc;
    RtlZeroMemory(Dloc, sizeof(UDF_DATALOC_INFO));
    Dloc->LinkedFileInfo = fi;
    UDFAcquireDloc(Vcb, Dloc);
    UDFReleaseResource(&(Vcb->DlocResource));
    return STATUS_SUCCESS;
} // end UDFStoreDloc()

Referenced by UDFBlankMount(), UDFBuildFileEntry(), UDFOpenFile__(), and UDFOpenRootFile__().

◆ UDFUmount__()

OSSTATUS UDFUmount__ ( IN PVCB Vcb )

Definition at line 921 of file mount.cpp.

{
#ifndef UDF_READ_ONLY_BUILD
    uint32 flags = 0;
 
    if((Vcb->VCBFlags & UDF_VCB_FLAGS_VOLUME_READ_ONLY)
        || !Vcb->Modified)
        return STATUS_SUCCESS;
    // prevent discarding metadata
    Vcb->VCBFlags |= UDF_VCB_ASSUME_ALL_USED;
    if(Vcb->CDR_Mode) {
        // flush internal cache
        if(WCacheGetWriteBlockCount__(&(Vcb->FastCache)) >= (Vcb->WriteBlockSize >> Vcb->BlockSizeBits) )
            WCacheFlushAll__(&(Vcb->FastCache), Vcb);
        // record VAT
        return UDFRecordVAT(Vcb);
    }
 
    UDFFlushAllCachedAllocations(Vcb, UDF_PREALLOC_CLASS_FE);
    UDFFlushAllCachedAllocations(Vcb, UDF_PREALLOC_CLASS_DIR);
 
    if(Vcb->VerifyOnWrite) {
        UDFPrint(("UDF: Flushing cache for verify\n"));
        //WCacheFlushAll__(&(Vcb->FastCache), Vcb);
        WCacheFlushBlocks__(&(Vcb->FastCache), Vcb, 0, Vcb->LastLBA);
        UDFVFlush(Vcb);
    }
 
    // synchronize BAD Block bitmap and NonAllocatable
    UDFUpdateNonAllocated(Vcb);
 
    UDFAcquireResourceExclusive(&(Vcb->BitMapResource1),TRUE);
 
    // RAM mode
#ifdef UDF_DBG
    if(!OS_SUCCESS(UDFUpdateVolIdent(Vcb, Vcb->PVolDescAddr, &(Vcb->VolIdent))))
        UDFPrint(("Error updating VolIdent (1)\n"));
    if(!OS_SUCCESS(UDFUpdateVolIdent(Vcb, Vcb->PVolDescAddr2, &(Vcb->VolIdent))))
        UDFPrint(("Error updating VolIdent (2)\n"));
#else
    UDFUpdateVolIdent(Vcb, Vcb->PVolDescAddr, &(Vcb->VolIdent));
    UDFUpdateVolIdent(Vcb, Vcb->PVolDescAddr2, &(Vcb->VolIdent));
#endif // UDF_DBG
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
    // check if we should update BM
    if(Vcb->FSBM_ByteCount == RtlCompareMemory(Vcb->FSBM_Bitmap, Vcb->FSBM_OldBitmap, Vcb->FSBM_ByteCount)) {
        flags &= ~1;
    } else {
        flags |= 1;
    }
 
#ifdef UDF_DBG
    if(!OS_SUCCESS(UDFUpdateVDS(Vcb, Vcb->VDS1, Vcb->VDS1 + Vcb->VDS1_Len, flags)))
        UDFPrint(("Error updating Main VDS\n"));
    if(!OS_SUCCESS(UDFUpdateVDS(Vcb, Vcb->VDS2, Vcb->VDS2 + Vcb->VDS2_Len, flags)))
        UDFPrint(("Error updating Reserve VDS\n"));
#else
    UDFUpdateVDS(Vcb, Vcb->VDS1, Vcb->VDS1 + Vcb->VDS1_Len, flags);
    UDFUpdateVDS(Vcb, Vcb->VDS2, Vcb->VDS2 + Vcb->VDS2_Len, flags);
#endif // UDF_DBG
 
    // Update Integrity Desc if any
    if(Vcb->LVid && Vcb->origIntegrityType == INTEGRITY_TYPE_CLOSE) {
        UDFUpdateLogicalVolInt(Vcb, TRUE);
    }
 
    if(flags & 1)
        RtlCopyMemory(Vcb->FSBM_OldBitmap, Vcb->FSBM_Bitmap, Vcb->FSBM_ByteCount);
 
//skip_update_bitmap:
 
    Vcb->VCBFlags &= ~UDF_VCB_ASSUME_ALL_USED;
 
    UDFReleaseResource(&(Vcb->BitMapResource1));
#endif //UDF_READ_ONLY_BUILD
 
    return STATUS_SUCCESS;
} // end UDFUmount__()

Referenced by UDFFlushLogicalVolume().

◆ UDFUnicodeCksum()

uint16 __fastcall UDFUnicodeCksum	(	PWCHAR	s,
		uint32	n
	)

Definition at line 4356 of file udf_info.cpp.

{
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
//    uint32 _Size = n;
 
    __asm {
        push  ebx
        push  ecx
        push  edx
        push  esi
 
        xor   eax,eax
        mov   esi,ecx
        mov   ecx,edx
 
        jecxz EO_uCRC
 
        lea   ebx,[CrcTable]
        xor   edx,edx
 
uCRC_loop:
 
        mov   dl,ah            // dl = (Crc >> 8)
        xor   dl,[esi+1]       // dl = ((Crc >> 8) ^ (*s >> 8)) & 0xff
        mov   ah,al
        mov   al,dh            // ax = (Crc << 8)
        xor   ax,[word ptr ebx+edx*2]  // ax = ...........
 
        mov   dl,ah
        xor   dl,[esi]
        mov   ah,al
        mov   al,dh
        xor   ax,[word ptr ebx+edx*2]
 
        inc   esi
        inc   esi
        loop  uCRC_loop
 
EO_uCRC:
 
        pop   esi
        pop   edx
        pop   ecx
        pop   ebx
 
        ret
    }
#else  // NO X86 optimization , use generic C/C++
    uint16 Crc = 0;
    while (n--) {
        Crc = CrcTable[(Crc >> 8 ^ (*s >> 8)) & 0xff] ^ (Crc << 8);
        Crc = CrcTable[(Crc >> 8 ^ (*s++ & 0xff)) & 0xff] ^ (Crc << 8);
    }
    return Crc;
 
#endif // _X86_
} // end UDFUnicodeCksum()

Referenced by UDFDOSName100(), UDFDOSName200(), and UDFDOSName201().

◆ UDFUnicodeCksum150()

uint16 __fastcall UDFUnicodeCksum150	(	PWCHAR	s,
		uint32	n
	)

Definition at line 4422 of file udf_info.cpp.

{
#if defined(_X86_) && defined(_MSC_VER) && !defined(__clang__)
//    uint32 _Size = n;
 
    __asm {
        push  ebx
        push  ecx
        push  edx
        push  esi
        push  edi
 
        xor   eax,eax
        mov   esi,ecx
        mov   ecx,edx
        xor   edi,edi
 
        jecxz EO_uCRC
 
        //lea   ebx,[CrcTable]
        xor   edx,edx
        xor   ebx,ebx
 
uCRC_loop:
 
        mov   dl,ah            // dl = (Crc >> 8)
        or    edi,edx          // if(*s & 0xff00) Use16 = TRUE;
        xor   dl,[esi+1]       // dl = ((Crc >> 8) ^ (*s >> 8)) & 0xff
        mov   ah,al
        mov   al,0             // ax = (Crc << 8)
        xor   ax,[word ptr CrcTable+edx*2]  // ax = ...........
 
        mov   dl,ah
        xor   dl,[esi]
        mov   ah,al
        mov   al,0
        xor   ax,[word ptr CrcTable+edx*2]
 
        or    edi,edi          // if(!Use16) {
        jnz   use16_1
 
        rol   eax,16
 
        mov   bl,ah            // dl = (Crc >> 8)
        xor   bl,[esi]         // dl = ((Crc >> 8) ^ (*s >> 8)) & 0xff
        mov   ah,al
        mov   al,0             // ax = (Crc << 8)
        xor   ax,[word ptr CrcTable+ebx*2]  // ax = ...........
 
        rol   eax,16
use16_1:
        inc   esi
        inc   esi
        loop  uCRC_loop
 
EO_uCRC:
 
        or    edi,edi          // if(!Use16) {
        jnz   use16_2
 
        rol   eax,16           // }
use16_2:
        and   eax,0xffff
 
        pop   edi
        pop   esi
        pop   edx
        pop   ecx
        pop   ebx
 
        ret
    }
#else  // NO X86 optimization , use generic C/C++
    uint16 Crc = 0;
    uint16 Crc2 = 0;
    BOOLEAN Use16 = FALSE;
    while (n--) {
        if(!Use16) {
            if((*s) & 0xff00) {
                Use16 = TRUE;
            } else {
                Crc2 = CrcTable[(Crc2 >> 8 ^ (*s >> 8)) & 0xff] ^ (Crc2 << 8);
            }
        }
        Crc = CrcTable[(Crc >> 8 ^ (*s >> 8)) & 0xff] ^ (Crc << 8);
        Crc = CrcTable[(Crc >> 8 ^ (*s++ & 0xff)) & 0xff] ^ (Crc << 8);
    }
    return Use16 ? Crc : Crc2;
#endif // _X86_
} // end UDFUnicodeCksum150()

Referenced by UDFDOSName200().

◆ UDFUnicodeInString()

BOOLEAN UDFUnicodeInString	(	IN uint8 *	string,
		IN WCHAR	ch
	)

Definition at line 336 of file udf_info.cpp.

{
    BOOLEAN found = FALSE;
 
    while(*string != '\0' && !found) {
        // These types should compare, since both are unsigned numbers.
        if(*string == ch) {
            found = TRUE;
        }
        string++;
    }
    return(found);
} // end UDFUnicodeInString()

Referenced by UDFIsIllegalChar().

◆ UDFUnlinkAllFilesInDir()

OSSTATUS UDFUnlinkAllFilesInDir	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	DirInfo
	)

Definition at line 1945 of file udf_info.cpp.

{
    PDIR_INDEX_HDR hCurDirNdx;
    PDIR_INDEX_ITEM CurDirNdx;
    PUDF_FILE_INFO FileInfo;
    OSSTATUS status;
    uint_di i;
 
    hCurDirNdx = DirInfo->Dloc->DirIndex;
    // check if we can delete all files
    for(i=2; (CurDirNdx = UDFDirIndex(hCurDirNdx,i)); i++) {
        // try to open Stream
        if(CurDirNdx->FileInfo)
            return STATUS_CANNOT_DELETE;
    }
    // start deletion
    for(i=2; (CurDirNdx = UDFDirIndex(hCurDirNdx,i)); i++) {
        // try to open Stream
        status = UDFOpenFile__(Vcb, FALSE, TRUE, NULL, DirInfo, &FileInfo, &i);
        if(status == STATUS_FILE_DELETED) {
            // we should not release on-disk allocation for
            // deleted streams twice
            if(CurDirNdx->FileInfo) {
                BrutePoint();
                goto err_del_stream;
            }
            goto skip_del_stream;
        } else
        if(!OS_SUCCESS(status)) {
            // Error :(((
err_del_stream:
            UDFCleanUpFile__(Vcb, FileInfo);
            if(FileInfo)
                MyFreePool__(FileInfo);
            return status;
        }
 
        UDFFlushFile__(Vcb, FileInfo);
        AdPrint(("    "));
        UDFUnlinkFile__(Vcb, FileInfo, TRUE);
        UDFCloseFile__(Vcb, FileInfo);
skip_del_stream:
        if(FileInfo && UDFCleanUpFile__(Vcb, FileInfo)) {
            MyFreePool__(FileInfo);
        }
    }
    return STATUS_SUCCESS;
} // end UDFUnlinkAllFilesInDir()

Referenced by UDFUnlinkFile__().

◆ UDFUnlinkDloc()

OSSTATUS UDFUnlinkDloc	(	IN PVCB	Vcb,
		IN PUDF_DATALOC_INFO	Dloc
	)

Definition at line 1327 of file dirtree.cpp.

{
    LONG i;
 
    UDFAcquireResourceExclusive(&(Vcb->DlocResource),TRUE);
 
    if((i = UDFFindDlocInMem(Vcb, Dloc)) == (-1)) {
        // FE specified is not in cache. exit
        UDFReleaseResource(&(Vcb->DlocResource));
        return STATUS_INVALID_PARAMETER;
    }
    // remove from cache
    ASSERT(Vcb->DlocList);
    RtlZeroMemory(&(Vcb->DlocList[i]), sizeof(UDF_DATALOC_INDEX));
    UDFReleaseResource(&(Vcb->DlocResource));
    return STATUS_SUCCESS;
} // end UDFUnlinkDloc()

Referenced by UDFRenameMoveFile__(), and UDFUnlinkFile__().

◆ UDFUnlinkFile__()

OSSTATUS UDFUnlinkFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN BOOLEAN	FreeSpace
	)

Definition at line 1766 of file udf_info.cpp.

{
    uint_di Index;   // index of file to be deleted
    uint16 lc;
    PUDF_DATALOC_INFO Dloc;
    PUDF_FILE_INFO DirInfo;
    PUDF_FILE_INFO SDirInfo;
    PDIR_INDEX_HDR hDirNdx;
    PDIR_INDEX_HDR hCurDirNdx;
    PDIR_INDEX_ITEM DirNdx;
    OSSTATUS status;
    BOOLEAN IsSDir;
 
    AdPrint(("UDFUnlinkFile__:\n"));
    if(!FileInfo) return STATUS_SUCCESS;
 
    ValidateFileInfo(FileInfo);
 
#ifndef _CONSOLE
    // now we can't call this if there is no OS-specific File Desc. present
    if(FileInfo->Fcb)
        UDFRemoveFileId__(Vcb, FileInfo);
#endif //_CONSOLE
    // check references
    Dloc = FileInfo->Dloc;
    if((FileInfo->OpenCount /*> (uint32)(UDFHasAStreamDir(FileInfo) ? 1 : 0)*/) ||
       (FileInfo->RefCount>1)) return STATUS_CANNOT_DELETE;
    if(Dloc->SDirInfo)
        return STATUS_CANNOT_DELETE;
    ASSERT(FileInfo->RefCount == 1);
    DirInfo = FileInfo->ParentFile;
    // root dir or self
    if(!DirInfo || ((FileInfo->Index < 2) && !UDFIsAStreamDir(FileInfo))) return STATUS_CANNOT_DELETE;
    hDirNdx = DirInfo->Dloc->DirIndex;
    Index = FileInfo->Index;
    // we can't delete modified file
    // it should be closed & reopened (or flushed) before deletion
    DirNdx = UDFDirIndex(hDirNdx,Index);
#if defined UDF_DBG || defined PRINT_ALWAYS
    if(DirNdx && DirNdx->FName.Buffer) {
        AdPrint(("Unlink: %ws\n",DirNdx->FName.Buffer));
    }
#endif // UDF_DBG
    if(FreeSpace &&
       ((Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED) ||
         Dloc->DataLoc.Modified ||
         Dloc->AllocLoc.Modified ||
         Dloc->FELoc.Modified ||
        (DirNdx && (DirNdx->FI_Flags & UDF_FI_FLAG_FI_MODIFIED)) )) {
//        BrutePoint();
        return STATUS_CANNOT_DELETE;
    }
    SDirInfo = Dloc->SDirInfo;
/*    if(FreeSpace && SDirInfo) {
        UDFPrint(("Unlink: SDirInfo should be NULL !!!\n"));
        BrutePoint();
        return STATUS_CANNOT_DELETE;
    }*/
    // stream directory can be deleted even being not empty
    // otherwise we should perform some checks
    if(!(IsSDir = UDFIsAStreamDir(FileInfo))) {
        // check if not empty direcory
        if((DirNdx->FileCharacteristics & FILE_DIRECTORY) &&
           (hCurDirNdx = Dloc->DirIndex) &&
            FreeSpace) {
            if(!UDFIsDirEmpty(hCurDirNdx))
                return STATUS_DIRECTORY_NOT_EMPTY;
        }
        DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
        DirNdx->FileCharacteristics |= FILE_DELETED;
        FileInfo->FileIdent->fileCharacteristics |= FILE_DELETED;
        hDirNdx->DelCount++;
        UDFChangeFileCounter(Vcb, !UDFIsADirectory(FileInfo), FALSE);
    }
    UDFDecFileLinkCount(FileInfo); // decrease
    lc = UDFGetFileLinkCount(FileInfo);
    if(DirNdx && FreeSpace) {
        // FileIdent marked as 'deleted' should have an empty ICB
        // We shall do it only if object has parent Dir
        // (for ex. SDir has parent object, but has no parent Dir)
        DirNdx->FI_Flags |= UDF_FI_FLAG_FI_MODIFIED;
        DirNdx->FI_Flags &= ~UDF_FI_FLAG_SYS_ATTR;
        // Root Files (Root/SDir/Vat/etc.) has no FileIdent...
        if(FileInfo->FileIdent)
            RtlZeroMemory(&(FileInfo->FileIdent->icb), sizeof(long_ad));
    }
    // caller wishes to free allocation, but we can't do it due to
    // alive links. In this case we should just remove reference
    if(FreeSpace && lc) {
        ((icbtag*)(Dloc->FileEntry+1))->parentICBLocation.logicalBlockNum = 0;
        ((icbtag*)(Dloc->FileEntry+1))->parentICBLocation.partitionReferenceNum = 0;
        Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
    } else
    // if caller wishes to free file allocation &
    // there are no more references(links) to this file, lets do it >;->
    if(FreeSpace && !lc) {
        if(UDFHasAStreamDir(FileInfo) &&
           !UDFIsSDirDeleted(Dloc->SDirInfo) ) {
            // we have a Stream Dir associated...
            PUDF_FILE_INFO SFileInfo;
            // ... try to open it
            if(Dloc->SDirInfo) {
                UDFFlushFile__(Vcb, FileInfo);
                return STATUS_CANNOT_DELETE;
            }
            // open SDir
            status = UDFOpenStreamDir__(Vcb, FileInfo, &(Dloc->SDirInfo));
            if(!OS_SUCCESS(status)) {
                // abort Unlink on error
                SFileInfo = Dloc->SDirInfo;
cleanup_SDir:
                UDFCleanUpFile__(Vcb, SFileInfo);
                if(SFileInfo) MyFreePool__(SFileInfo);
                UDFFlushFile__(Vcb, FileInfo);
                return status;
            }
            SDirInfo = Dloc->SDirInfo;
            // try to perform deltree for Streams
            status = UDFUnlinkAllFilesInDir(Vcb, SDirInfo);
            if(!OS_SUCCESS(status)) {
                // abort Unlink on error
                UDFCloseFile__(Vcb, SDirInfo);
                SFileInfo = SDirInfo;
                BrutePoint();
                goto cleanup_SDir;
            }
            // delete SDir
            UDFFlushFile__(Vcb, SDirInfo);
            AdPrint(("  "));
            UDFUnlinkFile__(Vcb, SDirInfo, TRUE);
            // close SDir
            UDFCloseFile__(Vcb, SDirInfo);
            if(UDFCleanUpFile__(Vcb, SDirInfo)) {
                MyFreePool__(SDirInfo);
#ifdef UDF_DBG
            } else {
                BrutePoint();
#endif // UDF_DBG
            }
            // update FileInfo
            ASSERT(Dloc->FileEntry);
            RtlZeroMemory( &(((PEXTENDED_FILE_ENTRY)(Dloc->FileEntry))->streamDirectoryICB), sizeof(long_ad));
            FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_FE_MODIFIED;
        } else
        if(IsSDir) {
            // do deltree for Streams
            status = UDFUnlinkAllFilesInDir(Vcb, FileInfo);
            if(!OS_SUCCESS(status)) {
                UDFFlushFile__(Vcb, FileInfo);
                return status;
            }
            // update parent FileInfo
            ASSERT(FileInfo->ParentFile->Dloc->FileEntry);
            RtlZeroMemory( &(((PEXTENDED_FILE_ENTRY)(FileInfo->ParentFile->Dloc->FileEntry))->streamDirectoryICB), sizeof(long_ad));
            FileInfo->ParentFile->Dloc->FE_Flags &= ~UDF_FE_FLAG_HAS_SDIR;
            FileInfo->ParentFile->Dloc->FE_Flags |= (UDF_FE_FLAG_FE_MODIFIED |
                                                     UDF_FE_FLAG_HAS_DEL_SDIR);
            FileInfo->Dloc->FE_Flags |= UDF_FE_FLAG_IS_DEL_SDIR;
            UDFDecFileLinkCount(FileInfo->ParentFile);
        }
        if(Dloc->DirIndex) {
            UDFFlushFESpace(Vcb, Dloc, FLUSH_FE_FOR_DEL);
        }
        // flush file
        UDFFlushFile__(Vcb, FileInfo);
        UDFUnlinkDloc(Vcb, Dloc);
        // free allocation
        UDFFreeFileAllocation(Vcb, DirInfo, FileInfo);
        ASSERT(!(FileInfo->Dloc->FE_Flags & UDF_FE_FLAG_FE_MODIFIED));
        FileInfo->Dloc->FE_Flags &= ~UDF_FE_FLAG_FE_MODIFIED;
    }
    return STATUS_SUCCESS;
} // end UDFUnlinkFile__()

Referenced by UDFCleanUpFcbChain(), UDFCommonCleanup(), UDFCommonCreate(), UDFCreateStreamDir__(), UDFHardLinkFile__(), UDFRenameMoveFile__(), UDFUnlinkAllFilesInDir(), UDFUnlinkFile__(), and UDFWriteSecurity().

◆ UDFUnmapRange()

OSSTATUS __fastcall UDFUnmapRange	(	IN PVCB	Vcb,
		IN uint32	Lba,
		IN uint32	BCount
	)

Definition at line 894 of file remap.cpp.

{
    uint32 i, max, BS, orig;
    PSPARING_MAP Map;
 
    if(Vcb->SparingTable) {
        // use sparing table for relocation
 
        max = Vcb->SparingCount;
        BS = Vcb->SparingBlockSize;
        Map = Vcb->SparingTable;
        for(i=0;i<max;i++,Map++) {
            orig = Map->origLocation;
            switch(orig) {
            case SPARING_LOC_AVAILABLE:
            case SPARING_LOC_CORRUPTED:
                continue;
            }
            if(orig >= Lba &&
              (orig+BS) <= (Lba+BCount)) {
                // unmap
                UDFPrint(("unmap %x -> %x\n", orig, Map->mappedLocation));
                Map->origLocation = SPARING_LOC_AVAILABLE;
                Vcb->SparingTableModified = TRUE;
                Vcb->SparingCountFree++;
            }
        }
    }
    return STATUS_SUCCESS;
} // end UDFUnmapRange()

Referenced by UDFMarkSpaceAsXXXNoProtect_().

◆ UDFUnPackMapping()

OSSTATUS __fastcall UDFUnPackMapping	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo
	)

Definition at line 2860 of file extent.cpp.

{
    PEXTENT_MAP NewMapping;
    PEXTENT_MAP Mapping = ExtInfo->Mapping;
    uint32 LBS = Vcb->LBlockSize;
    uint32 len = (uint32)(UDFGetExtentLength(Mapping) >> Vcb->LBlockSizeBits);
    uint32 i,j, type, base, d;
    LONG l;
 
    NewMapping = (PEXTENT_MAP)MyAllocatePoolTag__(NonPagedPool , (len+1)*sizeof(EXTENT_MAP),
                                                       MEM_EXTMAP_TAG);
    if(!NewMapping) return STATUS_INSUFFICIENT_RESOURCES;
 
    j=0;
    d = LBS >> Vcb->BlockSizeBits;
    for(i=0; (l = (Mapping[i].extLength & UDF_EXTENT_LENGTH_MASK)); i++) {
        base = Mapping[i].extLocation;
        type = Mapping[i].extLength & UDF_EXTENT_FLAG_MASK;
        for(; l>=(LONG)LBS; j++) {
            NewMapping[j].extLength = LBS | type;
            NewMapping[j].extLocation = base;
            base+=d;
            l-=LBS;
        }
    }
    // record terminator
    ASSERT(NewMapping);
    RtlZeroMemory(&(NewMapping[j]), sizeof(EXTENT_MAP));
    MyFreePool__(Mapping);
    ExtInfo->Mapping = NewMapping;
 
    return STATUS_SUCCESS;
} // end UDFUnPackMapping()

Referenced by UDFAllocateFESpace(), and UDFRecordVAT().

◆ UDFUpdateLogicalVolInt()

OSSTATUS UDFUpdateLogicalVolInt	(	PVCB	Vcb,
		BOOLEAN	Close
	)

Definition at line 361 of file mount.cpp.

{
    OSSTATUS    RC = STATUS_SUCCESS;
    uint32      i, len;
    SIZE_T      WrittenBytes;
//    uint32      lvid_count = 0;
    uint32      pSize;
    tag*        PTag;
    LogicalVolIntegrityDesc *lvid;
    LogicalVolIntegrityDescImpUse* LVID_iUse;
    LogicalVolHeaderDesc* LVID_hd;
    uint32*     partFreeSpace;
    BOOLEAN     equal = FALSE;
 
    if(Vcb->CDR_Mode)
        return STATUS_SUCCESS;
    if(!Vcb->LVid) {
        return STATUS_UNSUCCESSFUL;
    }
 
    UDFPrint(("UDF: Updating LVID @%x (%x)\n", Vcb->LVid_loc.extLocation, Vcb->LVid_loc.extLength));
    len = max(Vcb->LVid_loc.extLength, Vcb->BlockSize);
    lvid = Vcb->LVid;
    if(lvid->descTag.tagSerialNum > UDF_LVID_TTL) {
        // TODO: allocate space for new LVID
    }
 
    LVID_iUse = UDFGetLVIDiUse(Vcb);
 
    if((LVID_iUse->minUDFReadRev  == Vcb->minUDFReadRev) &&
       (LVID_iUse->minUDFWriteRev == Vcb->minUDFWriteRev) &&
       (LVID_iUse->maxUDFWriteRev == Vcb->maxUDFWriteRev) &&
       (LVID_iUse->numFiles == Vcb->numFiles) &&
       (LVID_iUse->numDirs  == Vcb->numDirs))
        equal = TRUE;
 
    LVID_iUse->minUDFReadRev  = Vcb->minUDFReadRev;
    LVID_iUse->minUDFWriteRev = Vcb->minUDFWriteRev;
    LVID_iUse->maxUDFWriteRev = Vcb->maxUDFWriteRev;
 
    LVID_iUse->numFiles = Vcb->numFiles;
    LVID_iUse->numDirs  = Vcb->numDirs;
 
#if 0
    UDFSetEntityID_imp(&(LVID_iUse->impIdent), UDF_ID_DEVELOPER);
#endif
 
    if(Close){
        UDFPrint(("UDF: Opening LVID\n"));
        lvid->integrityType = INTEGRITY_TYPE_CLOSE;
    } else {
        UDFPrint(("UDF: Closing LVID\n"));
        lvid->integrityType = INTEGRITY_TYPE_OPEN;
    }
 
    equal = equal && (Vcb->IntegrityType == lvid->integrityType);
 
    // update Free Space Table
    partFreeSpace = (uint32*)(lvid+1);
    for(i=0; i<lvid->numOfPartitions; i++) {
        pSize = UDFGetPartFreeSpace(Vcb, i) >> Vcb->LB2B_Bits;
        equal = equal && (partFreeSpace[i] == pSize);
        partFreeSpace[i] = pSize;
    }
 
    // Update LVID Header Descriptor
    LVID_hd = (LogicalVolHeaderDesc*)&(lvid->logicalVolContentsUse);
    equal = equal && (LVID_hd->uniqueID == Vcb->NextUniqueId);
    LVID_hd->uniqueID = Vcb->NextUniqueId;
 
    if(equal) {
        UDFPrint(("UDF: equal Ids\n"));
        return STATUS_SUCCESS;
    }
 
    PTag = &(lvid->descTag);
    lvid->lengthOfImpUse =
        sizeof(LogicalVolIntegrityDescImpUse);
    UDFSetUpTag(Vcb, PTag,
        sizeof(LogicalVolIntegrityDesc) +
        sizeof(uint32)*2*lvid->numOfPartitions +
        sizeof(LogicalVolIntegrityDescImpUse),
        PTag->tagLocation);
 
    Vcb->IntegrityType = INTEGRITY_TYPE_OPEN; // make happy auto-dirty
    RC = UDFWriteSectors(Vcb, TRUE, PTag->tagLocation, len >> Vcb->BlockSizeBits, FALSE, (int8*)(lvid), &WrittenBytes);
    WCacheFlushBlocks__(&(Vcb->FastCache), Vcb, PTag->tagLocation, len >> Vcb->BlockSizeBits);
    // update it here to prevent recursion
    Vcb->IntegrityType = lvid->integrityType;
 
    return RC;
} // end UDFUpdateLogicalVolInt()

Referenced by UDFEjectReqWaiter(), UDFUmount__(), UDFWriteInSector(), and UDFWriteSectors().

◆ UDFUpdatePartDesc()

OSSTATUS UDFUpdatePartDesc	(	PVCB	Vcb,
		int8 *	Buf
	)

Definition at line 299 of file mount.cpp.

{
    PartitionDesc *p = (PartitionDesc *)Buf;
    uint32 i; // PartNdx
    tag* PTag;
    SIZE_T WrittenBytes;
 
    for(i=0; i<Vcb->PartitionMaps; i++)
    {
        if((UDFGetPartNumByPartNdx(Vcb,i) == p->partitionNumber) &&
           (!strcmp((int8*)&(p->partitionContents.ident), PARTITION_CONTENTS_NSR02) ||
            !strcmp((int8*)&(p->partitionContents.ident), PARTITION_CONTENTS_NSR03)))
        {
            PPARTITION_HEADER_DESC phd;
 
            phd = (PPARTITION_HEADER_DESC)(p->partitionContentsUse);
#ifdef UDF_DBG
            if(phd->unallocatedSpaceTable.extLength) {
                // rebuild unallocatedSpaceTable
                UDFPrint(("unallocatedSpaceTable (part %d)\n", i));
            }
            if(phd->freedSpaceTable.extLength) {
                // rebuild freedSpaceTable
                UDFPrint(("freedSpaceTable (part %d)\n", i));
            }
#endif // UDF_DBG
            UDFUpdateXSpaceBitmaps(Vcb, p->partitionNumber, phd);
            PTag = (tag*)Buf;
            UDFSetUpTag(Vcb, PTag, PTag->descCRCLength, PTag->tagLocation);
            UDFWriteSectors(Vcb, TRUE, PTag->tagLocation, 1, FALSE, Buf, &WrittenBytes);
        }
    }
    return STATUS_SUCCESS;
} // end UDFUpdatePartDesc()

Referenced by UDFUpdateVDS().

◆ UDFUpdateUSpaceDesc()

OSSTATUS UDFUpdateUSpaceDesc	(	IN PVCB	Vcb,
		int8 *	Buf
	)

◆ UDFUpdateVAT()

OSSTATUS UDFUpdateVAT	(	IN void *	_Vcb,
		IN uint32	Lba,
		IN uint32 *	RelocTab,
		IN uint32	BCount
	)

Definition at line 5316 of file udf_info.cpp.

{
#ifndef UDF_READ_ONLY_BUILD
    PVCB Vcb = (PVCB)_Vcb;
    uint16 PartNdx = (uint16)(Vcb->VatPartNdx);
    uint16 PartNum = (uint16)(Lba ? UDFGetPartNumByPhysLba(Vcb, Lba) : UDFGetPartNumByPartNdx(Vcb, PartNdx));
    if(PartNum != UDFGetPartNumByPartNdx(Vcb, PartNdx)) {
        UDFPrint(("UDFUpdateVAT: Write to Write-Protected partition\n"));
        return STATUS_MEDIA_WRITE_PROTECTED;
    }
    // !!! NOTE !!!
    // Both VAT copies - in-memory & on-disc
    // contain _relative_ addresses
    uint32 root = Vcb->Partitions[PartNdx].PartitionRoot;
    uint32 NWA = Vcb->NWA-root;
    uint32 i;
    uint32 CurLba;
 
    if(!Vcb->Vat) return STATUS_SUCCESS;
 
    for(i=0; i<BCount; i++, NWA++) {
        if((CurLba = (RelocTab ? RelocTab[i] : (Lba+i)) - root) >= Vcb->VatCount)
            Vcb->VatCount = CurLba+1;
        Vcb->Vat[CurLba] = NWA;
    }
    return STATUS_SUCCESS;
#else //UDF_READ_ONLY_BUILD
    return STATUS_MEDIA_WRITE_PROTECTED;
#endif //UDF_READ_ONLY_BUILD
} // end UDFUpdateVAT()

Referenced by UDFMountVolume(), and UDFVerifyVolume().

◆ UDFUpdateVDS()

OSSTATUS UDFUpdateVDS	(	IN PVCB	Vcb,
		IN uint32	block,
		IN uint32	lastblock,
		IN uint32	flags
	)

Definition at line 673 of file mount.cpp.

{
    OSSTATUS status;
    int8*    Buf = (int8*)DbgAllocatePool(NonPagedPool,Vcb->LBlockSize);
    UDF_VDS_RECORD vds[VDS_POS_LENGTH];
    uint32 i,j;
    uint16 ident;
 
    if (!Buf) return STATUS_INSUFFICIENT_RESOURCES;
    RtlZeroMemory(vds, sizeof(UDF_VDS_RECORD) * VDS_POS_LENGTH);
    if(!OS_SUCCESS(status = UDFReadVDS(Vcb, block, lastblock, (PUDF_VDS_RECORD)&vds, Buf))) {
        DbgFreePool(Buf);
        return status;
    }
 
/*
    // update USD (if any)
    for (i=0; i<VDS_POS_LENGTH; i++) {
        if (vds[i].block) {
            status = UDFReadTagged(Vcb, Buf, vds[i].block, vds[i].block, &ident);
            if(OS_SUCCESS(status) && (i == VDS_POS_PARTITION_DESC)) {
                // load partition descriptor(s)
                int8*  Buf2 = (int8*)DbgAllocatePool(NonPagedPool,Vcb->BlockSize);
                if (!Buf2) {
                    DbgFreePool(Buf);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++) {
                    UDFReadTagged(Vcb,Buf2, j, j, &ident);
                    if (ident == TID_UNALLOC_SPACE_DESC)
                        // This implememtation doesn't support USD ;) recording
                        // So, we'll make'em blank, but record all bitmaps
                        UDFUpdateUSpaceDesc(Vcb,Buf2);
                }
                DbgFreePool(Buf2);
                break;
            }
        }
    }*/
    for (i=0; i<VDS_POS_LENGTH; i++) {
        if (vds[i].block) {
            status = UDFReadTagged(Vcb, Buf, vds[i].block, vds[i].block, &ident);
            if(!OS_SUCCESS(status))
                continue;
            // update XBMs
            if(i == VDS_POS_PARTITION_DESC) {
                if(!(flags & 1))
                    continue;
                // update partition descriptor(s)
                int8*  Buf2 = (int8*)DbgAllocatePool(NonPagedPool,Vcb->BlockSize);
                if (!Buf2) {
                    DbgFreePool(Buf);
                    return STATUS_INSUFFICIENT_RESOURCES;
                }
                UDFUpdatePartDesc(Vcb,Buf);
                for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++) {
                    UDFReadTagged(Vcb,Buf2, j, j, &ident);
                    if (ident == TID_PARTITION_DESC)
                        UDFUpdatePartDesc(Vcb,Buf2);
                }
                DbgFreePool(Buf2);
//                continue;
            } else
            // update Vol Ident Desc
            if(i == VDS_POS_LOGICAL_VOL_DESC) {
                status = UDFUpdateLogicalVol(Vcb, vds[VDS_POS_LOGICAL_VOL_DESC], &(Vcb->VolIdent));
                if(!OS_SUCCESS(status))
                    continue;
            }
        }
    }
 
    DbgFreePool(Buf);
    return status;
} // end UDFUpdateVDS()

Referenced by UDFEjectReqWaiter(), and UDFUmount__().

◆ UDFUpdateVolIdent()

OSSTATUS UDFUpdateVolIdent	(	IN PVCB	Vcb,
		IN UDF_VDS_RECORD	Lba,
		IN PUNICODE_STRING	VolIdent
	)

Definition at line 801 of file mount.cpp.

{
#define CUR_IDENT_SZ (sizeof(pvoldesc->volIdent))
    PrimaryVolDesc* pvoldesc = (PrimaryVolDesc*)MyAllocatePool__(NonPagedPool, max(Vcb->BlockSize, sizeof(PrimaryVolDesc)) );
    OSSTATUS status;
    dstring CS0[CUR_IDENT_SZ];
    uint16 ident;
    SIZE_T WrittenBytes;
 
    if(!pvoldesc) return STATUS_INSUFFICIENT_RESOURCES;
 
    UDFPrint(("UDF: Updating PVD @%x (%x)\n", Lba.block, Vcb->BlockSize));
 
    status = UDFSetDstring(&(Vcb->VolIdent), (dstring*)&CS0, CUR_IDENT_SZ);
    if(!OS_SUCCESS(status)) {
        if(status == STATUS_INVALID_PARAMETER) {
            status = STATUS_INVALID_VOLUME_LABEL;
        }
        goto Err_SetVI;
    }
 
    if(!Lba.block) {
        status = STATUS_INVALID_PARAMETER;
        goto Err_SetVI;
    }
    status = UDFReadTagged(Vcb, (int8*)pvoldesc, Lba.block, Lba.block, &ident);
    if(!OS_SUCCESS(status)) goto Err_SetVI;
    if(ident != TID_PRIMARY_VOL_DESC) {
        status = STATUS_FILE_CORRUPT_ERROR;
        goto Err_SetVI;
    }
 
    if(RtlCompareMemory(pvoldesc->volIdent, CS0, CUR_IDENT_SZ) == CUR_IDENT_SZ) {
        // no changes
        status = STATUS_SUCCESS;
        goto Err_SetVI;
    }
    RtlCopyMemory(pvoldesc->volIdent, CS0, CUR_IDENT_SZ);
 
    pvoldesc->descTag.tagSerialNum --;
    UDFSetUpTag(Vcb, (tag*)pvoldesc, pvoldesc->descTag.descCRCLength, Lba.block);
 
    status = UDFWriteSectors(Vcb, TRUE, Lba.block, 1, FALSE, (int8*)pvoldesc, &WrittenBytes);
Err_SetVI:
    MyFreePool__(pvoldesc);
    return status;
 
#undef CUR_IDENT_SZ
} // end UDFUpdateVolIdent()

Referenced by UDFEjectReqWaiter(), and UDFUmount__().

◆ UDFUpdateXSpaceBitmaps()

OSSTATUS UDFUpdateXSpaceBitmaps	(	IN PVCB	Vcb,
		IN uint32	PartNum,
		IN PPARTITION_HEADER_DESC	phd
	)

Definition at line 186 of file mount.cpp.

{
    uint32 i,j,d;
    uint32 plen, pstart, pend;
    int8* bad_bm;
    int8* old_bm;
    int8* new_bm;
    int8* fpart_bm;
    int8* upart_bm;
    OSSTATUS status, status2;
    int8* USBM=NULL;
    int8* FSBM=NULL;
    uint32 USl, FSl;
    EXTENT_INFO FSBMExtInfo, USBMExtInfo;
//    lb_addr locAddr;
    SIZE_T WrittenBytes;
 
    UDF_CHECK_BITMAP_RESOURCE(Vcb);
 
    plen = UDFPartLen(Vcb, PartNum);
//    locAddr.partitionReferenceNum = (uint16)PartNum;
    // prepare bitmaps for updating
 
    status =  UDFPrepareXSpaceBitmap(Vcb, &(phd->unallocatedSpaceBitmap), &USBMExtInfo, &USBM, &USl);
    status2 = UDFPrepareXSpaceBitmap(Vcb, &(phd->freedSpaceBitmap), &FSBMExtInfo, &FSBM, &FSl);
    if(!OS_SUCCESS(status) ||
       !OS_SUCCESS(status2)) {
        BrutePoint();
    }
 
    pstart = UDFPartStart(Vcb, PartNum);
    new_bm = Vcb->FSBM_Bitmap;
    old_bm = Vcb->FSBM_OldBitmap;
    bad_bm = Vcb->BSBM_Bitmap;
 
    if((status  == STATUS_INSUFFICIENT_RESOURCES) ||
       (status2 == STATUS_INSUFFICIENT_RESOURCES)) {
        // try to recover insufficient resources
        if(USl && USBMExtInfo.Mapping) {
            USl -= sizeof(SPACE_BITMAP_DESC);
            status  = UDFWriteExtent(Vcb, &USBMExtInfo, sizeof(SPACE_BITMAP_DESC), USl, FALSE, new_bm, &WrittenBytes);
#ifdef UDF_DBG
        } else {
            UDFPrint(("Can't update USBM\n"));
#endif // UDF_DBG
        }
        if(USBMExtInfo.Mapping) MyFreePool__(USBMExtInfo.Mapping);
 
        if(FSl && FSBMExtInfo.Mapping) {
            FSl -= sizeof(SPACE_BITMAP_DESC);
            status2 = UDFWriteExtent(Vcb, &FSBMExtInfo, sizeof(SPACE_BITMAP_DESC), FSl, FALSE, new_bm, &WrittenBytes);
        } else {
            status2 = status;
            UDFPrint(("Can't update FSBM\n"));
        }
        if(FSBMExtInfo.Mapping) MyFreePool__(FSBMExtInfo.Mapping);
    } else {
        // normal way to record BitMaps
        if(USBM) upart_bm =  USBM + sizeof(SPACE_BITMAP_DESC);
        if(FSBM) fpart_bm =  FSBM + sizeof(SPACE_BITMAP_DESC);
        pend = min(pstart + plen, Vcb->FSBM_BitCount);
 
        d=1<<Vcb->LB2B_Bits;
        // if we have some bad bits, mark corresponding area as BAD
        if(bad_bm) {
            for(i=pstart; i<pend; i++) {
                if(UDFGetBadBit(bad_bm, i)) {
                    // TODO: would be nice to add these blocks to unallocatable space
                    UDFSetUsedBits(new_bm, i & ~(d-1), d);
                }
            }
        }
        j=0;
        for(i=pstart; i<pend; i+=d) {
            if(UDFGetUsedBit(old_bm, i) && UDFGetFreeBit(new_bm, i)) {
                // sector was deallocated during last session
                if(USBM) UDFSetFreeBit(upart_bm, j);
                if(FSBM) UDFSetFreeBit(fpart_bm, j);
            } else if(UDFGetUsedBit(new_bm, i)) {
                // allocated
                if(USBM) UDFSetUsedBit(upart_bm, j);
                if(FSBM) UDFSetUsedBit(fpart_bm, j);
            }
            j++;
        }
        // flush updates
        if(USBM) {
            status  = UDFWriteExtent(Vcb, &USBMExtInfo, 0, USl, FALSE, USBM, &WrittenBytes);
            DbgFreePool(USBM);
            MyFreePool__(USBMExtInfo.Mapping);
        }
        if(FSBM) {
            status2 = UDFWriteExtent(Vcb, &FSBMExtInfo, 0, FSl, FALSE, FSBM, &WrittenBytes);
            DbgFreePool(FSBM);
            MyFreePool__(FSBMExtInfo.Mapping);
        } else {
            status2 = status;
        }
    }
 
    if(!OS_SUCCESS(status))
        return status;
    return status2;
} // end UDFUpdateXSpaceBitmaps()

Referenced by UDFUpdatePartDesc().

◆ UDFVerifySequence()

OSSTATUS UDFVerifySequence	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PVCB	Vcb,
		IN uint32	block,
		IN uint32	lastblock,
		OUT lb_addr *	fileset
	)

Definition at line 2461 of file mount.cpp.

{
    OSSTATUS    RC = STATUS_SUCCESS;
    int8*       Buf = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
    UDF_VDS_RECORD vds[VDS_POS_LENGTH];
//    GenericDesc   *gd;
    uint32   i,j;
    uint16  ident;
    int8*  Buf2 = NULL;
 
    _SEH2_TRY {
        if(!Buf) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
        if(!block) try_return (RC = STATUS_SUCCESS);
        RtlZeroMemory(vds, sizeof(UDF_VDS_RECORD) * VDS_POS_LENGTH);
        if(!OS_SUCCESS(RC = UDFReadVDS(Vcb, block, lastblock, (PUDF_VDS_RECORD)&vds, Buf)))
            try_return(RC);
 
        for (i=0; i<VDS_POS_LENGTH; i++)
        {
            if(vds[i].block)
            {
                if(!OS_SUCCESS(RC = UDFReadTagged(Vcb, Buf, vds[i].block, vds[i].block, &ident)))
                    try_return(RC);
                UDFRegisterFsStructure(Vcb, vds[i].block, Vcb->BlockSize);
 
    /*            if(i == VDS_POS_PRIMARY_VOL_DESC)
                    UDFLoadPVolDesc(Vcb,Buf);
                else if(i == VDS_POS_LOGICAL_VOL_DESC) {
                    RC = UDFLoadLogicalVol(DeviceObject,Vcb, Buf, fileset);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                }
                else*/ if(i == VDS_POS_PARTITION_DESC)
                {
                    Buf2 = (int8*)MyAllocatePool__(NonPagedPool,Vcb->BlockSize);
                    if(!Buf2) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
                    RC = UDFVerifyPartDesc(Vcb,Buf);
                    if(!OS_SUCCESS(RC)) try_return(RC);
                    for (j=vds[i].block+1; j<vds[VDS_POS_TERMINATING_DESC].block; j++)
                    {
                        RC = UDFReadTagged(Vcb,Buf2, j, j, &ident);
                        if(!OS_SUCCESS(RC)) try_return(RC);
                        UDFRegisterFsStructure(Vcb, j, Vcb->BlockSize);
//                        gd = (struct GenericDesc *)Buf2;
                        if(ident == TID_PARTITION_DESC) {
                            RC = UDFVerifyPartDesc(Vcb,Buf2);
                            if(!OS_SUCCESS(RC)) try_return(RC);
                        } else if(ident == TID_UNALLOC_SPACE_DESC) {
                            RC = UDFVerifyFreeSpaceBitmap(Vcb,0,NULL,j);
                            Vcb->Modified = FALSE;
                            if(!OS_SUCCESS(RC))
                                try_return(RC);
                        }
                    }
                    MyFreePool__(Buf2);
                    Buf2 = NULL;
                }
            }
        }
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
        if(Buf) MyFreePool__(Buf);
        if(Buf2) MyFreePool__(Buf2);
    } _SEH2_END;
 
    return RC;
} // end UDFVerifySequence()

Referenced by UDFLoadPartition().

◆ UDFVFlush()

VOID UDFVFlush ( IN PVCB Vcb )

Definition at line 742 of file remap.cpp.

{
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
 
    if(!VerifyCtx->VInited) {
        return;
    }
 
    UDFPrint(("UDFVFlush: wait for completion\n"));
    UDFVWaitQueued(VerifyCtx);
 
    UDFVVerify(Vcb, UFD_VERIFY_FLAG_FORCE);
 
    UDFPrint(("UDFVFlush: wait for completion (2)\n"));
    UDFVWaitQueued(VerifyCtx);
} // end UDFVFlush()

Referenced by UDFCommonDeviceControl(), UDFEjectReqWaiter(), UDFFlushLogicalVolume(), and UDFUmount__().

◆ UDFVForget()

OSSTATUS UDFVForget	(	IN PVCB	Vcb,
		IN uint32	BCount,
		IN uint32	LBA,
		IN uint32	Flags
	)

Definition at line 486 of file remap.cpp.

{
    PLIST_ENTRY Link;
    PUDF_VERIFY_ITEM vItem;
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    ULONG i;
    ULONG n;
    OSSTATUS status = STATUS_SUCCESS;
 
    if(!VerifyCtx->VInited) {
        return STATUS_UNSUCCESSFUL;
    }
 
    UDFAcquireResourceExclusive(&(VerifyCtx->VerifyLock), TRUE);
 
    for(i=0, n=0; i<BCount; i++) {
        if(UDFGetBit(VerifyCtx->StoredBitMap, LBA+i)) {
            // some blocks are remembered
            n++;
        }
    }
 
    if(!n) {
        // no blocks are remembered
        UDFReleaseResource(&(VerifyCtx->VerifyLock));
        return STATUS_SUCCESS;
    }
 
    Link = VerifyCtx->vrfList.Flink;
    i = 0;
    while(Link != &(VerifyCtx->vrfList)) {
        vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
        Link = Link->Flink;
        if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
            i++;
            UDFVRemoveBlock(VerifyCtx, vItem);
            if(i >= n) {
                // no more blocks expected
                break;
            }
        }
    }
 
    UDFReleaseResource(&(VerifyCtx->VerifyLock));
    return status;
 
} // end UDFVForget()

◆ UDFVInit()

OSSTATUS UDFVInit ( IN PVCB Vcb )

Definition at line 54 of file remap.cpp.

{
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    uint32 i;
    OSSTATUS status = STATUS_SUCCESS;
    BOOLEAN res_inited = FALSE;
 
    if(VerifyCtx->VInited) {
        UDFPrint(("Already inited\n"));
        return STATUS_SUCCESS;
    }
 
    _SEH2_TRY {
        RtlZeroMemory(VerifyCtx, sizeof(UDF_VERIFY_CTX));
        if(!Vcb->VerifyOnWrite) {
            UDFPrint(("Verify is disabled\n"));
            return STATUS_SUCCESS;
        }
        if(Vcb->CDR_Mode) {
            UDFPrint(("Verify is not intended for CD/DVD-R\n"));
            return STATUS_SUCCESS;
        }
        if(!OS_SUCCESS(status = ExInitializeResourceLite(&(VerifyCtx->VerifyLock)))) {
            try_return(status);
        }
        res_inited = TRUE;
        VerifyCtx->ItemCount = 0;
        VerifyCtx->StoredBitMap = (uint8*)DbgAllocatePoolWithTag(PagedPool, (i = (Vcb->LastPossibleLBA+1+7)>>3), 'mNWD' );
        if(VerifyCtx->StoredBitMap) {
            RtlZeroMemory(VerifyCtx->StoredBitMap, i);
        } else {
            UDFPrint(("Can't alloc verify bitmap for %x blocks\n", Vcb->LastPossibleLBA));
            try_return(status = STATUS_INSUFFICIENT_RESOURCES);
        }
        InitializeListHead(&(VerifyCtx->vrfList));
        KeInitializeEvent(&(VerifyCtx->vrfEvent), SynchronizationEvent, FALSE);
        VerifyCtx->WaiterCount = 0;
        VerifyCtx->VInited = TRUE;
 
try_exit: NOTHING;
 
    } _SEH2_FINALLY {
 
        if(!OS_SUCCESS(status)) {
            if(res_inited) {
                ExDeleteResourceLite(&(VerifyCtx->VerifyLock));
            }
        }
    } _SEH2_END;
    return status;
} // end UDFVInit()

Referenced by UDFCommonDeviceControl(), UDFMountVolume(), and UDFVerifyVolume().

◆ UDFVIsStored()

__inline BOOLEAN __fastcall UDFVIsStored	(	IN PVCB	Vcb,
		IN lba_t	lba
	)

Definition at line 1320 of file udf_info.h.

{
    if(!Vcb->VerifyCtx.VInited)
        return FALSE;
    return UDFGetBit(Vcb->VerifyCtx.StoredBitMap, lba);
} // end UDFVIsStored()

◆ UDFVRead()

OSSTATUS UDFVRead	(	IN PVCB	Vcb,
		IN void *	Buffer,
		IN uint32	BCount,
		IN uint32	LBA,
		IN uint32	Flags
	)

Definition at line 375 of file remap.cpp.

{
    PLIST_ENTRY Link;
    PUDF_VERIFY_ITEM vItem;
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    ULONG crc;
    ULONG i;
    ULONG n;
    OSSTATUS status = STATUS_SUCCESS;
    uint32* bm;
 
    if(!VerifyCtx->VInited) {
        return STATUS_SUCCESS;
        //return STATUS_UNSUCCESSFUL;
    }
 
    UDFAcquireResourceExclusive(&(VerifyCtx->VerifyLock), TRUE);
 
    for(i=0, n=0; i<BCount; i++) {
        if(UDFGetBit(VerifyCtx->StoredBitMap, LBA+i)) {
            // some blocks are remembered
            n++;
        }
    }
 
    if(!n) {
        // no blocks are remembered
        UDFReleaseResource(&(VerifyCtx->VerifyLock));
        return STATUS_SUCCESS;
    }
 
    Link = VerifyCtx->vrfList.Flink;
    i=0;
    while(Link != &(VerifyCtx->vrfList)) {
        vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
        Link = Link->Flink;
        if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
            ASSERT(UDFGetBit(VerifyCtx->StoredBitMap, vItem->lba));
            i++;
            if(!(Flags & PH_READ_VERIFY_CACHE)) {
                crc = crc32((PUCHAR)Buffer+(vItem->lba - LBA)*Vcb->BlockSize, Vcb->BlockSize);
                if(vItem->crc != crc) {
                    UDFPrint(("UDFVRead: stored %x != %x\n", vItem->crc, crc));
                    RtlCopyMemory((PUCHAR)Buffer+(vItem->lba - LBA)*Vcb->BlockSize, vItem->Buffer, Vcb->BlockSize);
                    status = STATUS_FT_WRITE_RECOVERY;
 
                    if(!(bm = (uint32*)(Vcb->BSBM_Bitmap))) {
                        crc = (Vcb->LastPossibleLBA+1+7) >> 3; // reuse 'crc' variable
                        bm = (uint32*)(Vcb->BSBM_Bitmap = (int8*)DbgAllocatePoolWithTag(NonPagedPool, crc, 'mNWD' ));
                        if(bm) {
                            RtlZeroMemory(bm, crc);
                        } else {
                            UDFPrint(("Can't alloc BSBM for %x blocks\n", Vcb->LastPossibleLBA));
                        }
                    }
                    if(bm) {
                        UDFSetBit(bm, vItem->lba);
                        UDFPrint(("Set BB @ %#x\n", vItem->lba));
                    }
#ifdef _BROWSE_UDF_
                    bm = (uint32*)(Vcb->FSBM_Bitmap);
                    if(bm) {
                        UDFSetUsedBit(bm, vItem->lba);
                        UDFPrint(("Set BB @ %#x as used\n", vItem->lba));
                    }
#endif //_BROWSE_UDF_
                } else {
                    // ok
                }
            } else {
                UDFPrint(("UDFVRead: get cached @ %x\n", vItem->lba));
                RtlCopyMemory((PUCHAR)Buffer+(vItem->lba - LBA)*Vcb->BlockSize, vItem->Buffer, Vcb->BlockSize);
            }
            if(i >= n) {
                // no more blocks expected
                break;
            }
        }
    }
 
    if((status == STATUS_SUCCESS && !(Flags & PH_KEEP_VERIFY_CACHE)) || (Flags & PH_FORGET_VERIFIED)) {
        // ok, forget this, no errors found
        Link = VerifyCtx->vrfList.Flink;
        i = 0;
        while(Link != &(VerifyCtx->vrfList)) {
            vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
            Link = Link->Flink;
            if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
                i++;
                UDFVRemoveBlock(VerifyCtx, vItem);
                if(i >= n) {
                    // no more blocks expected
                    break;
                }
            }
        }
    }
 
    UDFReleaseResource(&(VerifyCtx->VerifyLock));
    return status;
 
} // end UDFVRead()

Referenced by UDFPhReadSynchronous(), and UDFVWorkItem().

◆ UDFVRelease()

VOID UDFVRelease ( IN PVCB Vcb )

Definition at line 132 of file remap.cpp.

{
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    PLIST_ENTRY Link;
    PUDF_VERIFY_ITEM vItem;
 
    if(!VerifyCtx->VInited) {
        return;
    }
 
    UDFPrint(("UDFVRelease: wait for completion\n"));
    UDFVWaitQueued(VerifyCtx);
 
    UDFAcquireResourceExclusive(&(VerifyCtx->VerifyLock), TRUE);
 
    Link = VerifyCtx->vrfList.Flink;
 
    while(Link != &(VerifyCtx->vrfList)) {
        vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
        Link = Link->Flink;
        //DbgFreePool(vItem);
        UDFVRemoveBlock(VerifyCtx, vItem);
    }
    VerifyCtx->VInited = FALSE;
 
    UDFReleaseResource(&(VerifyCtx->VerifyLock));
 
    ExDeleteResourceLite(&(VerifyCtx->VerifyLock));
    DbgFreePool(VerifyCtx->StoredBitMap);
 
    RtlZeroMemory(VerifyCtx, sizeof(UDF_VERIFY_CTX));
 
    return;
} // end UDFVRelease()

Referenced by UDFCommonDeviceControl(), and UDFReleaseVCB().

◆ UDFVVerify()

VOID UDFVVerify	(	IN PVCB	Vcb,
		IN ULONG	Flags
	)

Definition at line 601 of file remap.cpp.

{
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    PLIST_ENTRY Link;
    PUDF_VERIFY_ITEM vItem;
    PUDF_VERIFY_REQ VerifyReq = NULL;
    ULONG len, max_len=0;
    lba_t prev_lba;
    //PUCHAR tmp_buff;
    ULONG i;
    BOOLEAN do_vrf = FALSE;
 
    if(!VerifyCtx->VInited) {
        return;
    }
    if(VerifyCtx->QueuedCount) {
        if(Flags & UFD_VERIFY_FLAG_WAIT) {
            UDFPrint(("  wait for verify flush\n"));
            goto wait;
        }
        UDFPrint(("  verify flush already queued\n"));
        return;
    }
 
    if(!(Flags & (UFD_VERIFY_FLAG_FORCE | UFD_VERIFY_FLAG_BG))) {
        if(VerifyCtx->ItemCount < UDF_MAX_VERIFY_CACHE) {
            return;
        }
 
    }
    if(!(Flags & UFD_VERIFY_FLAG_LOCKED)) {
        UDFAcquireResourceExclusive(&(VerifyCtx->VerifyLock), TRUE);
    }
 
    if(Flags & UFD_VERIFY_FLAG_FORCE) {
        i = VerifyCtx->ItemCount;
    } else {
        if(VerifyCtx->ItemCount >= UDF_MAX_VERIFY_CACHE) {
            i = VerifyCtx->ItemCount - UDF_VERIFY_CACHE_LOW;
        } else {
            i = min(UDF_VERIFY_CACHE_GRAN, VerifyCtx->ItemCount);
        }
    }
 
    Link = VerifyCtx->vrfList.Flink;
    prev_lba = -2;
    len = 0;
 
    while(i) {
        ASSERT(Link != &(VerifyCtx->vrfList));
/*
        if(Link == &(VerifyCtx->vrfList)) {
            if(!len)
                break;
            i=1;
            goto queue_req;
        }
*/
        vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
        Link = Link->Flink;
 
        //
        if(!vItem->queued && (prev_lba+len == vItem->lba)) {
            vItem->queued = TRUE;
            len++;
        } else {
            if(len) {
                do_vrf = TRUE;
            } else {
                len = 1;
                prev_lba = vItem->lba;
            }
        }
        if((i == 1) && len) {
            do_vrf = TRUE;
        }
        if(len >= 0x100) {
            do_vrf = TRUE;
        }
        if(do_vrf) {
//queue_req:
            if(!VerifyReq) {
                VerifyReq = (PUDF_VERIFY_REQ)DbgAllocatePoolWithTag(NonPagedPool, sizeof(UDF_VERIFY_REQ), 'bNWD');
                if(VerifyReq) {
                    RtlZeroMemory(VerifyReq, sizeof(UDF_VERIFY_REQ));
                    VerifyReq->Vcb    = Vcb;
                }
            }
            if(VerifyReq) {
 
                VerifyReq->vr[VerifyReq->nReq].lba    = prev_lba;
                VerifyReq->vr[VerifyReq->nReq].BCount = len;
                VerifyReq->nReq++;
                if(max_len < len) {
                    max_len = len;
                }
 
                if((VerifyReq->nReq >= MAX_VREQ_RANGES) || (i == 1)) {
 
                    VerifyReq->Buffer = (PUCHAR)DbgAllocatePoolWithTag(NonPagedPool, max_len * Vcb->BlockSize, 'bNWD');
                    if(VerifyReq->Buffer) {
                        InterlockedIncrement((PLONG)&(VerifyCtx->QueuedCount));
#ifndef _CONSOLE
                        ExInitializeWorkItem( &(VerifyReq->VerifyItem),
                                              UDFVWorkItem,
                                              VerifyReq );
                        ExQueueWorkItem( &(VerifyReq->VerifyItem), CriticalWorkQueue );
#else
                        UDFVWorkItem(VerifyReq);
#endif
                    } else {
                        DbgFreePool(VerifyReq);
                    }
                    VerifyReq = NULL;
                    max_len = 0;
                } else {
                }
            }
            len = 1;
            prev_lba = vItem->lba;
            do_vrf = FALSE;
        }
        i--;
    }
 
    if(!(Flags & UFD_VERIFY_FLAG_LOCKED)) {
        UDFReleaseResource(&(VerifyCtx->VerifyLock));
    }
    if(Flags & UFD_VERIFY_FLAG_WAIT) {
wait:
        UDFPrint(("UDFVVerify: wait for completion\n"));
        UDFVWaitQueued(VerifyCtx);
    }
 
    return;
} // end UDFVVerify()

Referenced by UDFCommonWrite(), UDFEjectReqWaiter(), UDFVFlush(), and UDFVWrite().

◆ UDFVWrite()

OSSTATUS UDFVWrite	(	IN PVCB	Vcb,
		IN void *	Buffer,
		IN uint32	BCount,
		IN uint32	LBA,
		IN uint32	Flags
	)

Definition at line 225 of file remap.cpp.

{
    PLIST_ENTRY Link;
    PUDF_VERIFY_ITEM vItem;
    //PUDF_VERIFY_ITEM vItem1;
    PUDF_VERIFY_CTX VerifyCtx = &Vcb->VerifyCtx;
    ULONG i;
    ULONG n;
    //uint32 prev_lba;
 
    if(!VerifyCtx->VInited) {
        return STATUS_SUCCESS;
    }
 
    UDFAcquireResourceExclusive(&(VerifyCtx->VerifyLock), TRUE);
 
    for(i=0, n=0; i<BCount; i++) {
        if(UDFGetBit(VerifyCtx->StoredBitMap, LBA+i)) {
            // some blocks are remembered
            n++;
        }
    }
 
    if(n == BCount) {
        // update all blocks
        n = 0;
        Link = VerifyCtx->vrfList.Blink;
        while(Link != &(VerifyCtx->vrfList)) {
            vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
            Link = Link->Blink;
            if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
                ASSERT(UDFGetBit(VerifyCtx->StoredBitMap, vItem->lba));
                UDFVUpdateBlock(Vcb, ((PUCHAR)Buffer)+(vItem->lba-LBA)*Vcb->BlockSize, vItem);
                n++;
                if(n == BCount) {
                    // all updated
                    break;
                }
            }
        }
    } else
    if(n) {
#if 0
        // find remembered blocks (the 1st one)
        Link = VerifyCtx->vrfList.Blink;
        while(Link != &(VerifyCtx->vrfList)) {
            vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
            Link = Link->Blink;
            if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
                //UDFVRemoveBlock(VerifyCtx, vItem);
                break;
            }
        }
 
        // check if contiguous
        i=1;
        prev_lba = vItem->lba;
        vItem1 = vItem;
        Link = Link->Blink;
        while((i < n) && (Link != &(VerifyCtx->vrfList))) {
            vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
            Link = Link->Blink;
            if(vItem->lba > LBA || vItem->lba >= LBA+BCount) {
                // end
                break;
            }
            if(vItem->lba < prev_lba) {
                // not sorted
                break;
            }
            prev_lba = vItem->lba;
            i++;
        }
 
        if(i == n) {
            // cont
        } else {
            // drop all and add again
        }
 
        vItem1 = vItem;
        for(i=0; i<BCount; i++) {
            if(vItem->lba == LBA+i) {
                ASSERT(UDFGetBit(VerifyCtx->StoredBitMap, LBA+i));
                UDFVUpdateBlock(Vcb, ((PUCHAR)Buffer)+i*Vcb->BlockSize, vItem);
                continue;
            }
            if(vItem1->lba == LBA+i) {
                ASSERT(UDFGetBit(VerifyCtx->StoredBitMap, LBA+i));
                UDFVUpdateBlock(Vcb, ((PUCHAR)Buffer)+i*Vcb->BlockSize, vItem1);
                continue;
            }
            if(vItem1->lba > LBA+i) {
                // just insert this block
                ASSERT(!UDFGetBit(VerifyCtx->StoredBitMap, LBA+i));
                UDFVStoreBlock(Vcb, LBA+i, ((PUCHAR)Buffer)+i*Vcb->BlockSize, &(vItem1->vrfList));
            } else {
                vItem = CONTAINING_RECORD( vItem->vrfList.Blink, UDF_VERIFY_ITEM, vrfList );
            }
        }
#else
        Link = VerifyCtx->vrfList.Blink;
        i=0;
        while(Link != &(VerifyCtx->vrfList)) {
            vItem = CONTAINING_RECORD( Link, UDF_VERIFY_ITEM, vrfList );
            Link = Link->Blink;
            if(vItem->lba >= LBA && vItem->lba < LBA+BCount) {
                UDFVRemoveBlock(VerifyCtx, vItem);
                i++;
                if(i == n) {
                    // all killed
                    break;
                }
            }
        }
        goto remember_all;
#endif
 
    } else {
remember_all:
        // remember all blocks
        for(i=0; i<BCount; i++) {
            ASSERT(!UDFGetBit(VerifyCtx->StoredBitMap, LBA+i));
            UDFVStoreBlock(Vcb, LBA+i, ((PUCHAR)Buffer)+i*Vcb->BlockSize, &(VerifyCtx->vrfList));
        }
    }
 
    if(VerifyCtx->ItemCount > UDF_MAX_VERIFY_CACHE) {
        UDFVVerify(Vcb, UFD_VERIFY_FLAG_LOCKED);
    }
 
    UDFReleaseResource(&(VerifyCtx->VerifyLock));
 
    if(VerifyCtx->ItemCount > UDF_MAX_VERIFY_CACHE*2) {
        //UDFVVerify(Vcb, UFD_VERIFY_FLAG_LOCKED);
        // TODO: make some delay
    }
 
    return STATUS_SUCCESS;
 
} // end UDFVWrite()

Referenced by UDFPhWriteSynchronous().

◆ UDFWriteExtent()

OSSTATUS UDFWriteExtent	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo,
		IN int64	Offset,
		IN SIZE_T	Length,
		IN BOOLEAN	Direct,
		IN int8 *	Buffer,
		OUT PSIZE_T	WrittenBytes
	)

Definition at line 3186 of file extent.cpp.

{
    if(!ExtInfo || !ExtInfo->Mapping)
        return STATUS_INVALID_PARAMETER;
 
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    uint32 Lba, sect_offs, flags;
    OSSTATUS status;
    SIZE_T to_write, _WrittenBytes;
    BOOLEAN reread_lba;
//    BOOLEAN already_prepared = FALSE;
//    BOOLEAN prepare = !Buffer;
 
    AdPrint(("Write ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
 
    Offset += ExtInfo->Offset;               // used for in-ICB data
    // write maximal possible part of each frag of extent
    while(((LONG)Length) > 0) {
        UDFCheckSpaceAllocation(Vcb, 0, Extent, AS_USED); // check if used
        Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
        // EOF check
        if(Lba == LBA_OUT_OF_EXTENT) {
            return STATUS_END_OF_FILE;
        }
/*        if((to_write < Length) &&
           !Direct && !prepare && !already_prepared) {
            // rebuild mapping, allocate space, etc.
            // to indicate this, set Buffer to NULL
            AdPrint(("UDFWriteExtent: Prepare\n"));
            BrutePoint();
            _WrittenBytes = 0;
            status = UDFWriteExtent(Vcb, ExtInfo, Offset, Length, *//*Direct*//*FALSE, NULL, &_WrittenBytes);
            if(!OS_SUCCESS(status)) {
                return status;
            }
            Extent = ExtInfo->Mapping;
            Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
            already_prepared = TRUE;
        }*/
        if(flags == EXTENT_NOT_RECORDED_NOT_ALLOCATED) {
            // here we should allocate space for this extent
            if(!OS_SUCCESS(status = UDFMarkNotAllocatedAsAllocated(Vcb, Offset, to_write, ExtInfo)))
                return status;
            Extent = ExtInfo->Mapping;
            UDFCheckSpaceAllocation(Vcb, 0, Extent, AS_USED); // check if used
            Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
            if(Lba == LBA_OUT_OF_EXTENT) {
                return STATUS_END_OF_FILE;
            }
            // we have already re-read Lba
            reread_lba = FALSE;
        } else {
            // we may need to re-read Lba if some changes are
            // made while converting from Alloc-Not-Rec
            reread_lba = TRUE;
        }
        // check if writing to not recorded allocated
        // in this case we must pad blocks with zeros around
        // modified area
        //
        // ...|xxxxxxxx|xxxxxxxx|xxxxxxxx|...
        //        .                .
        //        .     ||         .
        //        .     \/         .
        //        .                .
        // ...|000ddddd|dddddddd|dd000000|...
        //        .                .
        //        ^                ^
        //        sect_offs        sect_offs+to_write
        //        .                .
        //        .<-- to_write -->.
        //
        to_write = min(to_write, Length);
        if(flags == EXTENT_NOT_RECORDED_ALLOCATED) {
            if(!OS_SUCCESS(status = UDFMarkAllocatedAsRecorded(Vcb, Offset, to_write, ExtInfo)))
                return status;
            Extent = ExtInfo->Mapping;
            UDFCheckSpaceAllocation(Vcb, 0, Extent, AS_USED); // check if used
            if(reread_lba) {
                Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
                to_write = min(to_write, Length);
            }
            /*
              we must fill 1st block with zeros in 1 of 2 cases:
                1) start offset is not aligned on LBlock boundary
                      OR
                2) end offset is not aligned on LBlock boundary and lays in
                   the same LBlock
 
              we must fill last block with zeros if both
                1) end offset is not aligned on LBlock boundary
                      AND
                2) end offset DOESN'T lay in the 1st LBlock
            */
 
//            if(!prepare) {
                // pad 1st logical block
            if((sect_offs || (sect_offs + to_write < Vcb->LBlockSize) )
                                &&
                           !Vcb->CDR_Mode) {
                status = UDFWriteData(Vcb, TRUE,
                                      ( ((uint64)Lba) << Vcb->BlockSizeBits),
                                      Vcb->LBlockSize, Direct, Vcb->ZBuffer, &_WrittenBytes);
                if(!OS_SUCCESS(status))
                    return status;
            }
            // pad last logical block
            if((sect_offs + to_write > Vcb->LBlockSize) &&
               (sect_offs + to_write) & (Vcb->LBlockSize - 1)) {
                status = UDFWriteData(Vcb, TRUE,
                                      (( ((uint64)Lba) << Vcb->BlockSizeBits) + sect_offs + to_write) & ~((int64)(Vcb->LBlockSize)-1),
                                      Vcb->LBlockSize, Direct, Vcb->ZBuffer, &_WrittenBytes);
            }
            if(!OS_SUCCESS(status))
                return status;
/*            } else {
                status = STATUS_SUCCESS;
            }*/
        }
        ASSERT(to_write);
//        if(!prepare) {
        status = UDFWriteData(Vcb, TRUE, ( ((uint64)Lba) << Vcb->BlockSizeBits) + sect_offs, to_write, Direct, Buffer, &_WrittenBytes);
        *WrittenBytes += _WrittenBytes;
        if(!OS_SUCCESS(status)) return status;
/*        } else {
            status = STATUS_SUCCESS;
            *WrittenBytes += to_write;
        }*/
        // prepare for writing next frag...
        Buffer += to_write;
        Offset += to_write;
        Length -= to_write;
    }
    AdPrint(("Write: ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
    return STATUS_SUCCESS;
} // end UDFWriteExtent()

Referenced by UDFConvertFEToNonInICB(), UDFFlushFE(), UDFResizeFile__(), UDFUpdateXSpaceBitmaps(), and UDFWriteFile__().

◆ UDFWriteFile__()

OSSTATUS UDFWriteFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64	Offset,
		IN SIZE_T	Length,
		IN BOOLEAN	Direct,
		IN int8 *	Buffer,
		OUT PSIZE_T	WrittenBytes
	)

Definition at line 1605 of file udf_info.cpp.

{
    int64 t, elen;
    OSSTATUS status;
    int8* OldInIcb = NULL;
    ValidateFileInfo(FileInfo);
    SIZE_T ReadBytes;
    SIZE_T _WrittenBytes;
    PUDF_DATALOC_INFO Dloc;
    // unwind staff
    BOOLEAN WasInIcb = FALSE;
    uint64 OldLen;
 
//    ASSERT(FileInfo->RefCount >= 1);
 
    Dloc = FileInfo->Dloc;
    ASSERT(Dloc->FELoc.Mapping[0].extLocation);
    uint32 PartNum = UDFGetPartNumByPhysLba(Vcb, Dloc->FELoc.Mapping[0].extLocation);
    (*WrittenBytes) = 0;
 
    AdPrint(("UDFWriteFile__ FE %x, FileInfo %x, ExtInfo %x, Mapping %x\n",
        Dloc->FELoc.Mapping[0].extLocation, FileInfo, &(Dloc->DataLoc), Dloc->DataLoc.Mapping));
 
    t = Offset + Length;
//    UDFUpdateModifyTime(Vcb, FileInfo);
    if(t <= Dloc->DataLoc.Length) {
        // write Alloc-Rec area
        ExtPrint(("  WAlloc-Rec: %I64x <= %I64x\n", t, Dloc->DataLoc.Length));
        status = UDFWriteExtent(Vcb, &(Dloc->DataLoc), Offset, Length, Direct, Buffer, WrittenBytes);
        return status;
    }
    elen = UDFGetExtentLength(Dloc->DataLoc.Mapping);
    ExtPrint(("  DataLoc Offs %x, Len %I64x\n",
        Dloc->DataLoc.Offset, Dloc->DataLoc.Length));
    if(t <= (elen - Dloc->DataLoc.Offset)) {
        // write Alloc-Not-Rec area
        ExtPrint(("  WAlloc-Not-Rec: %I64x <= %I64x (%I64x - %I64x)\n",
            t, elen - Dloc->DataLoc.Offset - Dloc->DataLoc.Length,
            elen - Dloc->DataLoc.Offset,
            Dloc->DataLoc.Length));
        UDFSetFileSize(FileInfo, t);
        if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
            ExtPrint(("  w2k-compat -> rebuild allocs\n"));
            Dloc->DataLoc.Modified = TRUE;
        } else
        if((ULONG)((elen+Vcb->LBlockSize-1) >> Vcb->LBlockSizeBits) != (ULONG)((t+Vcb->LBlockSize-1) >> Vcb->LBlockSizeBits)) {
            ExtPrint(("  LBS boundary crossed -> rebuild allocs\n"));
            Dloc->DataLoc.Modified = TRUE;
        }
        Dloc->DataLoc.Length = t;
        return UDFWriteExtent(Vcb, &(Dloc->DataLoc), Offset, Length, Direct, Buffer, WrittenBytes);
    }
    // We should not get here if Direct=TRUE
    if(Direct) return STATUS_INVALID_PARAMETER;
    OldLen = Dloc->DataLoc.Length;
    if(Dloc->DataLoc.Offset && Dloc->DataLoc.Length) {
        // read in-icb data. it'll be replaced after resize
        ExtPrint(("  read in-icb data\n"));
        OldInIcb = (int8*)MyAllocatePool__(NonPagedPool, (uint32)(Dloc->DataLoc.Length));
        if(!OldInIcb) return STATUS_INSUFFICIENT_RESOURCES;
        status = UDFReadExtent(Vcb, &(Dloc->DataLoc), 0, (uint32)OldLen, FALSE, OldInIcb, &ReadBytes);
        if(!OS_SUCCESS(status)) {
            MyFreePool__(OldInIcb);
            return status;
        }
    }
    // init Alloc mode
    ExtPrint(("  init Alloc mode\n"));
    if((((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags & ICB_FLAG_ALLOC_MASK) == ICB_FLAG_AD_IN_ICB) {
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags &= ~ICB_FLAG_ALLOC_MASK;
        ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags |= Vcb->DefaultAllocMode;
        WasInIcb = TRUE;
    }
    // increase extent
    ExtPrint(("  %s %s %s\n",
        UDFIsADirectory(FileInfo) ? "DIR" : "FILE",
        WasInIcb ? "In-Icb" : "",
        Vcb->LowFreeSpace ? "LowSpace" : ""));
    if(UDFIsADirectory(FileInfo) && !WasInIcb && !Vcb->LowFreeSpace) {
        FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_ALLOC_SEQUENTIAL;
        status = UDFResizeExtent(Vcb, PartNum, (t*2+Vcb->WriteBlockSize-1) & ~(SIZE_T)(Vcb->WriteBlockSize-1), FALSE, &(Dloc->DataLoc));
        if(OS_SUCCESS(status)) {
            AdPrint(("  preallocated space for Dir\n"));
            FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_PREALLOCATED;
            //UDFSetFileSize(FileInfo, t);
            Dloc->DataLoc.Length = t;
        } else
        if(status == STATUS_DISK_FULL) {
            status = UDFResizeExtent(Vcb, PartNum, t, FALSE, &(Dloc->DataLoc));
        }
    } else {
        status = UDFResizeExtent(Vcb, PartNum, t, FALSE, &(Dloc->DataLoc));
    }
    ExtPrint(("  DataLoc Offs %x, Len %I64x\n",
        Dloc->DataLoc.Offset, Dloc->DataLoc.Length));
    AdPrint(("UDFWriteFile__ (2) FileInfo %x, ExtInfo %x, Mapping %x\n", FileInfo, &(Dloc->DataLoc), Dloc->DataLoc.Mapping));
    if(!OS_SUCCESS(status)) {
        // rollback
        ExtPrint(("  err -> rollback\n"));
        if(WasInIcb) {
            // restore Alloc mode
            ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags &= ~ICB_FLAG_ALLOC_MASK;
            ((PFILE_ENTRY)(Dloc->FileEntry))->icbTag.flags |= ICB_FLAG_AD_IN_ICB;
            if(Dloc->AllocLoc.Mapping) {
                MyFreePool__(Dloc->AllocLoc.Mapping);
                Dloc->AllocLoc.Mapping = NULL;
            }
        }
        if(OldInIcb) {
            UDFWriteExtent(Vcb, &(Dloc->DataLoc), 0, (uint32)OldLen, FALSE, OldInIcb, &_WrittenBytes);
            MyFreePool__(OldInIcb);
        }
        if((int64)OldLen != Dloc->DataLoc.Length) {
            // restore file size
            AdPrint(("  restore alloc\n"));
            FileInfo->Dloc->DataLoc.Flags |= EXTENT_FLAG_CUT_PREALLOCATED;
            UDFResizeExtent(Vcb, PartNum, OldLen, FALSE, &(Dloc->DataLoc));
            FileInfo->Dloc->DataLoc.Flags &= ~EXTENT_FLAG_CUT_PREALLOCATED;
        }
        return status;
    }
    if(OldInIcb) {
        // replace data from ICB (if any) & free buffer
        ExtPrint(("  write old in-icd data\n"));
        status = UDFWriteExtent(Vcb, &(Dloc->DataLoc), 0, (uint32)OldLen, FALSE, OldInIcb, &_WrittenBytes);
        MyFreePool__(OldInIcb);
        if(!OS_SUCCESS(status))
            return status;
    }
    // ufff...
    // & now we'll write out data to well prepared extent...
    // ... like all normal people do...
    ExtPrint(("  write user data\n"));
    if(!OS_SUCCESS(status = UDFWriteExtent(Vcb, &(Dloc->DataLoc), Offset, Length, FALSE, Buffer, WrittenBytes)))
        return status;
    UDFSetFileSize(FileInfo, t);
    Dloc->DataLoc.Modified = TRUE;
#ifdef UDF_DBG
    if(Vcb->CompatFlags & UDF_VCB_IC_W2K_COMPAT_ALLOC_DESCS) {
        ASSERT(UDFGetFileSize(FileInfo) <= UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping));
    } else {
        ASSERT(((UDFGetFileSize(FileInfo)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)) ==
               ((UDFGetExtentLength(FileInfo->Dloc->DataLoc.Mapping)+Vcb->LBlockSize-1) & (Vcb->LBlockSize-1)));
    }
#endif // UDF_DBG
    return STATUS_SUCCESS;
} // end UDFWriteFile__()

Referenced by UDFCommonWrite(), UDFConvertFEToExtended(), UDFFlushFI(), UDFPackDirectory__(), UDFRecordDirectory__(), UDFRecordVAT(), UDFResizeFile__(), UDFReTagDirectory(), and UDFWriteSecurity().

◆ UDFZeroExtent()

OSSTATUS UDFZeroExtent	(	IN PVCB	Vcb,
		IN PEXTENT_INFO	ExtInfo,
		IN int64	Offset,
		IN SIZE_T	Length,
		IN BOOLEAN	Deallocate,
		IN BOOLEAN	Direct,
		OUT PSIZE_T	WrittenBytes
	)

Definition at line 3337 of file extent.cpp.

{
    if(!ExtInfo || !ExtInfo->Mapping)
        return STATUS_INVALID_PARAMETER;
 
    PEXTENT_MAP Extent = ExtInfo->Mapping;   // Extent array
    uint32 Lba, sect_offs, flags;
    OSSTATUS status;
    SIZE_T to_write, _WrittenBytes;
    SIZE_T LBS = Vcb->LBlockSize;
 
    AdPrint(("Zero ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
 
    Offset += ExtInfo->Offset;               // used for in-ICB data
    // fill/deallocate maximal possible part of each frag of extent
    while(((LONG)Length) > 0) {
        Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
        // EOF check
        if(Lba == LBA_OUT_OF_EXTENT) {
            return STATUS_END_OF_FILE;
        }
        // check for writing tail
        to_write = min(to_write, Length);
 
        if(flags == EXTENT_NOT_RECORDED_NOT_ALLOCATED) {
            // here we should do nothing
            *WrittenBytes += to_write;
        } else
        if(flags == EXTENT_NOT_RECORDED_ALLOCATED) {
            // we should just deallocate this frag
            if(Deallocate) {
                if(!OS_SUCCESS(status = UDFMarkAllocatedAsNotAllocated(Vcb, Offset, to_write, ExtInfo)))
                    return status;
            }
            Extent = ExtInfo->Mapping;
            *WrittenBytes += to_write;
        } else {
            // fill tail of the 1st Block with ZEROs
            if(sect_offs) {
                status = UDFWriteData(Vcb, TRUE, ( ((uint64)Lba) << Vcb->BlockSizeBits) + sect_offs,
                                      min(to_write, LBS-sect_offs),
                                      Direct, Vcb->ZBuffer, &_WrittenBytes);
                *WrittenBytes += _WrittenBytes;
                if(!OS_SUCCESS(status))
                    return status;
                Offset += _WrittenBytes;
                Length -= _WrittenBytes;
                to_write -= _WrittenBytes;
                Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
                ASSERT(flags != EXTENT_NOT_RECORDED_NOT_ALLOCATED);
                ASSERT(flags != EXTENT_NOT_RECORDED_ALLOCATED);
                ASSERT(!sect_offs);
            }
            // deallocate Blocks
            if(to_write >= LBS) {
                // use 'sect_offs' as length of extent to be deallocated
                sect_offs = to_write & ~(LBS - 1);
                if(Deallocate) {
                    status = UDFMarkAllocatedAsNotAllocated(Vcb, Offset, sect_offs, ExtInfo);
                } else {
                    status = UDFMarkRecordedAsAllocated(Vcb, Offset, sect_offs, ExtInfo);
                }
                if(!OS_SUCCESS(status))
                    return status;
                // reload extent mapping
                Extent = ExtInfo->Mapping;
                Offset += sect_offs;
                Length -= sect_offs;
                *WrittenBytes += sect_offs;
                to_write -= sect_offs;
                Lba = UDFExtentOffsetToLba(Vcb, Extent, Offset, &sect_offs, &to_write, &flags, NULL);
                ASSERT(flags != EXTENT_NOT_RECORDED_NOT_ALLOCATED);
                ASSERT(flags != EXTENT_NOT_RECORDED_ALLOCATED);
                ASSERT(!sect_offs);
            }
            // fill beginning of the last Block with ZEROs
            if(to_write) {
                status = UDFWriteData(Vcb, TRUE, ( ((uint64)Lba) << Vcb->BlockSizeBits), to_write, Direct, Vcb->ZBuffer, &_WrittenBytes);
                *WrittenBytes += _WrittenBytes;
                if(!OS_SUCCESS(status))
                    return status;
                ASSERT(to_write == _WrittenBytes);
            }
        }
        AdPrint(("Zero... ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
        // prepare for filling next frag...
        Offset += to_write;
        Length -= to_write;
    }
    AdPrint(("Zero: ExtInfo %x, Mapping %x\n", ExtInfo, ExtInfo->Mapping));
    return STATUS_SUCCESS;
} // end UDFZeroExtent()

◆ UDFZeroFile__()

__inline OSSTATUS UDFZeroFile__	(	IN PVCB	Vcb,
		IN PUDF_FILE_INFO	FileInfo,
		IN int64	Offset,
		IN uint32	Length,
		IN BOOLEAN	Direct,
		OUT uint32 *	ReadBytes
	)

Variable Documentation

◆ hexChar

const char hexChar[]

extern

Macros

Functions

Variables

Macro Definition Documentation

◆ AlignDirIndex

◆ AS_BAD

◆ AS_DISCARDED

◆ AS_FREE

◆ AS_USED

◆ FLUSH_FE_FOR_DEL

◆ FLUSH_FE_KEEP

◆ HASH_ALL

◆ HASH_DOS

◆ HASH_KEEP_NAME

◆ HASH_POSIX

◆ HASH_ULFN

◆ PH_FORGET_VERIFIED

◆ PH_KEEP_VERIFY_CACHE

◆ PH_READ_VERIFY_CACHE

◆ UDF_DIR_INDEX_FRAME

◆ UDF_DIR_INDEX_FRAME_GRAN

◆ UDF_DIR_INDEX_FRAME_GRAN_MASK

◆ UDF_DIR_INDEX_FRAME_SH

◆ UDF_FREE_DLOC

◆ UDF_FREE_FILEINFO

◆ UDF_FREE_NOTHING

◆ UDF_FSPACE_BM

◆ UDF_MAX_VERIFY_CACHE

◆ UDF_PREALLOC_CLASS_DIR

◆ UDF_PREALLOC_CLASS_FE

◆ UDF_SYS_CACHE_STOP_THR

◆ UDF_VERIFY_CACHE_GRAN

◆ UDF_VERIFY_CACHE_LOW

◆ UDF_ZSPACE_BM

◆ UDFAllocFreeExtent

◆ UDFCheckFreeBitOwner

◆ UDFCheckSpaceAllocation

◆ UDFCheckUsedBitOwner

◆ UDFClrBit

◆ UDFClrBits

◆ UDFClrZeroBit

◆ UDFClrZeroBits

◆ UDFDecDirCounter

◆ UDFDecFileCounter

◆ UDFDecFileLinkCount

◆ UDFDereferenceFile__

◆ UDFDirIndexGetLastIndex

◆ UDFDOSName__

◆ UDFExtentToMapping

◆ UDFGetBadBit

◆ UDFGetBit

◆ UDFGetFileAllocationSize

◆ UDFGetFileAllocMode__

◆ UDFGetFileICBAllocMode__

◆ UDFGetFreeBit

◆ UDFGetLVIDiUse

◆ UDFGetPartNumByPartNdx

◆ UDFGetUsedBit

◆ UDFGetZeroBit

◆ UDFHasAStreamDir

◆ UDFIncDirCounter

◆ UDFIncFileCounter

◆ UDFIncFileLinkCount

◆ UDFIsADirectory

◆ UDFIsAStream

◆ UDFIsAStreamDir

◆ UDFIsDeleted

◆ UDFIsDirEmpty__

◆ UDFIsDirOpened__

◆ UDFIsFileCached__

◆ UDFIsFlushed

◆ UDFIsSDirDeleted

◆ UDFMarkAllocatedAsNotAllocated

◆ UDFMarkRecordedAsAllocated

◆ UDFMarkSpaceAsXXX

◆ UDFMarkSpaceAsXXXNoProtect

◆ UDFNtAclSupported

◆ UDFReferenceFile__

◆ UDFReferenceFileEx__

◆ UDFRegisterFsStructure