internal virtual void WriteTo(byte[] buffer, int offset)
{
Array.Clear(buffer, offset, SectorSize);
buffer[offset] = (byte)VolumeDescriptorType;
IsoUtilities.WriteAChars(buffer, offset + 1, 5, StandardIdentifier);
buffer[offset + 6] = VolumeDescriptorVersion;
}
public ReaderDirEntry GetEntryByName(string name)
{
bool anyVerMatch = name.IndexOf(';') < 0;
string normName = IsoUtilities.NormalizeFileName(name).ToUpper(CultureInfo.InvariantCulture);
if (anyVerMatch)
{
normName = normName.Substring(0, normName.LastIndexOf(';') + 1);
}
foreach (ReaderDirEntry r in _records)
{
string toComp = IsoUtilities.NormalizeFileName(r.FileName).ToUpper(CultureInfo.InvariantCulture);
if (!anyVerMatch && toComp == normName)
{
return(r);
}
if (anyVerMatch && toComp.StartsWith(normName, StringComparison.Ordinal))
{
return(r);
}
}
return(null);
}
internal BuildFileInfo(string name, BuildDirectoryInfo parent, Stream source)
: base(IsoUtilities.NormalizeFileName(name), MakeShortFileName(name, parent))
{
Parent = parent;
_contentStream = source;
_contentSize = _contentStream.Length;
}
internal BuildFileInfo(string name, BuildDirectoryInfo parent, byte[] content)
: base(IsoUtilities.NormalizeFileName(name), MakeShortFileName(name, parent))
{
Parent = parent;
_contentData = content;
_contentSize = content.Length;
}
internal override void WriteTo(byte[] buffer, int offset)
{
base.WriteTo(buffer, offset);
IsoUtilities.WriteA1Chars(buffer, offset + 8, 32, SystemIdentifier, CharacterEncoding);
IsoUtilities.WriteString(buffer, offset + 40, 32, true, VolumeIdentifier, CharacterEncoding, true);
IsoUtilities.ToBothFromUInt32(buffer, offset + 80, VolumeSpaceSize);
IsoUtilities.EncodingToBytes(CharacterEncoding, buffer, offset + 88);
IsoUtilities.ToBothFromUInt16(buffer, offset + 120, VolumeSetSize);
IsoUtilities.ToBothFromUInt16(buffer, offset + 124, VolumeSequenceNumber);
IsoUtilities.ToBothFromUInt16(buffer, offset + 128, LogicalBlockSize);
IsoUtilities.ToBothFromUInt32(buffer, offset + 132, PathTableSize);
IsoUtilities.ToBytesFromUInt32(buffer, offset + 140, TypeLPathTableLocation);
IsoUtilities.ToBytesFromUInt32(buffer, offset + 144, OptionalTypeLPathTableLocation);
IsoUtilities.ToBytesFromUInt32(buffer, offset + 148, Utilities.BitSwap(TypeMPathTableLocation));
IsoUtilities.ToBytesFromUInt32(buffer, offset + 152, Utilities.BitSwap(OptionalTypeMPathTableLocation));
RootDirectory.WriteTo(buffer, offset + 156, CharacterEncoding);
IsoUtilities.WriteD1Chars(buffer, offset + 190, 129, VolumeSetIdentifier, CharacterEncoding);
IsoUtilities.WriteA1Chars(buffer, offset + 318, 129, PublisherIdentifier, CharacterEncoding);
IsoUtilities.WriteA1Chars(buffer, offset + 446, 129, DataPreparerIdentifier, CharacterEncoding);
IsoUtilities.WriteA1Chars(buffer, offset + 574, 129, ApplicationIdentifier, CharacterEncoding);
IsoUtilities.WriteD1Chars(buffer, offset + 702, 37, CopyrightFileIdentifier, CharacterEncoding); // FIXME!!
IsoUtilities.WriteD1Chars(buffer, offset + 739, 37, AbstractFileIdentifier, CharacterEncoding); // FIXME!!
IsoUtilities.WriteD1Chars(buffer, offset + 776, 37, BibliographicFileIdentifier, CharacterEncoding);
// FIXME!!
IsoUtilities.ToVolumeDescriptorTimeFromUTC(buffer, offset + 813, CreationDateAndTime);
IsoUtilities.ToVolumeDescriptorTimeFromUTC(buffer, offset + 830, ModificationDateAndTime);
IsoUtilities.ToVolumeDescriptorTimeFromUTC(buffer, offset + 847, ExpirationDateAndTime);
IsoUtilities.ToVolumeDescriptorTimeFromUTC(buffer, offset + 864, EffectiveDateAndTime);
buffer[offset + 881] = FileStructureVersion;
}
private static string MakeShortFileName(string longName, BuildDirectoryInfo dir)
{
if (IsoUtilities.IsValidFileName(longName))
{
return(longName);
}
char[] shortNameChars = longName.ToUpper(CultureInfo.InvariantCulture).ToCharArray();
for (int i = 0; i < shortNameChars.Length; ++i)
{
if (!IsoUtilities.IsValidDChar(shortNameChars[i]) && shortNameChars[i] != '.' && shortNameChars[i] != ';')
{
shortNameChars[i] = '_';
}
}
string[] parts = IsoUtilities.SplitFileName(new string(shortNameChars));
if (parts[0].Length + parts[1].Length > 30)
{
parts[1] = parts[1].Substring(0, Math.Min(parts[1].Length, 3));
}
if (parts[0].Length + parts[1].Length > 30)
{
parts[0] = parts[0].Substring(0, 30 - parts[1].Length);
}
string candidate = parts[0] + '.' + parts[1] + ';' + parts[2];
// TODO: Make unique
return(candidate);
}
public CommonVolumeDescriptor(byte[] src, int offset, Encoding enc)
: base(src, offset)
{
CharacterEncoding = enc;
SystemIdentifier = IsoUtilities.ReadChars(src, offset + 8, 32, CharacterEncoding);
VolumeIdentifier = IsoUtilities.ReadChars(src, offset + 40, 32, CharacterEncoding);
VolumeSpaceSize = IsoUtilities.ToUInt32FromBoth(src, offset + 80);
VolumeSetSize = IsoUtilities.ToUInt16FromBoth(src, offset + 120);
VolumeSequenceNumber = IsoUtilities.ToUInt16FromBoth(src, offset + 124);
LogicalBlockSize = IsoUtilities.ToUInt16FromBoth(src, offset + 128);
PathTableSize = IsoUtilities.ToUInt32FromBoth(src, offset + 132);
TypeLPathTableLocation = EndianUtilities.ToUInt32LittleEndian(src, offset + 140);
OptionalTypeLPathTableLocation = EndianUtilities.ToUInt32LittleEndian(src, offset + 144);
TypeMPathTableLocation = Utilities.BitSwap(EndianUtilities.ToUInt32LittleEndian(src, offset + 148));
OptionalTypeMPathTableLocation = Utilities.BitSwap(EndianUtilities.ToUInt32LittleEndian(src, offset + 152));
DirectoryRecord.ReadFrom(src, offset + 156, CharacterEncoding, out RootDirectory);
VolumeSetIdentifier = IsoUtilities.ReadChars(src, offset + 190, 318 - 190, CharacterEncoding);
PublisherIdentifier = IsoUtilities.ReadChars(src, offset + 318, 446 - 318, CharacterEncoding);
DataPreparerIdentifier = IsoUtilities.ReadChars(src, offset + 446, 574 - 446, CharacterEncoding);
ApplicationIdentifier = IsoUtilities.ReadChars(src, offset + 574, 702 - 574, CharacterEncoding);
CopyrightFileIdentifier = IsoUtilities.ReadChars(src, offset + 702, 739 - 702, CharacterEncoding);
AbstractFileIdentifier = IsoUtilities.ReadChars(src, offset + 739, 776 - 739, CharacterEncoding);
BibliographicFileIdentifier = IsoUtilities.ReadChars(src, offset + 776, 813 - 776, CharacterEncoding);
CreationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 813);
ModificationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 830);
ExpirationDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 847);
EffectiveDateAndTime = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(src, offset + 864);
FileStructureVersion = src[offset + 881];
}
internal int WriteTo(byte[] buffer, int offset, Encoding enc)
{
uint length = CalcLength(FileIdentifier, enc);
buffer[offset] = (byte)length;
buffer[offset + 1] = ExtendedAttributeRecordLength;
IsoUtilities.ToBothFromUInt32(buffer, offset + 2, LocationOfExtent);
IsoUtilities.ToBothFromUInt32(buffer, offset + 10, DataLength);
IsoUtilities.ToDirectoryTimeFromUTC(buffer, offset + 18, RecordingDateAndTime);
buffer[offset + 25] = (byte)Flags;
buffer[offset + 26] = FileUnitSize;
buffer[offset + 27] = InterleaveGapSize;
IsoUtilities.ToBothFromUInt16(buffer, offset + 28, VolumeSequenceNumber);
byte lengthOfFileIdentifier;
if (FileIdentifier.Length == 1 && FileIdentifier[0] <= 1)
{
buffer[offset + 33] = (byte)FileIdentifier[0];
lengthOfFileIdentifier = 1;
}
else
{
lengthOfFileIdentifier =
(byte)
IsoUtilities.WriteString(buffer, offset + 33, (int)(length - 33), false, FileIdentifier, enc);
}
buffer[offset + 32] = lengthOfFileIdentifier;
return((int)length);
}
public static int ReadFrom(byte[] src, int offset, Encoding enc, out DirectoryRecord record)
{
int length = src[offset + 0];
record = new DirectoryRecord();
record.ExtendedAttributeRecordLength = src[offset + 1];
record.LocationOfExtent = IsoUtilities.ToUInt32FromBoth(src, offset + 2);
record.DataLength = IsoUtilities.ToUInt32FromBoth(src, offset + 10);
record.RecordingDateAndTime = IsoUtilities.ToUTCDateTimeFromDirectoryTime(src, offset + 18);
record.Flags = (FileFlags)src[offset + 25];
record.FileUnitSize = src[offset + 26];
record.InterleaveGapSize = src[offset + 27];
record.VolumeSequenceNumber = IsoUtilities.ToUInt16FromBoth(src, offset + 28);
byte lengthOfFileIdentifier = src[offset + 32];
record.FileIdentifier = IsoUtilities.ReadChars(src, offset + 33, lengthOfFileIdentifier, enc);
int padding = (lengthOfFileIdentifier & 1) == 0 ? 1 : 0;
int startSystemArea = lengthOfFileIdentifier + padding + 33;
int lenSystemArea = length - startSystemArea;
if (lenSystemArea > 0)
{
record.SystemUseData = new byte[lenSystemArea];
Array.Copy(src, offset + startSystemArea, record.SystemUseData, 0, lenSystemArea);
}
return(length);
}
internal BuildFileInfo(string name, BuildDirectoryInfo parent, string content)
: base(IsoUtilities.NormalizeFileName(name), MakeShortFileName(name, parent))
{
Parent = parent;
_contentPath = content;
_contentSize = new FileInfo(_contentPath).Length;
CreationTime = new FileInfo(_contentPath).LastWriteTimeUtc;
}
public ReaderDirectory(IsoContext context, ReaderDirEntry dirEntry)
: base(context, dirEntry)
{
byte[] buffer = new byte[context.SectorSize];
Stream extent = new ExtentStream(_context.DataStream, dirEntry.Record.LocationOfExtent, uint.MaxValue, 0, 0, context.SectorSize);
_records = new List <ReaderDirEntry>();
uint totalLength = dirEntry.Record.DataLength;
uint totalRead = 0;
while (totalRead < totalLength)
{
int bytesRead = (int)Math.Min(buffer.Length, totalLength - totalRead);
extent.Seek(24, SeekOrigin.Current);
StreamUtilities.ReadExact(extent, buffer, 0, bytesRead);
totalRead += (uint)bytesRead;
uint pos = 0;
while (pos < bytesRead && buffer[pos] != 0)
{
DirectoryRecord dr;
uint length = (uint)DirectoryRecord.ReadFrom(buffer, (int)pos, context.VolumeDescriptor.CharacterEncoding, out dr);
if (!IsoUtilities.IsSpecialDirectory(dr))
{
ReaderDirEntry childDirEntry = new ReaderDirEntry(_context, dr);
if (context.SuspDetected && !string.IsNullOrEmpty(context.RockRidgeIdentifier))
{
if (childDirEntry.SuspRecords == null || !childDirEntry.SuspRecords.HasEntry(context.RockRidgeIdentifier, "RE"))
{
_records.Add(childDirEntry);
}
}
else
{
_records.Add(childDirEntry);
}
}
else if (dr.FileIdentifier == "\0")
{
Self = new ReaderDirEntry(_context, dr);
}
pos += length;
}
}
}
private static string MakeShortDirName(string longName, BuildDirectoryInfo dir)
{
if (IsoUtilities.IsValidDirectoryName(longName))
{
return(longName);
}
char[] shortNameChars = longName.ToUpper(CultureInfo.InvariantCulture).ToCharArray();
for (int i = 0; i < shortNameChars.Length; ++i)
{
if (!IsoUtilities.IsValidDChar(shortNameChars[i]) && shortNameChars[i] != '.' && shortNameChars[i] != ';')
{
shortNameChars[i] = '_';
}
}
return(new string(shortNameChars));
}
////public static int ReadFrom(byte[] src, int offset, bool byteSwap, Encoding enc, out PathTableRecord record)
////{
//// byte directoryIdentifierLength = src[offset + 0];
//// record.ExtendedAttributeRecordLength = src[offset + 1];
//// record.LocationOfExtent = EndianUtilities.ToUInt32LittleEndian(src, offset + 2);
//// record.ParentDirectoryNumber = EndianUtilities.ToUInt16LittleEndian(src, offset + 6);
//// record.DirectoryIdentifier = IsoUtilities.ReadChars(src, offset + 8, directoryIdentifierLength, enc);
////
//// if (byteSwap)
//// {
//// record.LocationOfExtent = Utilities.BitSwap(record.LocationOfExtent);
//// record.ParentDirectoryNumber = Utilities.BitSwap(record.ParentDirectoryNumber);
//// }
////
//// return directoryIdentifierLength + 8 + (((directoryIdentifierLength & 1) == 1) ? 1 : 0);
////}
internal int Write(bool byteSwap, Encoding enc, byte[] buffer, int offset)
{
int nameBytes = enc.GetByteCount(DirectoryIdentifier);
buffer[offset + 0] = (byte)nameBytes;
buffer[offset + 1] = 0; // ExtendedAttributeRecordLength;
IsoUtilities.ToBytesFromUInt32(buffer, offset + 2,
byteSwap ? Utilities.BitSwap(LocationOfExtent) : LocationOfExtent);
IsoUtilities.ToBytesFromUInt16(buffer, offset + 6,
byteSwap ? Utilities.BitSwap(ParentDirectoryNumber) : ParentDirectoryNumber);
IsoUtilities.WriteString(buffer, offset + 8, nameBytes, false, DirectoryIdentifier, enc);
if ((nameBytes & 1) == 1)
{
buffer[offset + 8 + nameBytes] = 0;
}
return(8 + nameBytes + ((nameBytes & 0x1) == 1 ? 1 : 0));
}
private DateTime ReadTimestamp(Timestamps timestamp, byte[] data, bool longForm, ref int pos)
{
DateTime result = DateTime.MinValue;
if ((TimestampsPresent & timestamp) != 0)
{
if (longForm)
{
result = IsoUtilities.ToDateTimeFromVolumeDescriptorTime(data, pos);
pos += 17;
}
else
{
result = IsoUtilities.ToUTCDateTimeFromDirectoryTime(data, pos);
pos += 7;
}
}
return(result);
}
public ExtensionSystemUseEntry(string name, byte length, byte version, byte[] data, int offset, Encoding encoding)
{
CheckAndSetCommonProperties(name, length, version, 8, 1);
int lenId = data[offset + 4];
int lenDescriptor = data[offset + 5];
int lenSource = data[offset + 6];
ExtensionVersion = data[offset + 7];
if (length < 8 + lenId + lenDescriptor + lenSource)
{
throw new InvalidDataException("Invalid SUSP ER entry - too short, only " + length + " bytes - expected: " +
(8 + lenId + lenDescriptor + lenSource));
}
ExtensionIdentifier = IsoUtilities.ReadChars(data, offset + 8, lenId, encoding);
ExtensionDescriptor = IsoUtilities.ReadChars(data, offset + 8 + lenId, lenDescriptor, encoding);
ExtensionSource = IsoUtilities.ReadChars(data, offset + 8 + lenId + lenDescriptor, lenSource, encoding);
}
public SupplementaryVolumeDescriptor(byte[] src, int offset)
: base(src, offset, IsoUtilities.EncodingFromBytes(src, offset + 88))
{
}