udf_info.cpp File Reference

#include "udf.h"

Include dependency graph for udf_info.cpp:

Go to the source code of this file.

Macros
#define	UDF_BUG_CHECK_ID   UDF_FILE_UDF_INFO
#define	DOS_CRC_MODULUS   41
#define	hexChar   crcChar
#define	DOS_CRC_LEN   4
#define	DOS_CRC_MODULUS   41
#define	lba   WrittenBytes

Functions
void __fastcall	UDFDecompressUnicode (IN OUT PUNICODE_STRING UName, IN uint8 *CS0, IN SIZE_T Length, OUT uint16 *valueCRC)
void __fastcall	UDFCompressUnicode (IN PUNICODE_STRING UName, IN OUT uint8 **_CS0, IN OUT PSIZE_T Length)
OSSTATUS	UDFReadFileEntry (IN PVCB Vcb, IN long_ad *Icb, IN OUT PFILE_ENTRY FileEntry, IN OUT uint16 *Ident)
BOOLEAN	UDFUnicodeInString (IN uint8 *string, IN WCHAR ch)
BOOLEAN __fastcall	UDFIsIllegalChar (IN WCHAR chr)
void __fastcall	UDFDOSName (IN PVCB Vcb, IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)
void __fastcall	UDFDOSName100 (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	UDFDOSName201 (IN OUT PUNICODE_STRING DosName, IN PUNICODE_STRING UdfName, IN BOOLEAN KeepIntact)
void	UDFSetUpTag (IN PVCB Vcb, IN tag *Tag, IN uint16 DataLen, IN uint32 TagLoc)
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)
OSSTATUS	UDFLoadExtInfo (IN PVCB Vcb, IN PFILE_ENTRY fe, IN PLONG_AD fe_loc, IN OUT PEXTENT_INFO FExtInfo, IN OUT PEXTENT_INFO AExtInfo)
OSSTATUS	UDFBuildFileIdent (IN PVCB Vcb, IN PUNICODE_STRING fn, IN PLONG_AD FileEntryIcb, IN uint32 ImpUseLen, OUT PFILE_IDENT_DESC *_FileId, OUT uint32 *FileIdLen)
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)
uint16	UDFGetFileLinkCount (IN PUDF_FILE_INFO FileInfo)
uint32	UDFGetFileEALength (IN PUDF_FILE_INFO FileInfo)
int64	UDFAssingNewFUID (IN PVCB Vcb)
void	UDFSetFileUID (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)
__inline int64	UDFGetFileUID_ (IN tag *FileEntry)
int64	UDFGetFileUID (IN PUDF_FILE_INFO FileInfo)
void	UDFChangeFileCounter (IN PVCB Vcb, IN BOOLEAN FileCounter, IN BOOLEAN Increase)
void	UDFSetEntityID_imp_ (IN EntityID *eID, IN uint8 *Str, IN uint32 Len)
void	UDFReadEntityID_Domain (PVCB Vcb, EntityID *eID)
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	UDFZeroFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT PSIZE_T ReadBytes)
__inline OSSTATUS	UDFSparseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN int64 Offset, IN SIZE_T Length, IN BOOLEAN Direct, OUT PSIZE_T ReadBytes)
OSSTATUS	UDFPadLastSector (IN PVCB Vcb, IN PEXTENT_INFO ExtInfo)
OSSTATUS	UDFCloseFile__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)
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	UDFRecordDirectory__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO DirInfo)
OSSTATUS	UDFResizeFile__ (IN PVCB Vcb, IN OUT PUDF_FILE_INFO FileInfo, IN int64 NewLength)
OSSTATUS	UDFLoadVAT (IN PVCB Vcb, IN uint32 PartNdx)
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)
BOOLEAN	UDFCompareFileInfo (IN PUDF_FILE_INFO f1, IN PUDF_FILE_INFO f2)
uint32 __fastcall	crc32 (IN uint8 *s, IN uint32 len)
uint16 __fastcall	UDFUnicodeCksum (PWCHAR s, uint32 n)
uint16 __fastcall	UDFUnicodeCksum150 (PWCHAR s, uint32 n)
uint16 __fastcall	UDFCrc (IN uint8 *Data, IN SIZE_T Size)
OSSTATUS	UDFReadTagged (PVCB Vcb, int8 *Buf, uint32 Block, uint32 Location, uint16 *Ident)
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)
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	UDFUpdateVAT (IN void *_Vcb, IN uint32 Lba, IN uint32 *RelocTab, IN uint32 BCount)
OSSTATUS	UDFConvertFEToNonInICB (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo, IN uint8 NewAllocMode)
OSSTATUS	UDFConvertFEToExtended (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)
OSSTATUS	UDFPretendFileDeleted__ (IN PVCB Vcb, IN PUDF_FILE_INFO FileInfo)

Variables
static const char	valid_char_arr [] = {"*/:?\"<>|\\"}
static const char	crcChar [] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ#_~-@"
static const uint16	CrcTable [256]
static const uint32	crc32_tab []

Macro Definition Documentation

DOS_CRC_LEN

#define DOS_CRC_LEN   4

DOS_CRC_MODULUS [1/2]

#define DOS_CRC_MODULUS   41

Definition at line 44 of file udf_info.cpp.

DOS_CRC_MODULUS [2/2]

#define DOS_CRC_MODULUS   41

Definition at line 44 of file udf_info.cpp.

hexChar

#define hexChar   crcChar

Definition at line 45 of file udf_info.cpp.

lba

#define lba   WrittenBytes

UDF_BUG_CHECK_ID

#define UDF_BUG_CHECK_ID   UDF_FILE_UDF_INFO

Definition at line 19 of file udf_info.cpp.

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()

UDFAssingNewFUID()

int64 UDFAssingNewFUID

(

IN PVCB

Vcb

)

Definition at line 1445 of file udf_info.cpp.

{
    Vcb->NextUniqueId++;
    if(!((uint32)(Vcb->NextUniqueId)))
        Vcb->NextUniqueId += 16;
    return Vcb->NextUniqueId;
}

Referenced by UDFHardLinkFile__(), and UDFSetFileUID().

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__().

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()

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().

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().

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__().

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
	)

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().

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()

UDFGetFileUID_()

__inline int64 UDFGetFileUID_

(

IN tag *

FileEntry

)

Definition at line 1491 of file udf_info.cpp.

{
    uint16 Ident;
 
    Ident = FileEntry->tagIdent;
    if(Ident == TID_FILE_ENTRY) {
        PFILE_ENTRY fe = (PFILE_ENTRY)(FileEntry);
        return fe->uniqueID;
    } else if(Ident == TID_EXTENDED_FILE_ENTRY) {
        PEXTENDED_FILE_ENTRY fe = (PEXTENDED_FILE_ENTRY)(FileEntry);
        return fe->uniqueID;
    }
    return (-1);
} // end UDFGetFileUID()

Referenced by UDFGetFileUID().

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().

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__().

UDFIsIllegalChar()

BOOLEAN __fastcall UDFIsIllegalChar

(

IN WCHAR

chr

)

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__().

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().

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().

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().

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__().

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().

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__().

UDFReadTagged()

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

Definition at line 4586 of file udf_info.cpp.

{
    OSSTATUS RC;
    tag* PTag = (tag*)Buf;
//    icbtag* Icb = (icbtag*)(Buf+1);
    uint8 checksum;
    unsigned int i;
    SIZE_T ReadBytes;
    int8* tb;
 
    // Read the block
    if(Block == 0xFFFFFFFF)
        return NULL;
 
    _SEH2_TRY {
        RC = UDFReadSectors(Vcb, FALSE, Block, 1, FALSE, Buf, &ReadBytes);
        if(!OS_SUCCESS(RC)) {
            UDFPrint(("UDF: Block=%x, Location=%x: read failed\n", Block, Location));
            try_return(RC);
        }
 
        *Ident = PTag->tagIdent;
 
        if(Location != PTag->tagLocation) {
            UDFPrint(("UDF: location mismatch block %x, tag %x != %x\n",
                Block, PTag->tagLocation, Location));
            try_return(RC = STATUS_FILE_CORRUPT_ERROR);
        }
 
        /* Verify the tag checksum */
        checksum = 0;
        tb = Buf;
        for (i=0; i<sizeof(tag); i++, tb++)
            checksum += (uint8)((i!=4) ? (*tb) : 0);
 
        if(checksum != PTag->tagChecksum) {
            UDFPrint(("UDF: tag checksum failed block %x\n", Block));
            try_return(RC = STATUS_CRC_ERROR);
        }
 
        // Verify the tag version
        if((PTag->descVersion != 2) &&
           (PTag->descVersion != 3)) {
            UDFPrint(("UDF: Tag version 0x%04x != 0x0002 || 0x0003 block %x\n",
                (PTag->descVersion), Block));
            try_return(RC = STATUS_FILE_CORRUPT_ERROR);
        }
 
        // Verify the descriptor CRC
        if(((PTag->descCRCLength) + sizeof(tag) > Vcb->BlockSize) ||
           ((PTag->descCRC) == UDFCrc((uint8*)Buf + sizeof(tag), PTag->descCRCLength)) ||
           !(PTag->descCRC) ) {
    /*        UDFPrint(("Tag ID: %x, ver %x\t", PTag->tagIdent, PTag->descVersion ));
            if((i == TID_FILE_ENTRY) ||
               (i == TID_EXTENDED_FILE_ENTRY)) {
                UDFPrint(("StrategType: %x, ", Icb->strategyType ));
                UDFPrint(("FileType: %x\t", Icb->fileType ));
            }
            UDFPrint(("\n"));*/
            try_return(RC = STATUS_SUCCESS);
        }
        UDFPrint(("UDF: Crc failure block %x: crc = %x, crclen = %x\n",
            Block, PTag->descCRC, PTag->descCRCLength));
        RC = STATUS_CRC_ERROR;
 
try_exit:    NOTHING;
 
    } _SEH2_FINALLY {
        ;
    } _SEH2_END
 
    return RC;
} // end UDFReadTagged()

Referenced by UDFAddXSpaceBitmap(), UDFBuildFreeSpaceBitmap(), UDFFindAnchor(), UDFFindLastFileSet(), UDFLoadLogicalVolInt(), UDFLoadPartition(), UDFPrepareXSpaceBitmap(), UDFProcessSequence(), UDFReadFileEntry(), UDFReadVDS(), UDFUpdateLogicalVol(), UDFUpdateVDS(), UDFUpdateVolIdent(), UDFVerifyFreeSpaceBitmap(), UDFVerifySequence(), and UDFVerifyXSpaceBitmap().

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__().

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().

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().

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().

UDFSparseFile__()

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

Definition at line 2944 of file udf_info.cpp.

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

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__().

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().

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().

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) & ~(UINT64)(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().

UDFZeroFile__()

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

Definition at line 2925 of file udf_info.cpp.

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

Variable Documentation

crc32_tab

const uint32 crc32_tab[]

static

Definition at line 86 of file udf_info.cpp.

Referenced by crc32().

crcChar

const char crcChar[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ#_~-@"

static

Definition at line 46 of file udf_info.cpp.

Referenced by UDFDOSName201().

CrcTable

const uint16 CrcTable[256]

static

Definition at line 51 of file udf_info.cpp.

Referenced by UDFCrc(), UDFUnicodeCksum(), and UDFUnicodeCksum150().

valid_char_arr

const char valid_char_arr[] = {"*/:?\"<>|\\"}

static

Definition at line 41 of file udf_info.cpp.

Referenced by UDFIsIllegalChar().