ReadUInt64() private method

private ReadUInt64 ( ) : ulong
return ulong
Example #1
0
        /// <summary>
        /// Reads a windows-specific PE header from the given binary
        /// data stream.
        /// </summary>
        /// <param name="reader">The reader to use.</param>
        /// <param name="isPE32Plus">Whether the file format is PE32+.</param>
        public WindowsHeader(BinaryReader reader, bool isPE32Plus)
        {
            this.ImageBase = isPE32Plus ? reader.ReadUInt64() : reader.ReadUInt32();

            this.SectionAlignment = reader.ReadUInt32();
            this.FileAlignment    = reader.ReadUInt32();
            this.TargetOSVersion  = new Version(reader.ReadUInt16(), reader.ReadUInt16());
            this.ImageVersion     = new Version(reader.ReadUInt16(), reader.ReadUInt16());
            this.SubsystemVersion = new Version(reader.ReadUInt16(), reader.ReadUInt16());

            reader.ReadUInt32(); // Skip reserved field

            this.ImageSize  = reader.ReadUInt32();
            this.HeaderSize = reader.ReadUInt32();
            this.Checksum   = reader.ReadUInt32();
            this.Subsystem  = (Subsystem)reader.ReadUInt16();
            this.DLLFlags   = (DLLCharacteristics)reader.ReadUInt16();

            this.StackReserveSize = isPE32Plus ? reader.ReadUInt64() : reader.ReadUInt32();
            this.StackCommitSize  = isPE32Plus ? reader.ReadUInt64() : reader.ReadUInt32();
            this.HeapReserveSize  = isPE32Plus ? reader.ReadUInt64() : reader.ReadUInt32();
            this.HeapCommitSize   = isPE32Plus ? reader.ReadUInt64() : reader.ReadUInt32();

            reader.ReadUInt32(); // Skip reserved field

            this.DataDirectoryCount = reader.ReadUInt32();
        }
Example #2
0
 public override ThingList Load(BinaryReader BR, ProgressCallback ProgressCallback)
 {
     ThingList TL = new ThingList();
       if (ProgressCallback != null)
     ProgressCallback(I18N.GetText("FTM:CheckingFile"), 0);
       if (BR.BaseStream.Length < 0x40 || BR.BaseStream.Position != 0)
     return TL;
     FFXIEncoding E = new FFXIEncoding();
       if (E.GetString(BR.ReadBytes(8)) != "d_msg".PadRight(8, '\0'))
     return TL;
     ushort Flag1 = BR.ReadUInt16();
       if (Flag1 != 0 && Flag1 != 1)
     return TL;
     ushort Flag2 = BR.ReadUInt16();
       if (Flag2 != 0 && Flag2 != 1)
     return TL;
       if (BR.ReadUInt32() != 3 || BR.ReadUInt32() != 3)
     return TL;
     uint FileSize = BR.ReadUInt32();
       if (FileSize != BR.BaseStream.Length)
     return TL;
     uint HeaderBytes = BR.ReadUInt32();
       if (HeaderBytes != 0x40)
     return TL;
       if (BR.ReadUInt32() != 0)
     return TL;
     int BytesPerEntry = BR.ReadInt32();
       if (BytesPerEntry < 0)
     return TL;
     uint DataBytes = BR.ReadUInt32();
       if (FileSize != (HeaderBytes + DataBytes) || (DataBytes % BytesPerEntry) != 0)
     return TL;
     uint EntryCount = BR.ReadUInt32();
       if (EntryCount * BytesPerEntry != DataBytes)
     return TL;
       if (BR.ReadUInt32() != 1 || BR.ReadUInt64() != 0 || BR.ReadUInt64() != 0)
     return TL;
       if (ProgressCallback != null)
     ProgressCallback(I18N.GetText("FTM:LoadingData"), 0);
       for (uint i = 0; i < EntryCount; ++i) {
       BinaryReader EntryBR = new BinaryReader(new MemoryStream(BR.ReadBytes(BytesPerEntry)));
     EntryBR.BaseStream.Position = 0;
       bool ItemAdded = false;
     {
     Things.DMSGStringBlock SB = new Things.DMSGStringBlock();
       if (SB.Read(EntryBR, E, i)) {
     TL.Add(SB);
     ItemAdded = true;
       }
     }
     EntryBR.Close();
     if (!ItemAdded) {
       TL.Clear();
       break;
     }
     if (ProgressCallback != null)
       ProgressCallback(null, (double) (i + 1) / EntryCount);
       }
       return TL;
 }
Example #3
0
        public ProgramHeader(BinaryReader reader, bool Is64Bit)
        {
            this.Type = (HeaderType)reader.ReadUInt32();

            // 64-bit reads flags here
            if (Is64Bit) { this.SegmentFlags = (SegmentFlags)reader.ReadUInt32(); }

            this.SegmentOffset  = Is64Bit ? reader.ReadInt64()  : reader.ReadUInt32();
            this.VirtualAddress = Is64Bit ? reader.ReadUInt64() : reader.ReadUInt32();

            // Skip physical address - reserved
            if (Is64Bit) reader.ReadUInt64(); else reader.ReadUInt32();

            this.SegmentFileSize   = Is64Bit ? reader.ReadInt64() : reader.ReadUInt32();
            this.SegmentLoadedSize = Is64Bit ? reader.ReadInt64() : reader.ReadUInt32();

            // 32-bit reads flags here
            if (!Is64Bit) { this.SegmentFlags = (SegmentFlags)reader.ReadUInt32(); }

            this.Alignment = Is64Bit ? reader.ReadInt64() : reader.ReadUInt32();

            if (this.SegmentOffset < 0 || this.SegmentFileSize < 0 ||
                this.SegmentLoadedSize < 0 || this.Alignment < 0)
            {
                throw new BadImageFormatException("Program header values are too large to be " +
                    "supported by this implementation");
            }
        }
Example #4
0
 /// <summary>Reads a 128-bit binary value from the specified binary reader.</summary>
 public static Bin128 Read(BinaryReader br)
 {
     var result = new Bin128();
     result._a = br.ReadUInt64();
     result._b = br.ReadUInt64();
     return result;
 }
        protected override void Parse(Stream s)
        {
            BinaryReader r = new BinaryReader(s);
            base.Parse(s);
            this.unknown1 = new DataBlobHandler(RecommendedApiVersion, OnResourceChanged, r.ReadBytes(7 * 4));
            this.unknownFlags1 = r.ReadUInt32();
            this.unknownFlags2 = r.ReadUInt32();
            this.unknownFlags3 = r.ReadUInt32();
            this.unknownFlags4 = r.ReadUInt32();
            this.unknownFlags5 = r.ReadUInt32();
            this.unknownInstance1 = r.ReadUInt64();
            this.unknown2 = r.ReadByte();
            this.unknownInstance2 = r.ReadUInt64();
            this.unknown3 = r.ReadByte();
            this.colorList = new SwatchColorList(OnResourceChanged, s);
            this.unknownFlags = new DataBlobHandler(RecommendedApiVersion, OnResourceChanged, r.ReadBytes(5));
            this.buildBuyMode = r.ReadBoolean();

            if (base.Version >= 0x19)
            {
                this.unknown4 = r.ReadUInt32();
                this.unknown5 = r.ReadUInt32();
                this.unknown6 = r.ReadUInt32();
                this.unknown7 = r.ReadUInt32();
            }
        }
Example #6
0
        public Binding(byte[] FileData)
        {
            MemoryStream MemStream = new MemoryStream(FileData);
            BinaryReader Reader = new BinaryReader(MemStream);

            m_Version = Endian.SwapUInt32(Reader.ReadUInt32());

            byte StrLength = Reader.ReadByte();
            string m_BoneName = Encoding.ASCII.GetString(Reader.ReadBytes(StrLength));

            //Should be 8.
            uint MeshAssetIDSize = Endian.SwapUInt32(Reader.ReadUInt32());

            //AssetID prefix, typical useless Maxis value...
            Reader.ReadUInt32();

            m_MeshAssetID = Endian.SwapUInt64(Reader.ReadUInt64());

            //Should be 8.
            uint TextureAssetIDSize = Endian.SwapUInt32(Reader.ReadUInt32());

            //AssetID prefix, typical useless Maxis value...
            Reader.ReadUInt32();

            m_TextureAssetID = Endian.SwapUInt64(Reader.ReadUInt64());
        }
Example #7
0
        internal ELFProgramHeader(BinaryReader reader, ELFSizeFormat sizeFormat)
        {
            p_type = reader.ReadUInt32();

            if (sizeFormat == ELFSizeFormat.ELF32)
            {
                p_offset = reader.ReadUInt32();
                p_vaddr = reader.ReadUInt32();
                p_paddr = reader.ReadUInt32();
            }
            else if (sizeFormat == ELFSizeFormat.ELF64)
            {
                p_offset = reader.ReadUInt64();
                p_vaddr = reader.ReadUInt64();
                p_paddr = reader.ReadUInt64();
            }
            else
            {
                throw new InvalidDataException("Unknown ELF size format value");
            }

            p_filesz = reader.ReadUInt32();
            p_memsz = reader.ReadUInt32();
            p_flags = reader.ReadUInt32();
            p_align = reader.ReadUInt32();
        }
Example #8
0
        public SdkMeshVertexBuffer(BinaryReader reader) {

            NumVertices = reader.ReadUInt64();
            SizeBytes = reader.ReadUInt64();
            StrideBytes = reader.ReadUInt64();
            Decl = new List<VertexElement>();
            var processElem = true;
            for (int j = 0; j < MaxVertexElements; j++) {
                var stream = reader.ReadUInt16();
                var offset = reader.ReadUInt16();
                var type = reader.ReadByte();
                var method = reader.ReadByte();
                var usage = reader.ReadByte();
                var usageIndex = reader.ReadByte();
                if (stream < 16 && processElem) {
                    var element = new VertexElement((short)stream, (short)offset, (DeclarationType)type, (DeclarationMethod)method, (DeclarationUsage)usage, usageIndex);
                    Decl.Add(element);
                } else {
                    processElem = false;
                }
            }
            DataOffset = reader.ReadUInt64();
            Vertices = new List<VertPosNormTexTan>();
            if (SizeBytes > 0) {
                ReadVertices(reader);
            }
        }
 public bool Load(string path)
 {
     using (FileStream fs = new FileStream(path, FileMode.Open))
     {
         using (BinaryReader reader = new BinaryReader(fs))
         {
             for (int i = 0; i < 8; ++i)
             {
                 reader.ReadBytes(4);
             }
             uint count = reader.ReadUInt32();
             uint offset = reader.ReadUInt32();
             fs.Position = (long)offset;
             try
             {
                 for (int i = 0; i < count; ++i)
                 {
                     ulong ext = reader.ReadUInt64();
                     ulong fpath = reader.ReadUInt64();
                     uint language = reader.ReadUInt32();
                     reader.ReadBytes(4);
                     uint id = reader.ReadUInt32();
                     reader.ReadBytes(4);
                     this.Add(ext, fpath, language, id);
                 }
             }
             catch (Exception)
             {
                 return false;
             }
         }
     }
     return true;
 }
		/* private ushort _padding; */

		/// <summary>
		/// Stream constructor.
		/// </summary>
		/// <param name="stream">The stream that contains the DirectorySectorEntry data.</param>
		public DirectorySectorEntry(Stream stream)
		{
			Debug.Assert(stream.Length >= Constants.DIR_ENTRY_SIZE);
			BinaryReader reader = new BinaryReader(stream);

			_name = Reader.ReadSimpleUnicodeString(reader, 64);
			_nameLength = reader.ReadUInt16();
			if(_nameLength > 0)
			{
				_nameLength /= 2;
				--_nameLength;
				_name = _name.Substring(0, _nameLength);
			}
			else
				_name = "";

			_type = (Stgty)reader.ReadByte();
			_color = (DeColor)reader.ReadByte();
			_leftSibling = new Sid(reader.ReadUInt32());
			_rightSibling = new Sid(reader.ReadUInt32());
			_child = new Sid(reader.ReadUInt32());
			_clsId = new Guid(reader.ReadBytes(16));
			_userFlags = reader.ReadUInt32();
			_createTimeStamp = reader.ReadUInt64();
			_modifyTimeStamp = reader.ReadUInt64();
			_sectStart = new Sect(reader.ReadUInt32());
			_size = reader.ReadUInt32();
			_propType = reader.ReadUInt16();
			/* _padding = */ reader.ReadUInt16();
		}
Example #11
0
 public IEnumerable<Entry> Import()
 {
     using (var reader = new BinaryReader(File.OpenRead(filename)))
     {
         // 4
         Version = reader.ReadInt32();
         // 4
         Positions = reader.ReadInt32();
         foreach (var i in Enumerable.Range(0, Positions))
         {
             // 16
             var board = new Board(reader.ReadUInt64(), reader.ReadUInt64(), Color.Black);
             // 20
             var height = reader.ReadInt32();
             // 24
             var prune = reader.ReadInt32();
             // 25
             var wld = reader.ReadBoolean();
             // 26
             var knownSolve = reader.ReadBoolean();
             // 28
             var fillOut = reader.ReadInt16();
             // 30
             var cutoff = reader.ReadInt16();
             // 32
             var heuristic = reader.ReadInt16();
             // 34
             var black = reader.ReadInt16();
             // 36
             var white = reader.ReadInt16();
             // 37
             var set = reader.ReadBoolean();
             // 38
             var assigned = reader.ReadBoolean();
             // 39
             var wldSolved = reader.ReadBoolean();
             // 40
             var fill2 = reader.ReadByte();
             // 48
             var games = new int[] { reader.ReadInt32(), reader.ReadInt32() };
             // 49
             var root = reader.ReadBoolean();
             // 52
             var fill3 = reader.ReadBytes(3);
             yield return new Entry(board, height, heuristic, 72/*new BookData()
             {
                 Height = height,
                 Prune = prune,
                 WLD = wld,
                 KnownSolve = knownSolve,
                 Cutoff = cutoff,
                 HeuristicValue = heuristic,
                 BlackValue = black,
                 WhiteValue = white,
                 Games = games
             }*/);
         }
     }
 }
        // extracts ZIP 64 extra field element from a given byte array 
        internal override void ParseDataField(BinaryReader reader, UInt16 size)
        {
            Debug.Assert(reader != null);

            if ((_zip64ExtraFieldUsage & ZipIOZip64ExtraFieldUsage.UncompressedSize) != 0)
            {
                _uncompressedSize = reader.ReadUInt64();

                if (size < sizeof(UInt64))
                {
                    throw new FileFormatException(SR.Get(SRID.CorruptedData));
                }

                size -= sizeof(UInt64);
            }

            if ((_zip64ExtraFieldUsage & ZipIOZip64ExtraFieldUsage.CompressedSize) != 0)
            {
                _compressedSize = reader.ReadUInt64();

                if (size < sizeof(UInt64))
                {
                    throw new FileFormatException(SR.Get(SRID.CorruptedData));
                }

                size -= sizeof(UInt64);
            }

            if ((_zip64ExtraFieldUsage & ZipIOZip64ExtraFieldUsage.OffsetOfLocalHeader) != 0)
            {
                _offsetOfLocalHeader = reader.ReadUInt64();

                if (size < sizeof(UInt64))
                {
                    throw new FileFormatException(SR.Get(SRID.CorruptedData));
                }

                size -= sizeof(UInt64);
            }

            if ((_zip64ExtraFieldUsage & ZipIOZip64ExtraFieldUsage.DiskNumber) != 0)
            {
                _diskNumber = reader.ReadUInt32();

                if (size < sizeof(UInt32))
                {
                    throw new FileFormatException(SR.Get(SRID.CorruptedData));
                }

                size -= sizeof(UInt32);
            }

            if (size != 0)
            {
                throw new FileFormatException(SR.Get(SRID.CorruptedData));
            }

            Validate();
        }
Example #13
0
 public override ThingList Load(BinaryReader BR, ProgressCallback ProgressCallback)
 {
     ThingList TL = new ThingList();
       if (ProgressCallback != null)
     ProgressCallback(I18N.GetText("FTM:CheckingFile"), 0);
       if (BR.BaseStream.Length < 0x40 || BR.BaseStream.Position != 0)
     return TL;
     FFXIEncoding E = new FFXIEncoding();
       // Skip (presumably) fixed portion of the header
       if ((E.GetString(BR.ReadBytes(8)) != "d_msg".PadRight(8, '\0')) || BR.ReadUInt16() != 1 || BR.ReadUInt16() != 1 || BR.ReadUInt32() != 3 || BR.ReadUInt32() != 3)
     return TL;
       // Read the useful header fields
     uint FileSize = BR.ReadUInt32();
       if (FileSize != BR.BaseStream.Length)
     return TL;
     uint HeaderBytes = BR.ReadUInt32();
       if (HeaderBytes != 0x40)
     return TL;
     uint EntryBytes = BR.ReadUInt32();
       if (BR.ReadUInt32() != 0)
     return TL;
     uint DataBytes  = BR.ReadUInt32();
       if (FileSize != HeaderBytes + EntryBytes + DataBytes)
     return TL;
     uint EntryCount = BR.ReadUInt32();
       if (EntryBytes != EntryCount * 8)
     return TL;
       if (BR.ReadUInt32() != 1 || BR.ReadUInt64() != 0 || BR.ReadUInt64() != 0)
     return TL;
       if (ProgressCallback != null)
     ProgressCallback(I18N.GetText("FTM:LoadingData"), 0);
       for (uint i = 0; i < EntryCount; ++i) {
     BR.BaseStream.Position = HeaderBytes + i * 8;
       int Offset = ~BR.ReadInt32();
       int Length = ~BR.ReadInt32();
     if (Length < 0 || Offset < 0 || Offset + Length > DataBytes) {
       TL.Clear();
       break;
     }
     BR.BaseStream.Position = HeaderBytes + EntryBytes + Offset;
       BinaryReader EntryBR = new BinaryReader(new MemoryStream(BR.ReadBytes(Length)));
       bool ItemAdded = false;
     {
     Things.DMSGStringBlock SB = new Things.DMSGStringBlock();
       if (SB.Read(EntryBR, E, i)) {
     TL.Add(SB);
     ItemAdded = true;
       }
     }
     EntryBR.Close();
     if (!ItemAdded) {
       TL.Clear();
       break;
     }
     if (ProgressCallback != null)
       ProgressCallback(null, (double) (i + 1) / EntryCount);
       }
       return TL;
 }
Example #14
0
 public Reference(BinaryReader byteFile)
 {
     this.Station = new Id(byteFile);
     this.East = byteFile.ReadUInt64();
     this.North = byteFile.ReadUInt64();
     this.Altitude = byteFile.ReadUInt32();
     this.Comment = byteFile.ReadString();
 }
 private void InternalRead(BinaryReader reader)
 {
     _gifTag0 = new GIFTag(reader);
     _trxPos = new TRXPOSRegister(reader);
     ulong trxPosAddress = reader.ReadUInt64();
     _trxReg = new TRXREGRegister(reader);
     ulong trxRegisterAddress = reader.ReadUInt64();
     _trxDir = new TRXDIRRegister(reader);
     ulong trxDirAddress = reader.ReadUInt64();
     _gifTag1 = new GIFTag(reader);
 }
Example #16
0
        public override void Deserialize(BinaryReader reader)
        {
            SimID = reader.ReadUInt32();
            Version = reader.ReadUInt16();

            HeadID = reader.ReadUInt64();
            BodyID = reader.ReadUInt64();
            SkinTone = reader.ReadByte();
            Gender = reader.ReadBoolean();
            Name = reader.ReadString();
        }
Example #17
0
        public bool Load()
        {            
            var FolderPath = string.Format(FOLDER_PATH, DriveInfo.VolumeSerialNumber);
            var FilePath = string.Format(FILE_PATH, DriveInfo.VolumeSerialNumber);
            var LogPath = string.Format(UPDATELOG_PATH, DriveInfo.VolumeSerialNumber);

            if (File.Exists(FolderPath) && File.Exists(FilePath) && File.Exists(LogPath))
            {
                using (FileStream stream = new FileStream(FolderPath, FileMode.Open))
                {
                    using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8))
                    {
                        while (reader.BaseStream.Position != reader.BaseStream.Length)
                        {
                            ulong frn = reader.ReadUInt64();
                            string name = reader.ReadString();
                            ulong parent_frn = reader.ReadUInt64();

                            FolderEntries[frn] = new FileNameAndFrn(name, parent_frn);
                        }                        
                    }
                }
                using (FileStream stream = new FileStream(FilePath, FileMode.Open))
                {
                    using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8))
                    {
                        while (reader.BaseStream.Position != reader.BaseStream.Length)
                        {
                            ulong frn = reader.ReadUInt64();
                            string name = reader.ReadString();
                            ulong parent_frn = reader.ReadUInt64();

                            FileEntries[frn] = new FileNameAndFrn(name, parent_frn);
                        }
                    }
                }
                using (FileStream stream = new FileStream(LogPath, FileMode.Open))
                {
                    using (BinaryReader reader = new BinaryReader(stream, Encoding.UTF8))
                    {
                        while (reader.BaseStream.Position != reader.BaseStream.Length)
                        {
                            long ticks = reader.ReadInt64();                            
                            Int64 usn = reader.ReadInt64();

                            UpdateLogs[new DateTime(ticks)] = usn;
                        }
                    }
                }      
                return true;
            }            
            return false;
        }
Example #18
0
 public void Read(Stream s)
 {
     BinaryReader br = new BinaryReader(s);
     version = br.ReadInt32();
     services = (Services)br.ReadUInt64();
     timestamp = br.ReadInt64();
     addr_recv = NetAddr.FromStream(s);
     addr_from = NetAddr.FromStream(s);
     nonce = br.ReadUInt64();
     user_agent = VarStr.FromStream(s);
     start_height = br.ReadInt32();
 }
Example #19
0
 public override void Deserialize(BinaryReader reader)
 {
     base.Deserialize(reader);
     Version = reader.ReadUInt16();
     RequesterID = reader.ReadUInt32();
     HeadID = reader.ReadUInt64();
     BodyID = reader.ReadUInt64();
     SkinTone = reader.ReadByte();
     Gender = reader.ReadBoolean();
     Name = reader.ReadString();
     Permissions = (VMTSOAvatarPermissions)reader.ReadByte();
 }
Example #20
0
 public AuthKey(BigInteger gab) {
     key = gab.ToByteArrayUnsigned();
     using(SHA1 hash = new SHA1Managed()) {
         using(MemoryStream hashStream = new MemoryStream(hash.ComputeHash(key), false)) {
             using(BinaryReader hashReader = new BinaryReader(hashStream)) {
                 auxHash = hashReader.ReadUInt64();
                 hashReader.ReadBytes(4);
                 keyId = hashReader.ReadUInt64();
             }
         }
     }
 }
Example #21
0
 public AuthKey(byte[] data) {
     key = data;
     using (SHA1 hash = new SHA1Managed()) {
         using (MemoryStream hashStream = new MemoryStream(hash.ComputeHash(key), false)) {
             using (BinaryReader hashReader = new BinaryReader(hashStream)) {
                 auxHash = hashReader.ReadUInt64();
                 hashReader.ReadBytes(4);
                 keyId = hashReader.ReadUInt64();
             }
         }
     }
 }
Example #22
0
        public Appearance(byte[] FileData)
        {
            MemoryStream MemStream = new MemoryStream(FileData);
            BinaryReader Reader = new BinaryReader(MemStream);

            m_Version = Endian.SwapUInt32(Reader.ReadUInt32());
            m_ThumbnailID = Endian.SwapUInt64(Reader.ReadUInt64());
            uint Count = Endian.SwapUInt32(Reader.ReadUInt32());

            for (int i = 0; i < Count; i++)
                BindingIDs.Add(Endian.SwapUInt64(Reader.ReadUInt64()));
        }
Example #23
0
        public SdkMeshIndexBuffer(BinaryReader reader) {

            NumIndices = reader.ReadUInt64();
            SizeBytes = reader.ReadUInt64();
            IndexType = reader.ReadUInt32();
            reader.ReadUInt32(); // padding
            DataOffset = reader.ReadUInt64();

            Indices = new List<int>();
            if (SizeBytes > 0) {
                ReadIndices(reader);
            }
        }
Example #24
0
 public SdkMeshSubset(BinaryReader reader) {
     Name = Encoding.Default.GetString(reader.ReadBytes(MaxSubsetName));
     if (Name[0] == '\0') {
         Name = string.Empty;
     }
     MaterialID = reader.ReadUInt32();
     PrimitiveType = reader.ReadUInt32();
     reader.ReadUInt32();
     IndexStart = reader.ReadUInt64();
     IndexCount = reader.ReadUInt64();
     VertexStart = reader.ReadUInt64();
     VertexCount = reader.ReadUInt64();
 }
 void ISteamSerializable.Deserialize(Stream stream)
 {
     try
     {
         BinaryReader br = new BinaryReader(stream);
         Invitee = br.ReadUInt64();
         GroupID = br.ReadUInt64();
         UnknownInfo = br.ReadBoolean();
     }//try
     catch
     {
         throw new IOException();
     }//catch
 }
        /// <summary>
        /// Creates a new outfit.
        /// </summary>
        /// <param name="FileData">The data to create the outfit from.</param>
        public Outfit(byte[] FileData)
        {
            MemoryStream MemStream = new MemoryStream(FileData);
            BinaryReader Reader = new BinaryReader(MemStream);

            m_Version = Endian.SwapUInt32(Reader.ReadUInt32());

            Reader.ReadUInt32(); //Unknown.

            m_LightAppearanceID = Endian.SwapUInt64(Reader.ReadUInt64());
            m_MediumAppearanceID = Endian.SwapUInt64(Reader.ReadUInt64());
            m_DarkAppearanceID = Endian.SwapUInt64(Reader.ReadUInt64());

            Reader.Close();
        }
        public void TestMethod()
        {
            MemoryStream stream = new MemoryStream(100000);

            BinaryWriter writer = new BinaryWriter(stream);
            writer.Write(UInt16.MinValue, true);
            writer.Write(UInt16.MaxValue, true);
            writer.Write(UInt32.MinValue, true);
            writer.Write(UInt32.MaxValue, true);
            writer.Write(UInt64.MinValue, true);
            writer.Write(UInt64.MaxValue, true);

            writer.Write(Int16.MinValue, true);
            writer.Write(Int16.MaxValue, true);
            writer.Write(Int32.MinValue, true);
            writer.Write(Int32.MaxValue, true);
            writer.Write(Int64.MinValue, true);
            writer.Write(Int64.MaxValue, true);

            writer.Write(Single.MinValue, true);
            writer.Write(Single.MaxValue, true);
            writer.Write(Double.MinValue, true);
            writer.Write(Double.MaxValue, true);

            writer.Flush();

            BinaryReader reader = new BinaryReader(stream);
            stream.Seek(0, SeekOrigin.Begin);

            Assert.AreEqual(UInt16.MinValue, reader.ReadUInt16(true));
            Assert.AreEqual(UInt16.MaxValue, reader.ReadUInt16(true));
            Assert.AreEqual(reader.ReadUInt32(true), UInt32.MinValue);
            Assert.AreEqual(reader.ReadUInt32(true), UInt32.MaxValue);
            Assert.AreEqual(reader.ReadUInt64(true), UInt64.MinValue);
            Assert.AreEqual(reader.ReadUInt64(true), UInt64.MaxValue);

            Assert.AreEqual(reader.ReadInt16(true), Int16.MinValue);
            Assert.AreEqual(reader.ReadInt16(true), Int16.MaxValue);
            Assert.AreEqual(reader.ReadInt32(true), Int32.MinValue);
            Assert.AreEqual(reader.ReadInt32(true), Int32.MaxValue);
            Assert.AreEqual(reader.ReadInt64(true), Int64.MinValue);
            Assert.AreEqual(reader.ReadInt64(true), Int64.MaxValue);

            Assert.AreEqual(reader.ReadSingle(true), Single.MinValue);
            Assert.AreEqual(reader.ReadSingle(true), Single.MaxValue);
            Assert.AreEqual(reader.ReadDouble(true), Double.MinValue);
            Assert.AreEqual(reader.ReadDouble(true), Double.MaxValue);
        }
Example #28
0
		/// <summary>
		/// Stream constructor.
		/// </summary>
		/// <param name="stream">The stream that contains the HeaderSector data.</param>
		/// <exception cref="Exception">Throws an exception if it encounters any invalid data in the stream.</exception>
		public HeaderSector(Stream stream) 
		{
			Debug.Assert(stream.Length >= Constants.SECTOR_SIZE);
			BinaryReader reader = new BinaryReader(stream);

			ulong magicNumber = reader.ReadUInt64();
			if(magicNumber != MAGIC_NUMBER)
				throw new Exception("Invalid header magic number.");

			_clsId = new Guid(reader.ReadBytes(16));
			_minorVer = reader.ReadUInt16();
			_dllVer = reader.ReadUInt16();
			_byteOrder = reader.ReadUInt16();
			_sectShift = reader.ReadUInt16();
			_miniSectShift = reader.ReadUInt16();
			_reserved = reader.ReadUInt16();
			_reserved1 = reader.ReadUInt32();
			_reserved2 = reader.ReadUInt32();
			_sectFatCount = reader.ReadUInt32();
			_sectDirStart = new Sect(reader.ReadUInt32());
			_signature = reader.ReadUInt32();
			_miniSectorCutoff = reader.ReadUInt32();
			_sectMiniFatStart = new Sect(reader.ReadUInt32());
			_sectMiniFatCount = reader.ReadUInt32();
			_sectDifStart = new Sect(reader.ReadUInt32());
			_sectDifCount = reader.ReadUInt32();

			for(int i = 0; i < _sectFat.Length; ++i)
				_sectFat[i] = new Sect(reader.ReadUInt32());
		}
Example #29
0
        public async Task<ImageInfo[]> LoadFromDbAsync(string dbFileName)
        {
            var file = await FileSystem.Current.GetFileFromPathAsync(dbFileName).ConfigureAwait(false);
            if (file == null)
                throw new FileNotFoundException();
            using (var fs = await file.OpenAsync(FileAccess.Read).ConfigureAwait(false))
            using (var gz = new GZipStream(fs, CompressionMode.Decompress))
            using (var br = new BinaryReader(gz))
            {
                long count = br.ReadInt32();
                _info = new ImageInfo[count];

                for (var i = 0; i < count; i++)
                {
                    var hash = br.ReadUInt64();
                    var titleId = br.ReadUInt16();
                    var episodeId = br.ReadUInt16();
                    var frame = br.ReadUInt32();
                    _info[i] = new ImageInfo
                    {
                        Hash = hash,
                        TitleId = titleId,
                        EpisodeId = episodeId,
                        Frame = frame
                    };
                }
            }
            return _info;
        }
Example #30
0
        public Resource Read()
        {
            using (this.reader = new BinaryReader(stream))
            {
                LSBHeader header;
                header.signature = reader.ReadUInt32();
                if (header.signature != LSBHeader.Signature)
                    throw new InvalidFormatException(String.Format("Illegal signature in header; expected {0}, got {1}", LSBHeader.Signature, header.signature));

                header.totalSize = reader.ReadUInt32();
                if (stream.Length != header.totalSize)
                    throw new InvalidFormatException(String.Format("Invalid LSB file size; expected {0}, got {1}", header.totalSize, stream.Length));

                header.bigEndian = reader.ReadUInt32();
                // The game only uses little-endian files on all platforms currently and big-endian support isn't worth the hassle
                if (header.bigEndian != 0)
                    throw new InvalidFormatException("Big-endian LSB files are not supported");

                header.unknown = reader.ReadUInt32();
                header.metadata.timestamp = reader.ReadUInt64();
                header.metadata.majorVersion = reader.ReadUInt32();
                header.metadata.minorVersion = reader.ReadUInt32();
                header.metadata.revision = reader.ReadUInt32();
                header.metadata.buildNumber = reader.ReadUInt32();

                ReadStaticStrings();

                Resource rsrc = new Resource();
                rsrc.Metadata = header.metadata;
                ReadRegions(rsrc);
                return rsrc;
            }
        }