Ejemplo n.º 1
0
        public LogicalRecordSegmentEncryptionPacket ReadLogicalRecordSegmentEncryptionPacket(Stream dlisStream)
        {
            if (dlisStream == null)
            {
                return(null);
            }
            if (dlisStream.BytesRemaining() < 4)
            {
                return(null);
            }

            var size = _unormReader.ReadUNORM(dlisStream);

            if (size < 4)
            {
                return(null);
            }
            if (dlisStream.BytesRemaining() < size - 4)
            {
                return(null);
            }

            return(new LogicalRecordSegmentEncryptionPacket
            {
                Size = size,
                CompanyCode = _unormReader.ReadUNORM(dlisStream),
                EncryptionInfo = dlisStream.ReadBytes(size - 4)
            });
        }
        public LogicalRecordSegmentTrailer ReadLogicalRecordSegmentTrailer(Stream dlisStream, LogicalRecordSegmentHeader header)
        {
            if (dlisStream == null)
            {
                return(null);
            }
            if (dlisStream.IsAtBeginningOfStream())
            {
                return(null);
            }
            if (header == null)
            {
                return(null);
            }
            if (!header.HasTrailer())
            {
                return(null);
            }

            var trailer = new LogicalRecordSegmentTrailer();

            if (header.TrailingLength)
            {
                dlisStream.Seek(-2, SeekOrigin.Current);
            }
            if (header.Checksum)
            {
                dlisStream.Seek(-2, SeekOrigin.Current);
            }

            if (header.Padding)
            {
                dlisStream.Seek(-1, SeekOrigin.Current);
                trailer.PadCount = _ushortReader.ReadUSHORT(dlisStream);

                dlisStream.Seek(-trailer.PadCount, SeekOrigin.Current);
                trailer.Padding = dlisStream.ReadBytes(trailer.PadCount);
            }

            if (header.Checksum)
            {
                trailer.Checksum = _unormReader.ReadUNORM(dlisStream);
            }
            if (header.TrailingLength)
            {
                trailer.TrailingLength = _unormReader.ReadUNORM(dlisStream);
            }

            return(trailer);
        }
        public LogicalRecordSegmentHeader ReadLogicalRecordSegmentHeader(Stream dlisStream)
        {
            if (dlisStream == null)
            {
                return(null);
            }
            if (dlisStream.BytesRemaining() < 4)
            {
                return(null);
            }

            return(new LogicalRecordSegmentHeader
            {
                LogicalRecordSegmentLength = _unormReader.ReadUNORM(dlisStream),
                LogicalRecordSegmentAttributes = _ushortReader.ReadUSHORT(dlisStream),
                LogicalRecordType = _ushortReader.ReadUSHORT(dlisStream)
            });
        }
        public VisibleRecord ReadVisibleRecord(Stream dlisStream)
        {
            if (dlisStream == null)
            {
                return(null);
            }

            var visibleRecord = new VisibleRecord
            {
                Length = _unormReader.ReadUNORM(dlisStream),
                FormatVersionField1 = _ushortReader.ReadUSHORT(dlisStream),
                FormatVersionField2 = _ushortReader.ReadUSHORT(dlisStream)
            };

            if (visibleRecord.FormatVersionField1 != 255 || visibleRecord.FormatVersionField2 != 1)
            {
                throw new Exception("invalid visible record format");
            }

            var logicalRecordSegmentData = dlisStream.ReadBytes(visibleRecord.Length - 4);

            if (logicalRecordSegmentData == null)
            {
                throw new Exception("invalid visible record length");
            }

            var logicalRecordSegments = new List <LogicalRecordSegment>();

            using (var lrsStream = new MemoryStream(logicalRecordSegmentData))
            {
                while (!lrsStream.IsAtEndOfStream())
                {
                    var lrs = _logicalRecordSegmentBusiness.ReadLogicalRecordSegment(lrsStream);
                    if (lrs == null)
                    {
                        throw new Exception("invalid logical record segment");
                    }
                    logicalRecordSegments.Add(lrs);
                }
            }
            visibleRecord.Segments = logicalRecordSegments.ToArray();

            return(visibleRecord);
        }