Difference between revisions of "Unit CDFS"

From Ultibo.org
Jump to: navigation, search
Line 3,747: Line 3,747:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-
Line 3,759: Line 3,759:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-
Line 3,774: Line 3,774:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Allows byte order swapping on copy
 
| Allows byte order swapping on copy
 
|-
 
|-
Line 3,786: Line 3,786:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Allows byte order swapping on copy
 
| Allows byte order swapping on copy
 
|-
 
|-
Line 3,798: Line 3,798:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Accounts for unicode and byte ordering
 
| Accounts for unicode and byte ordering
 
|-
 
|-
Line 3,810: Line 3,810:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Accounts for unicode and byte ordering
 
| Accounts for unicode and byte ordering
 
|-
 
|-
Line 3,822: Line 3,822:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Accounts for dot and dot dot special entries
 
| Accounts for dot and dot dot special entries
 
|-
 
|-
Line 3,834: Line 3,834:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| Accounts for dot and dot dot special entries
 
| Accounts for dot and dot dot special entries
 
|-
 
|-
Line 3,846: Line 3,846:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-
Line 3,858: Line 3,858:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-
Line 3,870: Line 3,870:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-
Line 3,882: Line 3,882:
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
{| class="wikitable" style="font-size: 14px; background: white;"
 
|-
 
|-
−
! '''Note'''
+
! Note
 
| None documented
 
| None documented
 
|-
 
|-

Revision as of 03:17, 24 April 2018

Return to Unit Reference


Description

Ultibo CDFS interface unit

To be documented

Constants


CDFS specific constants cdfs*
cdfsIso9660 = 0;  
cdfsJoilet = 1;  
cdfsSierra = 2;  
cdfsRockRidge = 3;  
cdfsAudio = 4;  
cdfsUDF = 5;  
 
cdfsAnyName = '*';  
cdfsDotName = '.';  
cdfsDotDotName = '..';  
cdfsVersionName = '1'; Used by version information on end of identifier (Not Used)
cdfsSeparator1Name = '.'; Dot on end of identifier when no extension exists (File only)
cdfsSeparator2Name = ';'; Used by version information on end of identifier (File only)
 
cdfsJolietMaxPath = 240; 120 (240 bytes)
cdfsJolietMaxFile = 64; (128 bytes)
cdfsISO9660MaxPath = 240;  
cdfsISO9660MaxFile = 30; 31 for Directories
 
cdfsISO9660StandardIdentifier = 'CD001';  
cdfsELTORITOSystemIdentifier = 'EL TORITO SPECIFICATION';  
 
cdfsFirstSector = 0;  
cdfsReservedSectors = 16;  
cdfsISO9660StartSector = 16;  
cdfsELTORITOBootSector = 17;  
 
cdfsISO9660StructureVersion = 1;  
cdfsISO9660DescriptorVersion = 1;  
cdfsELTORITODescriptorVersion = 1;  
 
cdfsJolietUCS2Sequence1 = #37 + #47 + #64; '%/@'
cdfsJolietUCS2Sequence2 = #37 + #47 + #67; '%/C'
cdfsJolietUCS2Sequence3 = #37 + #47 + #69; '%/E'
 
cdfsDotIdentifier = $00;  
cdfsDotDotIdentifier = $01;  
 
cdfsSeparator1Value = $2E; '.'
cdfsSeparator2Value = $3B; ';'
 
cdfsTimeStartYear = 1900; CDFS Time starts at 1900
cdfsTimeOffsetInterval = 15; Offset is in 15 minute intervals
 
cdfsNullFileTime:TFileTime = (dwLowDateTime:$00000000;dwHighDateTime:$00000000);  
 
cdfsStartCluster = 16;  
cdfsUnknownCluster = LongWord(-1);  
 
cdfsRootPathNumber = 1;  
 
cdfsPathRecordSize = 9; Minimum
cdfsExtendedRecordSize = 250; Minimum
cdfsDirectoryRecordSize = 34; Minimum
 
cdfsFileIdentifierSize = 1; Minimum
cdfsPathIdentifierSize = 1; Minimum
 
cdfsHeaderRecordSize = 32; Fixed
cdfsCatalogRecordSize = 32; Fixed
cdfsExtensionRecordSize = 32; Fixed
 
cdfsEvenSize = 0;  
cdfsUnevenSize = 1;  
 
cdfsRootRecordOffset = 156; Offset of Root Directory in Descriptor
 
cdfsInstanceFirst = 0;  
cdfsInstanceLast = Byte(-1);  
 
cdfsTableTypeMask = $00FF0000;  
cdfsTableTypeShift = 16;  
cdfsTableInstanceMask = $0000FF00;  
cdfsTableInstanceShift = 8;  
cdfsTableDescriptorMask = $000000FF;  
cdfsTableDescriptorShift = 0;  
 
cdfsBitmapUnknown = LongWord(-1);  


CDFS bitmap mask cdfsBitmapMask*
cdfsBitmapMaskBits = 64; Int64 Bitmap Masks
cdfsBitmapMaskNone = $0000000000000000; Int64 Used for fast counting of free blocks
cdfsBitmapMaskAll = $FFFFFFFFFFFFFFFF; Int64 Used for fast counting of used blocks


CDFS volume flag cdfsVolumeFlag*
cdfsVolumeFlagNone = $00;  
cdfsVolumeFlagUnregistered = $01; If set this SVD contains an unregistered escape sequence


CDFS file flag cdfsFileFlag*
cdfsFileFlagNone = $00;  
cdfsFileFlagExistence = $01; If set this file is hidden
cdfsFileFlagDirectory = $02; If set this record is a directory
cdfsFileFlagAssociated = $04; If set this file is an associated file
cdfsFileFlagRecord = $08; If set record information is recorded for this file
cdfsFileFlagProtection = $10; If set permissions are recorded for this file
cdfsFileFlagReserved1 = $20; Reserved
cdfsFileFlagReserved2 = $40; Reserved
cdfsFileFlagMore = $80; If set there are more directory records for this file


CDFS permissions cdfsPermission*
cdfsPermissionSystemRead = $0001; If set system cannot Read
cdfsPermissionSystemWrite = $0002; If set system cannot Write
cdfsPermissionSystemExecute = $0004; If set system cannot Execute
cdfsPermissionReserved1 = $0008; Reserved
cdfsPermissionOwnerRead = $0010; If set owner cannot Read
cdfsPermissionOwnerWrite = $0020; If set owner cannot Write
cdfsPermissionOwnerExecute = $0040; If set owner cannot Execute
cdfsPermissionReserved2 = $0080; Reserved
cdfsPermissionGroupRead = $0100; If set group cannot Read
cdfsPermissionGroupWrite = $0200; If set group cannot Write
cdfsPermissionGroupExecute = $0400; If set group cannot Execute
cdfsPermissionReserved3 = $0800; Reserved
cdfsPermissionOtherRead = $1000; If set other cannot Read
cdfsPermissionOtherWrite = $2000; If set other cannot Write
cdfsPermissionOtherExecute = $4000; If set other cannot Execute
cdfsPermissionReserved4 = $8000; Reserved


CDFS path table cdfsPathTable*
cdfsPathTableTypePrimary = $00;  
cdfsPathTableTypeAlternate = $01;  
cdfsPathTableTypePrimaryM = $02;  
cdfsPathTableTypeAlternateM = $03;  


CDFS volume descriptor cdfsVolumeDescriptor*
cdfsVolumeDescriptorTypeBoot = $00;  
cdfsVolumeDescriptorTypePrimary = $01;  
cdfsVolumeDescriptorTypeSupplementary = $02;  
cdfsVolumeDescriptorTypePartition = $03;  
cdfsVolumeDescriptorTypeTerminator = $FF;  


CDFS header cdfsElTorito*
cdfsElToritoHeaderId = $01;  
cdfsElToritoBootIndicator = $88;  
cdfsElToritoNoBootIndicator = $00;  
cdfsElToritoHeaderIndicator = $90; 91 if final header
cdfsElToritoHeaderTerminator = $91;  
cdfsElToritoExtensionIndicator = $44;  


CDFS signature cdfsElToritoSignature*
cdfsElToritoSignature = $AA55;  


CDFS platform Id cdfsElToritoPlatform*
cdfsElToritoPlatformIdx86 = $00;  
cdfsElToritoPlatformIdPPC = $01;  
cdfsElToritoPlatformIdMac = $02;  


CDFS media type cdfsElToritoMedia*
cdfsElToritoMediaTypeNone = $00; No Emulation
cdfsElToritoMediaType12M = $01; 1.2 meg diskette
cdfsElToritoMediaType144M = $02; 1.44 meg diskette
cdfsElToritoMediaType288M = $03; 2.88 meg diskette
cdfsElToritoMediaTypeHDD = $04; Hard Disk (drive 80)
cdfsElToritoMediaTypeMask = $0F; Values 5-F Reserved, invalid at this time
 
cdfsElToritoMediaFlagReserved = $10; Reserved, must be 0
cdfsElToritoMediaFlagContinuation = $20; Continuation Entry Follows
cdfsElToritoMediaFlagAtapi = $40; Image contains ATAPI driver
cdfsElToritoMediaFlagScsi = $80; Image contains SCSI drivers
cdfsElToritoMediaFlagMask = $F0;  


CDFS extension flag cdfsElToritoExtensionFlag*
cdfsElToritoExtensionFlagExtension = $20; Extension Record Follows


Type definitions


CDFS specific types

TCDFSType = (ctNONE,ctISO9660,ctJOLIET,ctSIERRA,ctROCKRIDGE,ctAUDIO,ctUDF);

CDFS time

PCDFSTime = ^TCDFSTime;

TCDFSTime = packed record

Note: 7 Bytes
Years:Byte; Number of years since 1900
Month:Byte; Month of the year from 1 to 12
Day:Byte; Day of the month from 1 to 31
Hour:Byte; Hour of the day from 0 to 23
Minute:Byte; Minute of the hour from 0 to 59
Second:Byte; Second of the minute from 0 to 59
Offset:ShortInt; Offset from Greenwich Mean Time in number of 15 min intervals from -48 (West) to +52 (East)

CDFS date time

PCDFSDateTime = ^TCDFSDateTime;

TCDFSDateTime = packed record

Note: 17 Bytes
Year:array[0..3] of Char; Year from 1 to 9999
Month:array[0..1] of Char; Month of the year from 1 to 12
Day:array[0..1] of Char; Day of the month from 1 to 31
Hour:array[0..1] of Char; Hour of the day from 0 to 23
Minute:array[0..1] of Char; Minute of the hour from 0 to 59
Second:array[0..1] of Char; Second of the minute from 0 to 59
Hundredths:array[0..1] of Char; Hundredths of a second
Offset:ShortInt; Offset from Greenwich Mean Time in number of 15 min intervals from -48 (West) to +52 (East)

CDFS directory record

PCDFSDirectoryRecord = ^TCDFSDirectoryRecord;

TCDFSDirectoryRecord = packed record

Note: 34 Bytes (Minimum not including padding)
RecordSize:Byte; Length of Directory Record (LEN-DR)
ExtendedSize:Byte; Extended Attribute Record Length
FirstBlock:LongWord; Location of Extent
FirstBlockM:LongWord;  
DataSize:LongWord; Data Length
DataSizeM:LongWord;  
CreateTime:TCDFSTime; Recording Date and Time
FileFlags:Byte; File Flags 8 bits
UnitSize:Byte; File Unit Size
InterleaveSize:Byte; Interleave Gap Size
SequenceNumber:Word; Volume Sequence Number
SequenceNumberM:Word;  
FileIdentifierSize:Byte; Length of File Identifier (LEN_FI)
FileIdentifier:array[0..0] of Char; File Identifier d-characters,d1-characters,SEPARATOR 1,SEPARATOR 2,(00) or (01) byte
Padding:Byte; Padding Field (00) byte (Only present if FileIdentifierSize is even (Total size would be odd))
SystemData:array[0..0] of Byte; System Use LEN_SU bytes

CDFS path record

PCDFSPathRecord = ^TCDFSPathRecord;

TCDFSPathRecord = packed record

Note: 9 Bytes (Minimum not including padding)
PathIdentifierSize:Byte; Length of Directory Identifier (LEN_DI)
ExtendedSize:Byte; Extended Attribute Record Length
FirstBlock:LongWord; Location of Extent
ParentNumber:Word; Parent Directory Number
PathIdentifier:array[0..0] of Char; Directory Identifier d-characters, d1-characters, (00) byte
Padding:Byte; Padding Field (00) byte (Only present if PathIdentifierSize is odd (Total size would be odd))

CDFS extended record

PCDFSExtendedRecord = ^TCDFSExtendedRecord;

TCDFSExtendedRecord = packed record

Note: 250 Bytes (Minimum)
OwnerId:Word; Owner Identification
OwnerIdM:Word;  
GroupId:Word; Group Identification
GroupIdM:Word;  
Permissions:Word; Permissions 16 bits
CreateTime:TCDFSDateTime; File Creation Date and Time
ModifyTime:TCDFSDateTime; File Modification Date and Time
ExpireTime:TCDFSDateTime; File Expiration Date and Time
EffectiveTime:TCDFSDateTime; File Effective Date and Time
RecordFormat:Byte; Record Format
RecordAttributes:Byte; Record Attributes
RecordLength:Word; Record Length
RecordLengthM:Word;  
SystemIdentifier:array[0..31] of Char; System Identifier a-characters, a1-characters
SystemData:array[0..63] of Byte; System Use not specified
ExtendedVersion:Byte; Extended Attribute Record Version
EscapeSequenceSize:Byte; Length of Escape Sequences (LEN_ESC)
Reserved1:array[0..63] of Byte; Reserved for future standardization (00) bytes
ApplicationDataSize:Word; Length of Application Use (LEN_AU)
ApplicationDataSizeM:Word;  
ApplicationData:array[0..0] of Byte; Application Use LEN_AU bytes
EscapeSequence:array[0..0] of Byte; Escape Sequences LEN_ESC bytes

CDFS volume descriptor header

PCDFSVolumeDescriptorHeader = ^TCDFSVolumeDescriptorHeader;

TCDFSVolumeDescriptorHeader = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type 00 = Boot, 01 = Primary etc
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
Reserved:array[0..2040] of Byte; Content depends on Descriptor Type

CDFS volume descriptor boot

PCDFSVolumeDescriptorBoot = ^TCDFSVolumeDescriptorBoot;

TCDFSVolumeDescriptorBoot = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type (00 = Boot)
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
SystemIdentifier:array[0..31] of Char; 32 a-characters (eg EL TORITO SPECIFICATION)
BootIdentifier:array[0..31] of Char; 32 a-characters
BootData:array[0..1976] of Byte;  

CDFS volume descriptor primary

PCDFSVolumeDescriptorPrimary = ^TCDFSVolumeDescriptorPrimary;

TCDFSVolumeDescriptorPrimary = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type (01 = Primary)
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
Reserved1:Byte; Unused Field (00) byte
SystemIdentifier:array[0..31] of Char; System Identifier a-characters
VolumeIdentifier:array[0..31] of Char; Volume Identifier d-characters
Reserved2:array[0..7] of Byte; Unused Field (00) bytes
VolumeSpaceSize:LongWord; Volume Space Size
VolumeSpaceSizeM:LongWord;  
Reserved3:array[0..31] of Byte; Unused Field (00) bytes
VolumeSetSize:Word; Volume Set Size
VolumeSetSizeM:Word;  
VolumeSequenceNumber:Word; Volume Sequence Number
VolumeSequenceNumberM:Word;  
LogicalBlockSize:Word; Logical Block Size
LogicalBlockSizeM:Word;  
PathTableSize:LongWord; Path Table Size
PathTableSizeM:LongWord;  
PrimaryPathTable:LongWord; Location of Occurrence of Type L Path Table
AlternatePathTable:LongWord; Location of Optional Occurrence of Type L Path Table
PrimaryPathTableM:LongWord; Location of Occurrence of Type M Path Table
AlternatePathTableM:LongWord; Location of Optional Occurrence of Type M Path Table
RootDirectory:TCDFSDirectoryRecord; Directory Record for Root Directory 34 bytes
VolumeSetIdentifier:array[0..127] of Char; Volume Set Identifier d-characters
PublisherIdentifier:array[0..127] of Char; Publisher Identifier a-characters
PreparerIdentifier:array[0..127] of Char; Data Preparer Identifier a-characters
ApplicationIdentifier:array[0..127] of Char; Application Identifier a-characters
CopyrightIdentifier:array[0..36] of Char; Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
AbstractIdentifier:array[0..36] of Char; Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
BibliographicIdentifier:array[0..36] of Char; Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
CreateTime:TCDFSDateTime; Volume Creation Date and Time
ModifyTime:TCDFSDateTime; Volume Modification Date and Time
ExpireTime:TCDFSDateTime; Volume Expiration Date and Time
EffectiveTime:TCDFSDateTime; Volume Effective Date and Time
FileStructureVersion:Byte; File Structure Version
Reserved4:Byte; Reserved for future standardization (00) byte
ApplicationData:array[0..511] of Byte; Application Use not specified
Reserved5:array[0..652] of Byte; Reserved for future standardization (00) bytes

CDFS volume descriptor supplementary

PCDFSVolumeDescriptorSupplementary = ^TCDFSVolumeDescriptorSupplementary;

TCDFSVolumeDescriptorSupplementary = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type (02 = Supplementary)
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
VolumeFlags:Byte; Volume Flags 8 bits
SystemIdentifier:array[0..31] of Char; System Identifier a-characters
VolumeIdentifier:array[0..31] of Char; Volume Identifier d-characters
Reserved2:array[0..7] of Byte; Unused Field (00) bytes
VolumeSpaceSize:LongWord; Volume Space Size
VolumeSpaceSizeM:LongWord;  
EscapeSequences:array[0..31] of Byte; Escape Sequences 32 bytes
VolumeSetSize:Word; Volume Set Size
VolumeSetSizeM:Word;  
VolumeSequenceNumber:Word; Volume Sequence Number
VolumeSequenceNumberM:Word;  
LogicalBlockSize:Word; Logical Block Size
LogicalBlockSizeM:Word;  
PathTableSize:LongWord; Path Table Size
PathTableSizeM:LongWord;  
PrimaryPathTable:LongWord; Location of Occurrence of Type L Path Table
AlternatePathTable:LongWord; Location of Optional Occurrence of Type L Path Table
PrimaryPathTableM:LongWord; Location of Occurrence of Type M Path Table
AlternatePathTableM:LongWord; Location of Optional Occurrence of Type M Path Table
RootDirectory:TCDFSDirectoryRecord; Directory Record for Root Directory 34 bytes
VolumeSetIdentifier:array[0..127] of Char; Volume Set Identifier d-characters
PublisherIdentifier:array[0..127] of Char; Publisher Identifier a-characters
PreparerIdentifier:array[0..127] of Char; Data Preparer Identifier a-characters
ApplicationIdentifier:array[0..127] of Char; Application Identifier a-characters
CopyrightIdentifier:array[0..36] of Char; Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
AbstractIdentifier:array[0..36] of Char; Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
BibliographicIdentifier:array[0..36] of Char; Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
CreateTime:TCDFSDateTime; Volume Creation Date and Time
ModifyTime:TCDFSDateTime; Volume Modification Date and Time
ExpireTime:TCDFSDateTime; Volume Expiration Date and Time
EffectiveTime:TCDFSDateTime; Volume Effective Date and Time
FileStructureVersion:Byte; File Structure Version
Reserved4:Byte; Reserved for future standardization (00) byte
ApplicationData:array[0..511] of Byte; Application Use not specified
Reserved5:array[0..652] of Byte; Reserved for future standardization (00) bytes

CDFS volume descriptor partition

PCDFSVolumeDescriptorPartition = ^TCDFSVolumeDescriptorPartition;

TCDFSVolumeDescriptorPartition = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type (03 = Partition)
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
Reserved1:Byte; Unused Field (00) byte
SystemIdentifier:array[0..31] of Char; System Identifier a-characters
PartitionIdentifier:array[0..31] of Char; Volume Partition Identifier d-characters
PartitionStart:LongWord; Volume Partition Location (first Logical Block)
PartitionStartM:LongWord;  
PartitionSize:LongWord; Volume Partition Size (in Logical Blocks)
PartitionSizeM:LongWord;  
SystemData:array[0..1959] of Byte; System Use not specified

CDFS volume descriptor terminator

PCDFSVolumeDescriptorTerminator = ^TCDFSVolumeDescriptorTerminator;

TCDFSVolumeDescriptorTerminator = packed record

Note: 2048 Bytes
DescriptorType:Byte; Descriptor Type (FF = Terminator)
StandardIdentifier:array[0..4] of Char; Standard Identifier ('CD001')
DescriptorVersion:Byte; Descriptor Version (1)
Reserved:array[0..2040] of Byte; Reserved (Always 00)

EL TORITO validation record

PELTORITOValidationRecord = ^TELTORITOValidationRecord;

TELTORITOValidationRecord = packed record

Note: 32 Bytes
HeaderId:Byte; Header ID, must be 01
PlatformId:Byte; Platform ID 0 = 80x86, 1 = PowerPC, 2 = Mac
Reserved1:Word; Reserved, must be 0
VendorId:array[0..23] of Char; ID string. This is intended to identify the manufacturer/developer of the CD-ROM
Checksum:Word; Checksum Word. This sum of all the words in this record should be 0
Signature:Word; Key byte, must be 55. Key byte, must be AA. This value is included in the checksum

EL TORITO default record

PELTORITODefaultRecord = ^TELTORITODefaultRecord;

TELTORITODefaultRecord = packed record

Note: 32 Bytes
BootIndicator:Byte; Boot Indicator. 88 = Bootable, 00 = Not Bootable
BootMedia:Byte; Boot media type. This specifies what media the boot image is intended to emulate
LoadSegment:Word; This is the load segment for the initial boot image. If this value is 0 the system will use the traditional segment of 7C0
SystemType:Byte; This must be a copy of byte 5 (System Type) from the Partition Table found in the boot image (PartitionId)
Reserved1:Byte; Unused, must be 0
LoadCount:Word; Sector Count. This is the number of virtual/emulated sectors the system will store at Load Segment during the initial boot procedure
LoadRBA:LongWord; Load RBA. This is the start address of the virtual disk. CDs use Relative/Logical block addressing
Reserved2:array[0..19] of Byte; {Unused, must be 0}  

EL TORITO section header

PELTORITOSectionHeader = ^TELTORITOSectionHeader;

TELTORITOSectionHeader = packed record

Note: 32 Bytes
HeaderIndicator:Byte; Header Indicator, 90 - Header, more headers follow, 91 - Final Header
PlatformId:Byte; Platform ID 0 = 80x86, 1 = PowerPC, 2 = Mac
SectionCount:Word; Number of section entries following this header
SectionId:array[0..27] of Char; ID string. This identifies a section

EL TORITO section record

PELTORITOSectionRecord = ^TELTORITOSectionRecord;

TELTORITOSectionRecord = packed record

Note: 32 Bytes
BootIndicator:Byte; Boot Indicator. 88 = Bootable, 00 = Not Bootable
BootMedia:Byte; Boot media type. This specifies what media the boot image emulates
LoadSegment:Word; Load Segment. This is the load segment for the initial boot image. If this value is 0 the system will use the traditional segment of 7C0
SystemType:Byte; System Type. This must be a copy of byte 5 (System Type) from the Partition Table found in the boot image (PartitionId)
Reserved1:Byte; Unused, must be 0
LoadCount:Word; Sector Count. This is the number of virtual/emulated sectors the system will store at Load Segment during the initial boot procedure
LoadRBA:LongWord; Load RBA. This is the start address of the virtual disk. CDs use Relative/Logical block addressing
SelectionType:Byte; Selection criteria type. 0 - No selection criteria, 1- Language and Version Information (IBM), 2-FF - Reserved
SelectionData:array[0..18] of Byte; Vendor unique selection criteria

EL TORITO section extension

PELTORITOSectionExtension = ^TELTORITOSectionExtension;

TELTORITOSectionExtension = packed record

Note: 32 Bytes
ExtensionIndicator:Byte; Extension Indicator. Must be 44
ExtensionFlag:Byte; Bits 1-4 - Unused, Bit 5 (1 = Extension Record follows, 0 = This is final Extension), Bits 6-7 - Unused
SelectionData:array[0..29] of Byte; Vendor unique selection criteria

EL TORITO volume descriptor boot

PELTORITOVolumeDescriptorBoot = ^TELTORITOVolumeDescriptorBoot;

TELTORITOVolumeDescriptorBoot = packed record

Note: 2048 Bytes
DescriptorType:Byte; Boot Record Indicator, must be 0
StandardIdentifier:array[0..4] of Char; ISO-9660 Identifier, must be 'CD001'
DescriptorVersion:Byte; Version of this descriptor, must be 1
SystemIdentifier:array[0..31] of Char; Boot System Identifier, must be 'EL TORITO SPECIFICATION' padded with 0s
Reserved1:array[0..31] of Byte; Unused, must be 0
CatalogStart:LongWord; Absolute pointer to first sector of Boot Catalog
Reserved2:array[0..1972] of Byte; Unused, must be 0


Class definitions


CDFS recognizer

TCDFSRecognizer = class(TRecognizer)

constructor Create(ADriver:TFileSysDriver);  
private
FLongNames:Boolean;  
FSwapSerial:Boolean;  
 
function CheckPrimaryDescriptor(ASector:PSector; const AStartSector:Int64; ASectorCount:LongWord):Boolean;  
protected
function GetName:String; override;  
public
property LongNames:Boolean read FLongNames write FLongNames;  
property SwapSerial:Boolean read FSwapSerial write FSwapSerial;  
 
function RecognizePartitionId(APartitionId:Byte):Boolean; override;  
function RecognizeBootSector(ABootSector:PBootSector; const AStartSector,ASectorCount:Int64):Boolean; override;  
 
function RecognizePartition(APartition:TDiskPartition):Boolean; override;  
function RecognizeVolume(AVolume:TDiskVolume):Boolean; override;  
function MountVolume(AVolume:TDiskVolume; ADrive:TDiskDrive):Boolean; override;  

CDFS formatter

TCDFSFormatter = class(TDiskFormatter)

private
function CheckDevice(AVolume:TDiskVolume; ADrive:TDiskDrive; AFloppyType:TFloppyType):Boolean;  
function CheckPartition(AVolume:TDiskVolume; ADrive:TDiskDrive; AFileSysType:TFileSysType):Boolean;  
 
function GetPathTableSize(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;  
function GetPathTableStart(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary,AEndian:Boolean):LongWord;  
 
function GetRootDirectorySize(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;  
function GetRootDirectoryStart(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ASupplementary:Boolean):LongWord;  
 
function CreatePrimaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;  
function WritePrimaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;  
function WritePrimaryPathTables(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;  
function WritePrimaryRootDirectory(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorPrimary):Boolean;  
 
function CreateSupplementaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;  
function WriteSupplementaryDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;  
function WriteSupplementaryPathTables(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;  
function WriteSupplementaryRootDirectory(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorSupplementary):Boolean;  
 
function CreateTerminatorDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorTerminator):Boolean;  
function WriteTerminatorDescriptor(AVolume:TDiskVolume; ADrive:TDiskDrive; ACDFSType:TCDFSType; ADescriptor:PCDFSVolumeDescriptorTerminator):Boolean;  
public
function AcceptVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; override;  
function FormatVolume(AVolume:TDiskVolume; AFloppyType:TFloppyType; AFileSysType:TFileSysType):Boolean; override;  

CDFS resizer

TCDFSResizer = class(TDiskResizer)

public
function AcceptVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;  
 
function ShrinkVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;  
function ExpandVolume(AVolume:TDiskVolume; const AStart,ASize:Int64):Boolean; override;  

CDFS copier

TCDFSCopier = class(TDiskCopier)

public
function AcceptVolume(AVolume,ADest:TDiskVolume):Boolean; override;  
 
function CopyVolume(AVolume,ADest:TDiskVolume):Boolean; override;  

CDFS file system

TCDFSFileSystem = class(TFileSystem)

constructor Create(ADriver:TFileSysDriver; AVolume:TDiskVolume; ADrive:TDiskDrive);  
destructor Destroy; override;  
private
FCDFSType:TCDFSType;  
FSwapSerial:Boolean;  
FVolumeFlags:LongWord; Volume flags
 
FTreesLoaded:Boolean;  
FBlocksLoaded:Boolean;  
FCatalogsLoaded:Boolean;  
FCatalogsLoading:Boolean;  
 
FBlockWrite:Boolean;  
FTreesPrepared:Boolean;  
FCatalogsChecked:Boolean;  
 
FLogicalBlockSize:Word; Size of a logical block on disk
FLogicalBlockCount:LongWord; Number of logical blocks on disk
 
FSectorsPerCluster:LongWord; Usually 1,2,4,8,16,32,64,128 etc
 
FDataStartCluster:LongWord; Usually 16 (First cluster of Data Area)
FBootStartCluster:LongWord; Usually 17 (Cluster of the Boot Descriptor)
FRootStartCluster:LongWord; Pointed to by Primary Descriptor
 
FBlockShiftCount:Word; Shift count for Cluster <-> BlockNo
FSectorShiftCount:Word; Shift count for Sector <-> Cluster
FClusterShiftCount:Word; Shift count for Cluster <-> Bytes
 
FEntriesPerBlock:LongWord; Number of Cluster entries per Block of bitmap
FClustersPerBlock:LongWord; Number of Clusters per Block of bitmap entries
FTotalBlockCount:LongWord; Total number of Blocks in bitmap
 
FTotalClusterCount:LongWord; Total number of Clusters on volume
 
FLastFreeCluster:LongWord; Or cdfsUnknownCluster if not known
FFreeClusterCount:LongWord; Or cdfsUnknownCluster if not known
 
FClusterSize:LongWord; Size of a Cluster in Bytes (Max 65536 > Word)
 
FBoot:TCDFSDiskDescriptor;  
FPrimary:TCDFSDiskDescriptor;  
FSupplementary:TCDFSDiskDescriptor;  
 
FHeaders:TFileSysList; List of Catalog Headers
FExtensions:TFileSysList; List of Catalog Extensions
FDescriptors:TFileSysList; List of Volume Descriptors
 
FHeaderLocal:TMutexHandle; Local Lock shared by all Catalog Headers
FExtensionLocal:TMutexHandle; Local Lock shared by all Catalog Extensions
FDescriptorLocal:TMutexHandle; Local Lock shared by all Volume Descriptors
 
FExtendedLocal:TMutexHandle; Local Lock shared by all Extended Attributes
 
FPathLock:TSynchronizerHandle; Lock shared by all Path lists
 
FReadBuffer:Pointer; Buffer for partial cluster entry reads (Cluster size)
FReadLock:TMutexHandle; Lock for read buffer
 
FWriteBuffer:Pointer; Buffer for partial cluster entry writes (Cluster size)
FWriteLock:TMutexHandle; Lock for write buffer
 
FClusterBuffer:Pointer; Buffer of exactly cluster size
FClusterLock:TMutexHandle; Lock for cluster buffer
 
function ReadLock:Boolean;  
function ReadUnlock:Boolean;  
 
function WriteLock:Boolean;  
function WriteUnlock:Boolean;  
 
function ClusterLock:Boolean;  
function ClusterUnlock:Boolean;  
 
function LoadTree(AEntry:TDiskEntry):Boolean;  
function MarkTree(AEntry:TDiskEntry):Boolean;  
function PrepareTree(AEntry:TDiskEntry):Boolean;  
function PrepareTable(ATable:TDiskTable):Boolean;  
 
function PrepareTrees:Boolean;  
function CheckCatalogs:Boolean;  
 
function LocatePath(ATable:TCDFSDiskTable; APathNumber:Word):TCDFSDiskPath;  
function LocateEntry(AEntry:TCDFSDiskEntry; AStartCluster:LongWord):TCDFSDiskEntry;  
 
function LoadVolumeFlags:LongWord;  
 
function FillClusters(ACluster:LongWord; ACount:Word; AValue:Byte):Boolean;  
 
function ReadClusters(ACluster:LongWord; ACount:Word; var ABuffer):Boolean;  
function WriteClusters(ACluster:LongWord; ACount:Word; const ABuffer):Boolean;  
 
function TestClusters(ACluster,ACount:LongWord):Boolean;  
function MarkClusters(ACluster,ACount:LongWord; AUsed:Boolean):Boolean;  
 
function AllocClusters(var ACluster:LongWord; ACount:LongWord):Boolean;  
function ReleaseClusters(ACluster,ACount:LongWord):Boolean;  
 
function GetNextFreeCluster:LongWord; Return is a Cluster
function GetFreeClusterCount:LongWord;  
 
function TestBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;  
function MarkBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord; AUsed:Boolean):Boolean;  
 
function AllocBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;  
function ReleaseBlock(ABlock:TCDFSDiskBlock; AStart,ACount:LongWord):Boolean;  
 
function GetBlockNextFree(ABlock:TCDFSDiskBlock; AStart:LongWord):LongWord;  
function GetBlockFreeCount(ABlock:TCDFSDiskBlock):LongWord;  
 
function TestBitmap(ABuffer:Pointer; ASize,AStart,ACount:LongWord):Boolean;  
function MarkBitmap(ABuffer:Pointer; ASize,AStart,ACount:LongWord; AUsed:Boolean):Boolean;  
 
function AllocBitmap(ABuffer:Pointer; ASize:LongWord; AStart,ACount:LongWord):Boolean;  
function ReleaseBitmap(ABuffer:Pointer; ASize:LongWord; AStart,ACount:LongWord):Boolean;  
 
function GetBitmapNextFree(ABuffer:Pointer; ASize,AStart:LongWord):LongWord;  
function GetBitmapFreeCount(ABuffer:Pointer; ASize:LongWord):LongWord;  
 
function GetTableDataFree(ATable:TDiskTable):LongWord;  
function GetEntryDataFree(AEntry:TDiskEntry):LongWord;  
function GetCatalogDataFree(ADescriptor:TCDFSDiskDescriptor):LongWord;  
 
function GetPreviousPath(ATable:TCDFSDiskTable; APath:TCDFSDiskPath):TCDFSDiskPath;  
function GetPreviousEntry(AParent,AEntry:TCDFSDiskEntry):TCDFSDiskEntry;  
 
function GetSectorsPerCluster(AClusterSize:LongWord):LongWord;  
function GetBlockShiftCount(AClusterSize:LongWord):Word;  
function GetSectorShiftCount(AClusterSize:LongWord):Word;  
function GetClusterShiftCount(AClusterSize:LongWord):Word;  
 
function GetEntriesPerBlock(AClusterSize:LongWord):LongWord;  
function GetClustersPerBlock(AClusterSize:LongWord):LongWord;  
function GetTotalBlockCount(ATotalClusterCount:LongWord):LongWord;  
 
function RenumberPaths(ATable:TDiskTable):Boolean;  
 
function ComparePath(APath1,APath2:TCDFSDiskPath; AUnicode:Boolean):Integer;  
function CompareEntry(AEntry1,AEntry2:TCDFSDiskEntry; AUnicode:Boolean):Integer;  
 
function PadString(const AString:String; ALength:Integer; APrefix,AUnicode:Boolean):String;  
function CompareString(const AString1,AString2:String; AReverse:Boolean):Integer;  
 
function ChecksumValidationRecord(AValidation:PELTORITOValidationRecord):Word;  
 
function RecordToPath(ARecord:Pointer; APath:TCDFSDiskPath; AUnicode,AEndian:Boolean):Boolean;  
function PathToRecord(APath:TCDFSDiskPath; ARecord:Pointer; AUnicode,AEndian:Boolean):Boolean;  
 
function RecordToEntry(ARecord:Pointer; AEntry:TCDFSDiskEntry; AUnicode:Boolean):Boolean;  
function EntryToRecord(AEntry:TCDFSDiskEntry; ARecord:Pointer; AUnicode:Boolean):Boolean;  
 
function CDFSTypeToFileSysType(ACDFSType:TCDFSType):TFileSysType;  
protected
function LoadMaxFile:Integer; override;  
function LoadMaxPath:Integer; override;  
function LoadAttributes:LongWord; override;  
function LoadSystemName:String; override;  
function LoadVolumeName:String; override;  
function LoadVolumeSerial:LongWord; override;  
function LoadFileSysType:TFileSysType; override;  
 
function SetVolumeName(const AName:String):Boolean;  
function SetVolumeSerial(ASerial:LongWord):Boolean;  
 
function ReadEntry(AParent,AEntry:TDiskEntry; var ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; override;  
function WriteEntry(AParent,AEntry:TDiskEntry; const ABuffer; const AStart:Int64; ACount:LongWord; var AOffset,AValue:LongWord):Integer; override;  
 
function LoadTrees:Boolean; Not override
function LoadTables:Boolean; override;  
function LoadBlocks:Boolean; override;  
function LoadDescriptors:Boolean; Not override
function LoadRoots:Boolean; Not override
function LoadPaths(ATable:TCDFSDiskTable):Boolean; Not override
function LoadEntries(AParent:TDiskEntry):Boolean; override;  
function LoadCatalogs:Boolean; override;  
 
function SetPaths(ATable:TCDFSDiskTable):Boolean; Not override
function SetEntries(AParent:TDiskEntry):Boolean; Not override
function SetCatalogs:Boolean; Not override
 
function LoadTable(ATableNo:LongWord):Boolean; override;  
function LoadBlock(ABlockNo:LongWord):Boolean; override;  
function LoadDescriptor(ABuffer:Pointer; ACluster:LongWord):Boolean; Not override
function LoadRoot(ADescriptor:TCDFSDiskDescriptor):Boolean; Not override
function LoadPath(ATable:TCDFSDiskTable; ABuffer:Pointer; AOffset:LongWord; ANumber:Word):Boolean; Not override
function LoadEntry(AParent:TCDFSDiskEntry; ABuffer:Pointer; AOffset,ACluster:LongWord):Boolean; Not override
function LoadHeader(ABuffer:Pointer; AOffset,ACluster:LongWord; AHeaderNo:LongWord):Boolean; Not override
function LoadCatalog(ABuffer:Pointer; AOffset,ACluster:LongWord; ACatalogNo:LongWord; AInitial:Boolean):Boolean; Not override
function LoadExtension(ABuffer:Pointer; AOffset,ACluster:LongWord; AExtensionNo:LongWord):Boolean; Not override
function LoadExtended(AEntry:TDiskEntry):Boolean; Not override
 
function AddDescriptor(AType:Byte):TCDFSDiskDescriptor; Not override
function RemoveDescriptor(ADescriptor:TCDFSDiskDescriptor):Boolean; Not override
 
function AddPath(ATable:TDiskTable; AParentNumber:Word; const AName:String; AStartCluster:LongWord):TCDFSDiskPath; Not override
function RemovePath(ATable:TDiskTable; APath:TCDFSDiskPath):Boolean; Not override
function RenamePath(ATable:TDiskTable; APath:TCDFSDiskPath; const AName:String):Boolean; Not override
function MovePath(ATable:TDiskTable; ADestNumber:Word; APath:TCDFSDiskPath):Boolean; Not override
 
function AddEntry(AParent:TDiskEntry; const AName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; override;  
function AddEntryEx(AParent:TDiskEntry; const AName,AAltName:String; AAttributes:LongWord; AReference:Boolean):TDiskEntry; override;  
function RemoveEntry(AParent,AEntry:TDiskEntry):Boolean; override;  
function RenameEntry(AParent,AEntry:TDiskEntry; const AName:String):Boolean; override;  
function RenameEntryEx(AParent,AEntry:TDiskEntry; const AAltName:String):Boolean; override;  
function MoveEntry(ASource,ADest,AEntry:TDiskEntry):Boolean; override;  
 
function AddCatalog(AEntry:TDiskEntry; AMediaType:TMediaType; AFloppyType:TFloppyType; AAttributes:LongWord; ASectorSize:Word; const ASectorCount:Int64):TDiskCatalog; override;  
function RemoveCatalog(ACatalog:TDiskCatalog):Boolean; override;  
function GetNextHeaderNo:LongWord; Not override
function GetMaxHeaderNo:LongWord; Not override
function GetNextHeaderOffset:LongWord; Not override
function GetNextHeaderCluster:LongWord; Not override
function GetNextCatalogOffset:LongWord; Not override
function GetNextCatalogCluster:LongWord; Not override
 
function SetTable(ATable:TDiskTable):Boolean; override;  
function SetBlock(ABlock:TDiskBlock):Boolean; override;  
function SetDescriptor(ADescriptor:TCDFSDiskDescriptor):Boolean; Not override
function SetRoot(ADescriptor:TCDFSDiskDescriptor; ARoot:TDiskEntry):Boolean; Not override
function SetPath(ATable:TDiskTable; APath:TCDFSDiskPath; ABuffer:Pointer):Boolean; Not override
function SetEntry(AParent,AEntry:TDiskEntry):Boolean; override;  
function SetHeader(AHeader:TCDFSDiskHeader):Boolean; Not override
function SetCatalog(ACatalog:TDiskCatalog):Boolean; override;  
function SetExtension(AExtension:TCDFSDiskExtension):Boolean; Not override
function SetExtended(AEntry:TDiskEntry; AExtended:TCDFSDiskExtended):Boolean; Not override
 
function SizeEntry(AParent,AEntry:TDiskEntry; const ASize:Int64):Boolean; override;  
 
function GetBlock(ABlockNo:LongWord):TDiskBlock; override;  
function GetBlockEx(ABlockNo:LongWord; AWrite:Boolean):TDiskBlock; override;  
function GetDescriptor(AType,AInstance:Byte):TCDFSDiskDescriptor; Not override
function GetDescriptorEx(AType,AInstance:Byte; AWrite:Boolean):TCDFSDiskDescriptor; Not override
function GetRoot(ADescriptor:TCDFSDiskDescriptor):TDiskEntry; Not override
function GetPath(ATable:TDiskTable; AParentNumber:Word; const AName:String):TCDFSDiskPath; Not override
function GetHeader(AHeaderNo:LongWord):TCDFSDiskHeader; Not override
function GetHeaderEx(AHeaderNo:LongWord; AWrite:Boolean):TCDFSDiskHeader; Not override
function GetExtension(AExtensionNo:LongWord):TCDFSDiskExtension; Not override
function GetExtensionEx(AExtensionNo:LongWord; AWrite:Boolean):TCDFSDiskExtension; Not override
function GetExtended(AEntry:TDiskEntry):TCDFSDiskExtended; Not override
 
function GetVersion(const AName:String):String;  
 
function StripDot(const AName:String):String;  
function StripVersion(const AName:String):String;  
 
function CompareName(const AName,AMatch:String; AWildcard:Boolean):Boolean; override;  
function CompareSequence(const ASequence; const ACompare; ASize:Integer):Boolean;  
function CompareIdentifier(const AIdentifier; const ACompare; ASize:Integer):Boolean;  
 
function CalculateVolumeSerial(ABuffer:Pointer; ASize:Integer):LongWord;  
public
property ReadOnly:Boolean read FReadOnly write FReadOnly;  
property LongNames:Boolean read FLongNames write FLongNames;  
property CasePreserved:Boolean read FCasePreserved write FCasePreserved;  
property UnicodeNames:Boolean read FUnicodeNames write FUnicodeNames;  
property SwapSerial:Boolean read FSwapSerial write FSwapSerial;  
 
function FileSystemInit:Boolean; override;  
 
function MountFileSystem:Boolean; override;  
function DismountFileSystem:Boolean; override;  
function InitializeFileSystem(ASectorsPerCluster:LongWord; AFileSysType:TFileSysType):Boolean; override;  
 
function GetDriveLabel:String; override;  
function SetDriveLabel(const ALabel:String):Boolean; override;  
function SetDriveSerial(ASerial:LongWord):Boolean; override;  
 
function GetDriveFreeSpaceEx:Int64; override;  
function GetDriveTotalSpaceEx:Int64; override;  
 
function GetDriveInformation(var AClusterSize:LongWord; var ATotalClusterCount,AFreeClusterCount:Int64):Boolean; override;  

CDFS disk table

TCDFSDiskTable = class(TDiskTable)

Note: Represents a CDFS path table.
 
constructor Create(ALock:TSynchronizerHandle; ALocalLock:TMutexHandle; ADescriptor:TCDFSDiskDescriptor);  
destructor Destroy; override;  
private
FTableType:Byte;  
FEndian:Boolean;  
FUnicode:Boolean;  
 
FPathsLoaded:Boolean;  
 
FStartCluster:LongWord;  
FClusterCount:LongWord;  
 
FDataFree:LongWord; Data Free
FDataSize:LongWord; Data Length
 
FPaths:TFileSysListEx;  
FPathLocal:TMutexHandle;  
 
FDescriptor:TCDFSDiskDescriptor;  
public
property TableType:Byte read FTableType write FTableType;  
property Endian:Boolean read FEndian write FEndian;  
property Unicode:Boolean read FUnicode write FUnicode;  
 
property PathsLoaded:Boolean read FPathsLoaded write FPathsLoaded;  
 
property StartCluster:LongWord read FStartCluster write FStartCluster;  
property ClusterCount:LongWord read FClusterCount write FClusterCount;  
 
property DataFree:LongWord read FDataFree write FDataFree;  
property DataSize:LongWord read FDataSize write FDataSize;  
 
property Paths:TFileSysListEx read FPaths;  
property PathLocal:TMutexHandle read FPathLocal;  
property Descriptor:TCDFSDiskDescriptor read FDescriptor;  

CDFS disk block

TCDFSDiskBlock = class(TDiskBlock)

Note: Represents a block of clusters.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FBlockCount:LongWord; Number of cluster entries in this block
FBlockBuffer:Pointer;  
FBlockCluster:LongWord; First cluster represented by this block
public
property BlockCount:LongWord read FBlockCount write FBlockCount;  
property BlockBuffer:Pointer read FBlockBuffer write FBlockBuffer;  
property BlockCluster:LongWord read FBlockCluster write FBlockCluster;  

CDFS disk entry

TCDFSDiskEntry = class(TDiskEntry)

Note: Represents a CDFS directory entry.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FUnicode:Boolean;  
FVersion:String;  
 
FEntryOffset:LongWord;  
FEntryCluster:LongWord;  
FStartCluster:LongWord;  
FClusterCount:LongWord;  
 
FRecordSize:Byte; Length of Directory Record (LEN-DR)
FExtendedSize:Byte; Extended Attribute Record Length
FDataSize:LongWord; Data Length
FUnitSize:Byte; File Unit Size
FInterleaveSize:Byte; Interleave Gap Size
FSequenceNumber:Word; Volume Sequence Number
 
FDataFree:LongWord; Data Free
 
FPath:TCDFSDiskPath;  
FPathM:TCDFSDiskPath;  
FAltPath:TCDFSDiskPath;  
FAltPathM:TCDFSDiskPath;  
FExtended:TCDFSDiskExtended;  
 
function GetVersion:String;  
procedure SetVersion(const AVersion:String);  
public
property Unicode:Boolean read FUnicode write FUnicode;  
property Version:String read GetVersion write SetVersion;  
 
property EntryOffset:LongWord read FEntryOffset write FEntryOffset;  
property EntryCluster:LongWord read FEntryCluster write FEntryCluster;  
property StartCluster:LongWord read FStartCluster write FStartCluster;  
property ClusterCount:LongWord read FClusterCount write FClusterCount;  
 
property RecordSize:Byte read FRecordSize write FRecordSize;  
property ExtendedSize:Byte read FExtendedSize write FExtendedSize;  
property DataSize:LongWord read FDataSize write FDataSize;  
property FirstBlock:LongWord read FStartCluster write FStartCluster;  
property UnitSize:Byte read FUnitSize write FUnitSize;  
property InterleaveSize:Byte read FInterleaveSize write FInterleaveSize;  
property SequenceNumber:Word read FSequenceNumber write FSequenceNumber;  
 
property DataFree:LongWord read FDataFree write FDataFree;  
 
property Path:TCDFSDiskPath read FPath write FPath;  
property PathM:TCDFSDiskPath read FPathM write FPathM;  
property AltPath:TCDFSDiskPath read FAltPath write FAltPath;  
property AltPathM:TCDFSDiskPath read FAltPathM write FAltPathM;  
property Extended:TCDFSDiskExtended read FExtended write FExtended;  
 
function PathNumber:Word;  
function ParentNumber:Word;  
 
function FileIdentifier:String;  
function FileIdentifierSize:Byte;  
function DirectoryRecordSize:Byte;  
function ExtendedRecordSize:Byte;  

CDFS disk catalog

TCDFSDiskCatalog = class(TDiskCatalog)

Note: Represents a CDFS boot catalog entry (Also the Initial/Default entry).
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FCatalogOffset:LongWord;  
FCatalogCluster:LongWord;  
FStartCluster:LongWord;  
FClusterCount:LongWord;  
 
FInitial:Boolean;  
FBootIndicator:Byte;  
FBootMedia:Byte;  
FLoadSegment:Word;  
FSystemType:Byte;  
FLoadCount:Word;  
 
FSelectionType:Byte;  
FSelectionData:Pointer;  
 
FEntry:TCDFSDiskEntry;  
FHeader:TCDFSDiskHeader;  
protected
function GetName:String; override;  
procedure SetName(const AName:String); override;  
function GetMediaType:TMediaType; override;  
procedure SetMediaType(AMediaType:TMediaType); override;  
function GetFloppyType:TFloppyType; override;  
procedure SetFloppyType(AFloppyType:TFloppyType); override;  
function GetAttributes:LongWord; override;  
procedure SetAttributes(AAttributes:LongWord); override;  
function GetSectorSize:Word; override;  
procedure SetSectorSize(ASectorSize:Word); override;  
function GetSectorCount:Int64; override;  
procedure SetSectorCount(const ASectorCount:Int64); override;  
 
function GetStartCluster:LongWord;  
procedure SetStartCluster(AStartCluster:LongWord);  
function GetClusterCount:LongWord;  
procedure SetClusterCount(AClusterCount:LongWord);  
public
property CatalogOffset:LongWord read FCatalogOffset write FCatalogOffset;  
property CatalogCluster:LongWord read FCatalogCluster write FCatalogCluster;  
property StartCluster:LongWord read GetStartCluster write SetStartCluster;  
property ClusterCount:LongWord read GetClusterCount write SetClusterCount;  
 
property Initial:Boolean read FInitial write FInitial;  
property BootIndicator:Byte read FBootIndicator write FBootIndicator;  
property BootMedia:Byte read FBootMedia write FBootMedia;  
property LoadSegment:Word read FLoadSegment write FLoadSegment;  
property SystemType:Byte read FSystemType write FSystemType;  
property LoadCount:Word read FLoadCount write FLoadCount;  
 
property SelectionType:Byte read FSelectionType write FSelectionType;  
property SelectionData:Pointer read FSelectionData write FSelectionData;  
 
property Entry:TCDFSDiskEntry read FEntry write FEntry;  
property Header:TCDFSDiskHeader read FHeader write FHeader;  
property Validation:TCDFSDiskHeader read FHeader write FHeader;  

CDFS disk path

TCDFSDiskPath = class(TListObject)

Note: Represents a CDFS path table entry.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FLocalLock:TMutexHandle;  
 
FName:String;  
FHash:LongWord;  
 
FPathNumber:Word;  
FPathOffset:LongWord;  
FStartCluster:LongWord;  
 
FExtendedSize:Byte; Extended Attribute Record Length
FParentNumber:Word; Parent Directory Number
 
FParent:TCDFSDiskPath;  
 
function AcquireLock:Boolean;  
function ReleaseLock:Boolean;  
 
function GetName:String;  
procedure SetName(const AName:String);  
public
property Name:String read GetName write SetName;  
property Hash:LongWord read FHash;  
 
property PathNumber:Word read FPathNumber write FPathNumber;  
property PathOffset:LongWord read FPathOffset write FPathOffset;  
property StartCluster:LongWord read FStartCluster write FStartCluster;  
 
property ExtendedSize:Byte read FExtendedSize write FExtendedSize;  
property FirstBlock:LongWord read FStartCluster write FStartCluster;  
property ParentNumber:Word read FParentNumber write FParentNumber;  
 
property Parent:TCDFSDiskPath read FParent write FParent;  
 
function PathIdentifier:String;  
function PathIdentifierSize(AUnicode:Boolean):Byte;  
function PathRecordSize(AUnicode:Boolean):Byte;  

CDFS disk extended

TCDFSDiskExtended = class(TObject)

Note: Represents a CDFS extended attribute.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FLocalLock:TMutexHandle;  
 
FStartCluster:LongWord;  
FClusterCount:LongWord;  
 
FOwnerId:Word; Owner Identification
FGroupId:Word; Group Identification
FPermissions:Word; Permissions 16 bits
FCreateTime:TFileTime; File Creation Date and Time
FModifyTime:TFileTime; File Modification Date and Time
FExpireTime:TFileTime; File Expiration Date and Time
FEffectiveTime:TFileTime; File Effective Date and Time
FRecordFormat:Byte; Record Format
FRecordAttributes:Byte; Record Attributes
FRecordLength:Word; Record Length
FSystemIdentifier:String; System Identifier a-characters, a1-characters
FSystemData:Pointer; System Use not specified
FExtendedVersion:Byte; Extended Attribute Record Version
FEscapeSequenceSize:Byte; Length of Escape Sequences (LEN_ESC)
FApplicationDataSize:Word; Length of Application Use (LEN_AU)
FApplicationData:Pointer; Application Use LEN_AU bytes
FEscapeSequence:Pointer; Escape Sequences LEN_ESC bytes
 
function AcquireLock:Boolean;  
function ReleaseLock:Boolean;  
 
function GetSystemIdentifier:String;  
procedure SetSystemIdentifier(const ASystemIdentifier:String);  
public
property StartCluster:LongWord read FStartCluster write FStartCluster;  
property ClusterCount:LongWord read FClusterCount write FClusterCount;  
 
property OwnerId:Word read FOwnerId write FOwnerId;  
property GroupId:Word read FGroupId write FGroupId;  
property Permissions:Word read FPermissions write FPermissions;  
property CreateTime:TFileTime read FCreateTime write FCreateTime;  
property ModifyTime:TFileTime read FModifyTime write FModifyTime;  
property ExpireTime:TFileTime read FExpireTime write FExpireTime;  
property EffectiveTime:TFileTime read FEffectiveTime write FEffectiveTime;  
property RecordFormat:Byte read FRecordFormat write FRecordFormat;  
property RecordAttributes:Byte read FRecordAttributes write FRecordAttributes;  
property RecordLength:Word read FRecordLength write FRecordLength;  
property SystemIdentifier:String read GetSystemIdentifier write SetSystemIdentifier;  
property SystemData:Pointer read FSystemData write FSystemData;  
property ExtendedVersion:Byte read FExtendedVersion write FExtendedVersion;  
property EscapeSequenceSize:Byte read FEscapeSequenceSize write FEscapeSequenceSize;  
property ApplicationDataSize:Word read FApplicationDataSize write FApplicationDataSize;  
property ApplicationData:Pointer read FApplicationData write FApplicationData;  
property EscapeSequence:Pointer read FEscapeSequence write FEscapeSequence;  
 
function ExtendedRecordSize:Byte;  

CDFS disk descriptor

TCDFSDiskDescriptor = class(TListObject)

Note: Represents a CDFS volume descriptor.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FLocalLock:TMutexHandle;  
 
FUnicode:Boolean;  
 
FStartCluster:LongWord;  
 
FDescriptorType:Byte; Descriptor Type (00 = Boot, 01 = Primary etc)
FDescriptorVersion:Byte; Descriptor Version (1)
FStandardIdentifier:String; Standard Identifier ('CD001')
 
FSystemIdentifier:String; System Identifier a-characters (eg EL TORITO SPECIFICATION)
FVolumeIdentifier:String; Volume Identifier d-characters
FVolumeSpaceSize:LongWord; Volume Space Size
FVolumeSetSize:Word; Volume Set Size
FVolumeSequenceNumber:Word; Volume Sequence Number
FLogicalBlockSize:Word; Logical Block Size
FPathTableSize:LongWord; Path Table Size
FPrimaryPathTable:LongWord; Location of Occurrence of Type L Path Table
FAlternatePathTable:LongWord; Location of Optional Occurrence of Type L Path Table
FPrimaryPathTableM:LongWord; Location of Occurrence of Type M Path Table
FAlternatePathTableM:LongWord; Location of Optional Occurrence of Type M Path Table
FVolumeSetIdentifier:String; Volume Set Identifier d-characters
FPublisherIdentifier:String; Publisher Identifier a-characters
FPreparerIdentifier:String; Data Preparer Identifier a-characters
FApplicationIdentifier:String; Application Identifier a-characters
FCopyrightIdentifier:String; Copyright File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
FAbstractIdentifier:String; Abstract File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
FBibliographicIdentifier:String; Bibliographic File Identifier d-characters, SEPARATOR 1, SEPARATOR 2
FCreateTime:TFileTime; Volume Creation Date and Time
FModifyTime:TFileTime; Volume Modification Date and Time
FExpireTime:TFileTime; Volume Expiration Date and Time
FEffectiveTime:TFileTime; Volume Effective Date and Time
FFileStructureVersion:Byte; File Structure Version
FApplicationData:Pointer; Application Use not specified
 
FVolumeFlags:Byte; Volume Flags 8 bits
FEscapeSequences:Pointer; Escape Sequences 32 bytes
 
FBootIdentifier:String; 32 a-characters
FCatalogStart:LongWord; Absolute pointer to first sector of Boot Catalog
FCatalogCount:LongWord; Number of Sectors in Boot Catalog (Not Stored)
 
FPartitionIdentifier:String; Volume Partition Identifier d-characters
FPartitionStart:LongWord; Volume Partition Location (first Logical Block)
FPartitionSize:LongWord; Volume Partition Size (in Logical Blocks)
FSystemData:Pointer; System Use not specified
 
FRoot:TCDFSDiskEntry;  
FPrimary:TCDFSDiskTable;  
FPrimaryM:TCDFSDiskTable;  
FAlternate:TCDFSDiskTable;  
FAlternateM:TCDFSDiskTable;  
 
FInitial:TCDFSDiskCatalog;  
FValidation:TCDFSDiskHeader;  
 
function AcquireLock:Boolean;  
function ReleaseLock:Boolean;  
 
function GetStandardIdentifier:String;  
procedure SetStandardIdentifier(const AStandardIdentifier:String);  
 
function GetSystemIdentifier:String;  
procedure SetSystemIdentifier(const ASystemIdentifier:String);  
function GetVolumeIdentifier:String;  
procedure SetVolumeIdentifier(const AVolumeIdentifier:String);  
 
function GetVolumeSetIdentifier:String;  
procedure SetVolumeSetIdentifier(const AVolumeSetIdentifier:String);  
function GetPublisherIdentifier:String;  
procedure SetPublisherIdentifier(const APublisherIdentifier:String);  
function GetPreparerIdentifier:String;  
procedure SetPreparerIdentifier(const APreparerIdentifier:String);  
function GetApplicationIdentifier:String;  
procedure SetApplicationIdentifier(const AApplicationIdentifier:String);  
function GetCopyrightIdentifier:String;  
procedure SetCopyrightIdentifier(const ACopyrightIdentifier:String);  
function GetAbstractIdentifier:String;  
procedure SetAbstractIdentifier(const AAbstractIdentifier:String);  
function GetBibliographicIdentifier:String;  
procedure SetBibliographicIdentifier(const ABibliographicIdentifier:String);  
 
function GetBootIdentifier:String;  
procedure SetBootIdentifier(const ABootIdentifier:String);  
 
function GetPartitionIdentifier:String;  
procedure SetPartitionIdentifier(const APartitionIdentifier:String);  
public
property Unicode:Boolean read FUnicode write FUnicode;  
 
property StartCluster:LongWord read FStartCluster write FStartCluster;  
 
property DescriptorType:Byte read FDescriptorType write FDescriptorType;  
property DescriptorVersion:Byte read FDescriptorVersion write FDescriptorVersion;  
property StandardIdentifier:String read GetStandardIdentifier write SetStandardIdentifier;  
 
property SystemIdentifier:String read GetSystemIdentifier write SetSystemIdentifier;  
property VolumeIdentifier:String read GetVolumeIdentifier write SetVolumeIdentifier;  
property VolumeSpaceSize:LongWord read FVolumeSpaceSize write FVolumeSpaceSize;  
property VolumeSetSize:Word read FVolumeSetSize write FVolumeSetSize;  
property VolumeSequenceNumber:Word read FVolumeSequenceNumber write FVolumeSequenceNumber;  
property LogicalBlockSize:Word read FLogicalBlockSize write FLogicalBlockSize;  
property PathTableSize:LongWord read FPathTableSize write FPathTableSize;  
property PrimaryPathTable:LongWord read FPrimaryPathTable write FPrimaryPathTable;  
property AlternatePathTable:LongWord read FAlternatePathTable write FAlternatePathTable;  
property PrimaryPathTableM:LongWord read FPrimaryPathTableM write FPrimaryPathTableM;  
property AlternatePathTableM:LongWord read FAlternatePathTableM write FAlternatePathTableM;  
property VolumeSetIdentifier:String read GetVolumeSetIdentifier write SetVolumeSetIdentifier;  
property PublisherIdentifier:String read GetPublisherIdentifier write SetPublisherIdentifier;  
property PreparerIdentifier:String read GetPreparerIdentifier write SetPreparerIdentifier;  
property ApplicationIdentifier:String read GetApplicationIdentifier write SetApplicationIdentifier;  
property CopyrightIdentifier:String read GetCopyrightIdentifier write SetCopyrightIdentifier;  
property AbstractIdentifier:String read GetAbstractIdentifier write SetAbstractIdentifier;  
property BibliographicIdentifier:String read GetBibliographicIdentifier write SetBibliographicIdentifier;  
property CreateTime:TFileTime read FCreateTime write FCreateTime;  
property ModifyTime:TFileTime read FModifyTime write FModifyTime;  
property ExpireTime:TFileTime read FExpireTime write FExpireTime;  
property EffectiveTime:TFileTime read FEffectiveTime write FEffectiveTime;  
property FileStructureVersion:Byte read FFileStructureVersion write FFileStructureVersion;  
property ApplicationData:Pointer read FApplicationData write FApplicationData;  
 
property VolumeFlags:Byte read FVolumeFlags write FVolumeFlags;  
property EscapeSequences:Pointer read FEscapeSequences write FEscapeSequences;  
 
property BootIdentifier:String read GetBootIdentifier write SetBootIdentifier;  
property CatalogStart:LongWord read FCatalogStart write FCatalogStart;  
property CatalogCount:LongWord read FCatalogCount write FCatalogCount;  
 
property PartitionIdentifier:String read GetPartitionIdentifier write SetPartitionIdentifier;  
property PartitionStart:LongWord read FPartitionStart write FPartitionStart;  
property PartitionSize:LongWord read FPartitionSize write FPartitionSize;  
property SystemData:Pointer read FSystemData write FSystemData;  
 
property Root:TCDFSDiskEntry read FRoot write FRoot;  
property Primary:TCDFSDiskTable read FPrimary write FPrimary;  
property PrimaryM:TCDFSDiskTable read FPrimaryM write FPrimaryM;  
property Alternate:TCDFSDiskTable read FAlternate write FAlternate;  
property AlternateM:TCDFSDiskTable read FAlternateM write FAlternateM;  
 
property Initial:TCDFSDiskCatalog read FInitial write FInitial;  
property Validation:TCDFSDiskHeader read FValidation write FValidation;  

CDFS disk header

TCDFSDiskHeader = class(TListObject)

Note: Represents a CDFS catalog header (Also the Validation entry).
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FLocalLock:TMutexHandle;  
 
FHeaderNo:LongWord;  
 
FHeaderOffset:LongWord;  
FHeaderCluster:LongWord;  
 
FValidation:Boolean;  
FHeaderId:Byte;  
FPlatformId:Byte;  
FVendorId:String;  
FChecksum:Word;  
FSignature:Word;  
 
FSectionCount:Word;  
 
function AcquireLock:Boolean;  
function ReleaseLock:Boolean;  
 
function GetVendorId:String;  
procedure SetVendorId(const AVendorId:String);  
public
property HeaderNo:LongWord read FHeaderNo write FHeaderNo;  
 
property HeaderOffset:LongWord read FHeaderOffset write FHeaderOffset;  
property HeaderCluster:LongWord read FHeaderCluster write FHeaderCluster;  
 
property Validation:Boolean read FValidation write FValidation;  
property HeaderId:Byte read FHeaderId write FHeaderId;  
property PlatformId:Byte read FPlatformId write FPlatformId;  
property VendorId:String read GetVendorId write SetVendorId;  
property Checksum:Word read FChecksum write FChecksum;  
property Signature:Word read FSignature write FSignature;  
 
property HeaderIndicator:Byte read FHeaderId write FHeaderId;  
property SectionCount:Word read FSectionCount write FSectionCount;  
property SectionId:String read GetVendorId write SetVendorId;  

CDFS disk extension

TCDFSDiskExtension = class(TListObject)

Note: Represents a CDFS catalog extension.
 
constructor Create(ALocalLock:TMutexHandle);  
destructor Destroy; override;  
private
FLocalLock:TMutexHandle;  
 
FExtensionNo:LongWord;  
 
FExtensionOffset:LongWord;  
FExtensionCluster:LongWord;  
 
FExtensionIndicator:Byte;  
FExtensionFlag:Byte;  
FSelectionData:Pointer;  
 
FCatalog:TCDFSDiskCatalog;  
 
function AcquireLock:Boolean;  
function ReleaseLock:Boolean;  
public
property ExtensionNo:LongWord read FExtensionNo write FExtensionNo;  
 
property ExtensionOffset:LongWord read FExtensionOffset write FExtensionOffset;  
property ExtensionCluster:LongWord read FExtensionCluster write FExtensionCluster;  
 
property ExtensionIndicator:Byte read FExtensionIndicator write FExtensionIndicator;  
property ExtensionFlag:Byte read FExtensionFlag write FExtensionFlag;  
property SelectionData:Pointer read FSelectionData write FSelectionData;  
 
property Catalog:TCDFSDiskCatalog read FCatalog write FCatalog;  


Public variables

None defined

Function declarations


Initialization functions 

procedure CDFSInit;
Description: To be documented
Note None documented 


procedure CDFSQuit;
Description: To be documented
Note None documented


CDFS helper functions 

function CDFSDataToPointer(const AData; ASize:Integer; ASwap:Boolean):Pointer;
Description: Creates a pointer and copies data from a buffer
Note Allows byte order swapping on copy 


function CDFSPointerToData(APointer:Pointer; var AData; ASize:Integer; ASwap:Boolean):Boolean;
Description: Copies data to a buffer from supplied pointer
Note Allows byte order swapping on copy 


function CDFSIdentifierToString(const AIdentifier; ASize:Integer; AUnicode:Boolean):String;
Description: Converts the supplied indentifier to a string
Note Accounts for unicode and byte ordering 


function CDFSStringToIdentifier(const AString:String; var AIdentifier; ASize:Integer; AUnicode:Boolean):Boolean;
Description: Converts the supplied string to an identifier
Note Accounts for unicode and byte ordering 


function CDFSIdentifierToFileName(const AIdentifier; ASize:Integer; AUnicode:Boolean):String;
Description: Converts the supplied identifier to a filename
Note Accounts for dot and dot dot special entries 


function CDFSFileNameToIdentifier(const AFileName:String; var AIdentifier; ASize:Integer; AUnicode:Boolean):Boolean;
Description: Converts the supplied filename to an identifier
Note Accounts for dot and dot dot special entries 


function CDFSTimeToFileTime(const ATime:TCDFSTime):TFileTime;
Description: Converts a CDFS Time in Local to a File Time in UTC
Note None documented 


function FileTimeToCDFSTime(const AFileTime:TFileTime; var ATime:TCDFSTime):Boolean;
Description: Converts a File Time in UTC to a CDFS Time in Local
Note None documented 


function CDFSDateTimeToFileTime(const ADateTime:TCDFSDateTime):TFileTime;
Description: Converts a CDFS Date Time in Local to a File Time in UTC
Note None documented 


function FileTimeToCDFSDateTime(const AFileTime:TFileTime; var ADateTime:TCDFSDateTime):Boolean;
Description: Converts a File Time in UTC to a CDFS Date Time in Local
Note None documented


Return to Unit Reference

Retrieved from "https://ultibo.org/mediawiki_ultibo_org/index.php?title=Unit_CDFS&oldid=3783"