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;
 }
Example #2
0
        private static string MakeShortFileName(string longName, BuildDirectoryInfo dir)
        {
            if (IsoUtilities.IsValidFileName(longName) && longName.Contains(";"))
            {
                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);
        }
Example #3
0
 internal BuildFileInfo(string name, BuildDirectoryInfo parent, Stream source)
     : base(IsoUtilities.NormalizeFileName(name), MakeShortFileName(name, parent))
 {
     _parent        = parent;
     _contentStream = source;
     _contentSize   = _contentStream.Length;
 }
Example #4
0
 internal BuildFileInfo(string name, BuildDirectoryInfo parent, byte[] content)
     : base(IsoUtilities.NormalizeFileName(name), MakeShortFileName(name, parent))
 {
     _parent      = parent;
     _contentData = content;
     _contentSize = content.LongLength;
 }
Example #5
0
        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);
        }
Example #6
0
        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);
        }
Example #7
0
 internal virtual void WriteTo(byte[] buffer, int offset)
 {
     Array.Clear(buffer, offset, IsoUtilities.SectorSize);
     buffer[offset] = (byte)VolumeDescriptorType;
     IsoUtilities.WriteAChars(buffer, offset + 1, 5, StandardIdentifier);
     buffer[offset + 6] = VolumeDescriptorVersion;
 }
        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         = Utilities.ToUInt32LittleEndian(src, offset + 140);
            OptionalTypeLPathTableLocation = Utilities.ToUInt32LittleEndian(src, offset + 144);
            TypeMPathTableLocation         = Utilities.BitSwap(Utilities.ToUInt32LittleEndian(src, offset + 148));
            OptionalTypeMPathTableLocation = Utilities.BitSwap(Utilities.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];
        }
Example #9
0
        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 ChildLinkSystemUseEntry(byte[] data, int offset)
        {
            byte len = data[offset + 2];

            Name    = "CL";
            Version = data[offset + 3];

            CheckLengthAndVersion(len, 12, 1);

            ChildDirLocation = IsoUtilities.ToUInt32FromBoth(data, offset + 4);
        }
        public ContinuationSystemUseEntry(byte[] data, int offset)
        {
            byte len = data[offset + 2];

            Name    = "CE";
            Version = data[offset + 3];

            CheckLengthAndVersion(len, 28, 1);

            Block       = IsoUtilities.ToUInt32FromBoth(data, offset + 4);
            BlockOffset = IsoUtilities.ToUInt32FromBoth(data, offset + 12);
            Length      = IsoUtilities.ToUInt32FromBoth(data, offset + 20);
        }
Example #12
0
        ////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 = Utilities.ToUInt32LittleEndian(src, offset + 2);
        ////    record.ParentDirectoryNumber = Utilities.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((int)(8 + nameBytes + (((nameBytes & 0x1) == 1) ? 1 : 0)));
        }
Example #13
0
        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));
        }
        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(byte[] data, int offset, Encoding encoding)
        {
            byte len = data[offset + 2];

            Name    = "ER";
            Version = data[offset + 3];

            CheckLengthAndVersion(len, 8, 1);

            int lenId         = data[offset + 4];
            int lenDescriptor = data[offset + 5];
            int lenSource     = data[offset + 6];

            ExtensionVersion = data[offset + 7];

            if (len < 8 + lenId + lenDescriptor + lenSource)
            {
                throw new InvalidDataException("Invalid SUSP ER entry - too short, only " + len + " 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))
 {
 }