ReadBytes() public méthode

public ReadBytes ( int count ) : byte[]
count int
Résultat byte[]
        internal override void Read(BinaryReader reader)
        {
            Version = reader.ReadUInt16();
            VersionNeededToExtract = reader.ReadUInt16();
            Flags = (HeaderFlags) reader.ReadUInt16();
            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
            LastModifiedTime = reader.ReadUInt16();
            LastModifiedDate = reader.ReadUInt16();
            Crc = reader.ReadUInt32();
            CompressedSize = reader.ReadUInt32();
            UncompressedSize = reader.ReadUInt32();
            ushort nameLength = reader.ReadUInt16();
            ushort extraLength = reader.ReadUInt16();
            ushort commentLength = reader.ReadUInt16();
            DiskNumberStart = reader.ReadUInt16();
            InternalFileAttributes = reader.ReadUInt16();
            ExternalFileAttributes = reader.ReadUInt32();
            RelativeOffsetOfEntryHeader = reader.ReadUInt32();

            byte[] name = reader.ReadBytes(nameLength);
            Name = DecodeString(name);
            byte[] extra = reader.ReadBytes(extraLength);
            byte[] comment = reader.ReadBytes(commentLength);
            Comment = DecodeString(comment);
            LoadExtra(extra);
        }
        private void TransformToPNG()
        {
            using (MemoryStream ms = new MemoryStream(this.rawData))
            {
                BinaryReader r = new BinaryReader(ms);
                Bitmap colorImage = new Bitmap(ms);
                ms.Position = 0;
                r.ReadBytes(24);
                if (r.ReadUInt32() == 0x41464C41U)
                {
                    int length = r.ReadInt32();
                    length = (int)((length & 0xFF000000) >> 24) | (int)((length & 0x00FF0000) >> 8) | (int)((length & 0x0000FF00) << 8) | (int)((length & 0x000000FF) << 24);
                    using (MemoryStream alphaStream = new MemoryStream(r.ReadBytes(length)))
                    {
                        Bitmap alphaImage = new Bitmap(alphaStream);
                        if (colorImage.Width != alphaImage.Width || colorImage.Height != alphaImage.Height) throw new InvalidDataException("Not a proper TS4 Thumbnail image");
                        //int[,] rawImage = new int[colorImage.Width, colorImage.Height];
                        //for (int y = 0; y < colorImage.Height; y++)
                        //{
                        //    for (int x = 0; x < colorImage.Width; x++)
                        //    {
                        //        Color color = colorImage.GetPixel(x, y);
                        //        byte alpha = alphaImage.GetPixel(x, y).R;
                        //        rawImage[x, y] = Color.FromArgb(alpha, color).ToArgb();

                        //    }
                        //}
                        colorImage = UpdateAlpha(colorImage, alphaImage);

                        this.Image = colorImage;
                    }
                }
                this.Image = colorImage;
            }
        }
Exemple #3
0
 public BAR(Stream file)
 {
     if (!file.CanRead || !file.CanSeek)
     {
         throw new NotSupportedException("Cannot read or seek in stream");
     }
     using (var br = new BinaryReader(file))
     {
         if (file.Length < 16 || br.ReadUInt32() != 0x01524142)
         {
             throw new InvalidDataException("Invalid signature");
         }
         int fileC = br.ReadInt32();
         fileList = new List<BARFile>(fileC);
         Debug.WriteLine("Loading BAR with " + fileC + " files");
         file.Position = 16;
         for (int i = 0; i < fileC; i++)
         {
             var bf = new BARFile();
             bf.type = br.ReadUInt32();
             {
                 byte[] b = br.ReadBytes(4);
                 Buffer.BlockCopy(b, 0, bf._id, 0, 4);
             }
             long lpos = file.Position + 8;
             uint pos = br.ReadUInt32();
             int len = br.ReadInt32();
             file.Position = pos;
             bf.data = br.ReadBytes(len);
             fileList.Add(bf);
             file.Position = lpos;
         }
     }
     //BinaryReader should close file
 }
 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;
 }
        public ITI(string filename)
        {
            impi fil = new impi();
            // FIXME: Possible re-use
            this.noteName = MidiHelper.OctaveMacro();

            using (FileStream rop = new FileStream(
                filename,
                FileMode.Open,
                FileAccess.Read,
                FileShare.ReadWrite))
                using (BinaryReader bob = new BinaryReader(rop))
            {
                byte[] mal = bob.ReadBytes(Marshal.SizeOf(fil));
                this.iti_instrument = IOHelper.xread<impi>(fil,mal);
                // Get Samples
                {
                    impx[] samp = new impx[iti_instrument.impNumberOfSamples];
                    for (int i = 0; i < iti_instrument.impNumberOfSamples;i++)
                        samp[i] = IOHelper.xread<impx>(
                            samp[i],
                            bob.ReadBytes(Marshal.SizeOf(samp[i]))
                        );
                    this.ITI_SMPH = samp;
                }

                bob.Close();
                rop.Close();
                mal = null;
            }
        }
Exemple #6
0
        static void Main(string[] args)
        {
            OpenFileDialog OpenFile = new OpenFileDialog();
            OpenFile.Multiselect = false;
            OpenFile.Title = "Cartridge";
            OpenFile.Filter = "GBA Files (.gba)|*.gba";
            OpenFile.FilterIndex = 1;

            string Cartridge;

            Console.WriteLine("Gneiss - Game Boy Advance Cartridge Reader.");
            Console.CursorVisible = false;

            if (OpenFile.ShowDialog() == DialogResult.OK)
            {
                Cartridge = OpenFile.FileName;
                BinaryReader BR = new BinaryReader(File.OpenRead(Cartridge));

                BR.BaseStream.Seek(0xA0, SeekOrigin.Begin);
                Console.WriteLine("\n\nCartridge Name: {0}", Encoding.UTF8.GetString(BR.ReadBytes(12)));

                BR.BaseStream.Seek(0xAC, SeekOrigin.Begin);
                Console.WriteLine("Serial: {0}", Encoding.UTF8.GetString(BR.ReadBytes(4)));

                BR.BaseStream.Seek(0x108, SeekOrigin.Begin);
                Console.WriteLine("Name: {0}", Encoding.UTF8.GetString(BR.ReadBytes(24)));
                Console.Read();
            }
        }
Exemple #7
0
        public static byte[] GetWaveData(BinaryReader file, ref WaveInfo waveInfo)
        {
            byte[] returnData;

            //Read the wave file header from the buffer. 

            waveInfo.ChunkID = file.ReadInt32();
            waveInfo.FileSize = file.ReadInt32();
            waveInfo.RiffType = file.ReadInt32();
            waveInfo.FormatID = file.ReadInt32();
            waveInfo.FormatSize = file.ReadInt32();
            waveInfo.FormatCode = file.ReadInt16();
            waveInfo.Channels = file.ReadInt16();
            waveInfo.SampleRate = file.ReadInt32();
            waveInfo.FormatAverageBps = file.ReadInt32();
            waveInfo.FormatBlockAlign = file.ReadInt16();
            waveInfo.BitDepth = file.ReadInt16();

            if (waveInfo.FormatSize == 18)
            {
                // Read any extra values
                waveInfo.FormatExtraSize = file.ReadInt16();
                file.ReadBytes(waveInfo.FormatExtraSize);
            }

            waveInfo.DataID = file.ReadInt32();
            waveInfo.DataSize = file.ReadInt32();


            // Store the audio data of the wave file to a byte array. 

            returnData = file.ReadBytes(waveInfo.DataSize);

            return returnData;
        }
 public static bool ReadFile(string FileName)
 {
     LCMeshReader.OpenedFile = FileName;
       LCMeshReader.pMesh = new tMeshContainer();
       BinaryReader b = new BinaryReader( new FileStream(FileName, FileMode.Open, FileAccess.Read, FileShare.Read));
       LCMeshReader.pMesh.HeaderInfo = new tHeaderInfo();
       LCMeshReader.pMesh.HeaderInfo.Format = b.ReadBytes(4);
       LCMeshReader.pMesh.HeaderInfo.Version = b.ReadInt32();
       LCMeshReader.pMesh.HeaderInfo.MeshDataSize = b.ReadInt32();
       LCMeshReader.pMesh.HeaderInfo.MeshCount = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.VertexCount = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.JointCount = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.TextureMaps = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.NormalCount = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.ObjCount = b.ReadUInt32();
       LCMeshReader.pMesh.HeaderInfo.UnknownCount = b.ReadUInt32();
       LCMeshReader.pMesh.FileName = b.ReadBytes(b.ReadInt32());
       LCMeshReader.pMesh.Scale = b.ReadSingle();
       LCMeshReader.pMesh.Value1 = b.ReadUInt32();
       LCMeshReader.pMesh.FilePath = FileName;
       bool flag = false;
       if (LCMeshReader.pMesh.HeaderInfo.Version == 16)
       {
     if (LCMeshReader.ReadV10(b, b.BaseStream.Position))
       flag = true;
       }
       else if (LCMeshReader.pMesh.HeaderInfo.Version == 17 && LCMeshReader.ReadV11(b, b.BaseStream.Position))
     flag = true;
       b.Close();
       return flag;
 }
        /// <summary>
        /// The read.
        /// </summary>
        /// <param name="client">
        /// </param>
        /// <param name="packet">
        /// </param>
        public static void Read(Client client, byte[] packet)
        {
            LogUtil.Debug(DebugInfoDetail.Network, "\r\nReceived:\r\n" + HexOutput.Output(packet));

            MemoryStream m_stream = new MemoryStream(packet);
            BinaryReader m_reader = new BinaryReader(m_stream);

            // now we should do password check and then send OK or Error
            // sending OK now
            m_stream.Position = 8;

            short userNameLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string userName = Encoding.ASCII.GetString(m_reader.ReadBytes(userNameLength));
            short loginKeyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt16());
            string loginKey = Encoding.ASCII.GetString(m_reader.ReadBytes(loginKeyLength));

            LoginEncryption loginEncryption = new LoginEncryption();

            if (loginEncryption.IsValidLogin(loginKey, client.ServerSalt, userName))
            {
                client.IsBot = true;
                byte[] chars = AccountCharacterList.Create(userName);
                LogUtil.Debug(DebugInfoDetail.Network, "\r\nReceived:\r\n" + HexOutput.Output(chars));

                client.Send(chars);
            }
            else
            {
                byte[] loginerr = LoginError.Create();
                client.Send(loginerr);
                client.Server.DisconnectClient(client);
            }
        }
        public static ConnectionSettings Read(byte[] data)
        {
            var cs = new ConnectionSettings();
            using (var ms = new MemoryStream(data))
            using (var br = new BinaryReader(ms))
            {
                cs.Version = br.ReadInt32();
                cs.Counter = br.ReadInt32();
                cs.Autodetect = (Autodetect)br.ReadInt32();

                var len = br.ReadInt32();
                cs.ProxyServer = Utf8.GetString(br.ReadBytes(len));

                len = br.ReadInt32();
                cs.ExtraData = Utf8.GetString(br.ReadBytes(len));

                len = br.ReadInt32();
                cs.AutodetectScript = Utf8.GetString(br.ReadBytes(len));

                // So damn lazy.
                using (var ms2 = new MemoryStream())
                {
                    var ba = new byte[Environment.SystemPageSize];
                    while ((len = br.Read(ba, 0, ba.Length)) != 0)
                    {
                        ms2.Write(ba, 0, len);
                    }

                    cs.Junk = ms2.ToArray();
                }
            }

            return cs;
        }
Exemple #11
0
 /// <summary>
 ///     Creatis this object and sets all it properties
 /// </summary>
 /// <param name="binaryReader"></param>
 internal CLSID(BinaryReader binaryReader)
 {
     Data1 = binaryReader.ReadBytes(4).Reverse().ToArray();
     Data2 = binaryReader.ReadBytes(2).Reverse().ToArray();
     Data3 = binaryReader.ReadBytes(2).Reverse().ToArray();
     Data4 = binaryReader.ReadBytes(8).Reverse().ToArray();
 }
        public static Certificate GetSignedCertificate(Uri apiUri, CertificateStore certStore)
        {
            using (WebClient client = new WebClient())
            {
                client.Headers.Add("User-Agent", GetUserAgent());

                byte[] data = client.DownloadData(apiUri.AbsoluteUri + "?cmd=dlc&email=" + certStore.Certificate.IssuedTo.EmailAddress.Address);

                using (BinaryReader bR = new BinaryReader(new MemoryStream(data)))
                {
                    int errorCode = bR.ReadInt32();
                    if (errorCode != 0)
                    {
                        string message = Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadInt32()));
                        string remoteStackTrace = Encoding.UTF8.GetString(bR.ReadBytes(bR.ReadInt32()));

                        throw new BitChatException(message);
                    }

                    Certificate cert = new Certificate(bR);

                    if (!cert.IssuedTo.EmailAddress.Equals(certStore.Certificate.IssuedTo.EmailAddress) || (cert.PublicKeyEncryptionAlgorithm != certStore.PrivateKey.Algorithm) || (cert.PublicKeyXML != certStore.PrivateKey.GetPublicKey()))
                        throw new BitChatException("Invalid signed certificate received. Please try again.");

                    return cert;
                }
            }
        }
Exemple #13
0
        public void Deserialize(byte[] buffer)
        {
            if (buffer.Length == 240)
            {
                MemoryStream MS = new MemoryStream(buffer);
                BinaryReader BR = new BinaryReader(MS);

                ushort length = BR.ReadUInt16();
                if (length == 240)
                {
                    ushort type = BR.ReadUInt16();
                    if (type == 1124)
                    {
                        Username = Encoding.ASCII.GetString(BR.ReadBytes(16));
                        Username = Username.Replace("\0", "");
                        BR.ReadBytes(112);
                        Password = Encoding.ASCII.GetString(BR.ReadBytes(16));
                        BR.ReadBytes(112);
                        Server = Encoding.ASCII.GetString(BR.ReadBytes(16));
                        Server = Server.Replace("\0", "");
                    }
                }
                BR.Close();
                MS.Close();
            }
        }
        public static void ReadBlendomatic(FileStream file)
        {
            BinaryReader reader = new BinaryReader(file);

            NumberOfBlendingModes = reader.ReadUInt32();
            NumberOfTiles = reader.ReadUInt32();

            BlendingModes = new Dictionary<byte, BlendingMode>();

            Console.WriteLine("Number of blending modes: " + NumberOfBlendingModes);
            Console.WriteLine("Number of tiles: " + NumberOfTiles);

            for (var i = 0; i < NumberOfBlendingModes; i++ )
            {
                BlendingMode mode;
                mode.TileSize = reader.ReadUInt32();
                mode.Tiles = new Dictionary<byte, byte[]>();

                var TileFlags = reader.ReadBytes(31); // all 1 wtf

                reader.ReadBytes((int)mode.TileSize * 4);
                for (var j = 0; j < NumberOfTiles; j++)
                {
                    mode.Tiles[(byte)j] = reader.ReadBytes((int)mode.TileSize);
                }

                BlendingModes[(byte)i] = mode;
            }
        }
        internal override void Read(BinaryReader reader)
        {
            Version = reader.ReadUInt16();
            VersionNeededToExtract = reader.ReadUInt16();
            Flags = (HeaderFlags) reader.ReadUInt16();
            CompressionMethod = (ZipCompressionMethod) reader.ReadUInt16();
            LastModifiedTime = reader.ReadUInt16();
            LastModifiedDate = reader.ReadUInt16();
            Crc = reader.ReadUInt32();
            CompressedSize = reader.ReadUInt32();
            UncompressedSize = reader.ReadUInt32();
            ushort nameLength = reader.ReadUInt16();
            ushort extraLength = reader.ReadUInt16();
            ushort commentLength = reader.ReadUInt16();
            DiskNumberStart = reader.ReadUInt16();
            InternalFileAttributes = reader.ReadUInt16();
            ExternalFileAttributes = reader.ReadUInt32();
            RelativeOffsetOfEntryHeader = reader.ReadUInt32();

            byte[] name = reader.ReadBytes(nameLength);
            Name = DecodeString(name);
            byte[] extra = reader.ReadBytes(extraLength);
            byte[] comment = reader.ReadBytes(commentLength);
            Comment = DecodeString(comment);
            LoadExtra(extra);

            var unicodePathExtra = Extra.FirstOrDefault(u => u.Type == ExtraDataType.UnicodePathExtraField);
            if (unicodePathExtra != null)
            {
                Name = ((ExtraUnicodePathExtraField)unicodePathExtra).UnicodeName;
            }
        }
        /// <summary>
        /// Creates a new FAR3Archive instance from a path.
        /// </summary>
        /// <param name="Path">The path to the archive.</param>
        public FAR3Archive(string Path)
        {
            m_ArchivePath = Path;

            if (isReadingSomething == false)
            {
                isReadingSomething = true;

                try
                {
                    m_Reader = new BinaryReader(File.Open(Path, FileMode.Open, FileAccess.Read, FileShare.Read));
                }
                catch (Exception)
                {
                    throw new FAR3Exception("Could not open the specified archive - " + Path + "! (FAR3Archive())");
                }

                string Header = Encoding.ASCII.GetString(m_Reader.ReadBytes(8));
                uint Version = m_Reader.ReadUInt32();

                if ((Header != "FAR!byAZ") || (Version != 3))
                {
                    throw new FAR3Exception("Archive wasn't a valid FAR V.3 archive! (FAR3Archive())");
                }

                uint ManifestOffset = m_Reader.ReadUInt32();
                m_ManifestOffset = ManifestOffset;

                m_Reader.BaseStream.Seek(ManifestOffset, SeekOrigin.Begin);

                uint NumFiles = m_Reader.ReadUInt32();

                for (int i = 0; i < NumFiles; i++)
                {
                    Far3Entry Entry = new Far3Entry();
                    Entry.DecompressedFileSize = m_Reader.ReadUInt32();
                    byte[] Dummy = m_Reader.ReadBytes(3);
                    Entry.CompressedFileSize = (uint)((Dummy[0] << 0) | (Dummy[1] << 8) | (Dummy[2]) << 16);
                    Entry.DataType = m_Reader.ReadByte();
                    Entry.DataOffset = m_Reader.ReadUInt32();
                    //Entry.HasFilename = m_Reader.ReadUInt16();
                    Entry.IsCompressed = m_Reader.ReadByte();
                    Entry.AccessNumber = m_Reader.ReadByte();
                    Entry.FilenameLength = m_Reader.ReadUInt16();
                    Entry.TypeID = m_Reader.ReadUInt32();
                    Entry.FileID = m_Reader.ReadUInt32();
                    Entry.Filename = Encoding.ASCII.GetString(m_Reader.ReadBytes(Entry.FilenameLength));

                    if (!m_Entries.ContainsKey(Entry.Filename))
                        m_Entries.Add(Entry.Filename, Entry);
                    m_EntriesList.Add(Entry);

                    m_EntryByID.Add(Entry.FileID, Entry); //isn't this a bad idea? i have a feeling this is a bad idea...
                }

                //Keep the stream open, it helps peformance.
                //m_Reader.Close();
                isReadingSomething = false;
            }
        }
        /// <summary> Parses the Replay.Messages.Events file. </summary>
        /// <param name="buffer"> Buffer containing the contents of the replay.messages.events file. </param>
        /// <returns> A list of chat messages parsed from the buffer. </returns>
        public static void Parse(Replay replay, byte[] buffer)
        {
            using (var stream = new MemoryStream(buffer))
            {
                using (var reader = new BinaryReader(stream))
                {
                    int totalTime = 0;
                    while (reader.BaseStream.Position < reader.BaseStream.Length)
                    {
                        // While not EOF
                        var message = new ChatMessage();

                        var time = ParseTimestamp(reader);

                        // sometimes we only have a header for the message
                        if (reader.BaseStream.Position >= reader.BaseStream.Length) 
                            break;

                        message.PlayerId = reader.ReadByte();

                        // I believe this 'PlayerId' is an index for this client list, which can include observers
                        // var player = replay.ClientList[message.PlayerId];

                        totalTime += time;
                        var opCode = reader.ReadByte();

                        if (opCode == 0x80)
                            reader.ReadBytes(4);
                        else if (opCode == 0x83)
                            reader.ReadBytes(8);
                        else if (opCode == 2 && message.PlayerId <= 10)
                        {
                            if (message.PlayerId == 80)
                                continue;

                            message.MessageTarget = (ChatMessageTarget)(opCode & 7);
                            var length = reader.ReadByte();

                            if ((opCode & 8) == 8)
                                length += 64;

                            if ((opCode & 16) == 16)
                                length += 128;

                            message.Message = Encoding.UTF8.GetString(reader.ReadBytes(length));
                        }
                        else
                        {
                            
                        }

                        if (message.Message != null)
                        {
                            message.Timestamp = new TimeSpan(0, 0, (int)Math.Round(totalTime / 16.0));
                            replay.ChatMessages.Add(message);
                        }
                    }
                }
            }
        }
Exemple #18
0
 internal void Read(BinaryReader reader, float CoordZ, float scale)
 {
     SkinVertIndex = BitConverter.ToUInt32(reader.ReadBytes(4), 0);
     for (int i = 0; i < SkinVertPos.Length; i++)
         SkinVertPos[i] = BitConverter.ToSingle(reader.ReadBytes(4), 0)* scale;
     SkinVertPos[2] *= CoordZ;
 }
 public void Read(BinaryReader reader, float CoordZ, float scale)
 {
     Position = new float[3];
     for (int i = 0; i < Position.Length; i++)
     {
         Position[i] = BitConverter.ToSingle(reader.ReadBytes(4), 0) * scale;
     }
     NormalVector = new float[3];
     for (int i = 0; i < NormalVector.Length; i++)
     {
         NormalVector[i] = BitConverter.ToSingle(reader.ReadBytes(4), 0);
     }
     UV = new float[2];
     for (int i = 0; i < UV.Length; i++)
     {
         UV[i] = BitConverter.ToSingle(reader.ReadBytes(4), 0);
     }
     BoneNum = new WORD[2];
     for (int i = 0; i < BoneNum.Length; i++)
     {
         BoneNum[i] = BitConverter.ToUInt16(reader.ReadBytes(2), 0);
     }
     BoneWeight = reader.ReadByte();
     NonEdgeFlag = reader.ReadByte();
     Position[2] *= CoordZ;
     NormalVector[2] *= CoordZ;
 }
Exemple #20
0
        private static Model LoadFromBIN(string pModelFile)
        {
            BinaryReader reader = new BinaryReader(new FileStream(pModelFile, FileMode.Open));

            int numberOfVertices = reader.ReadInt32();
            int floatsPerVertex = 6;

            Vertices = new float[numberOfVertices * floatsPerVertex];

            byte[]  byteArray = new byte[Vertices.Length * sizeof(float)];
            byteArray = reader.ReadBytes(byteArray.Length);

            Buffer.BlockCopy(byteArray, 0, Vertices, 0, byteArray.Length);

            int numberOfTriangles = reader.ReadInt32();

            Indices = new int[numberOfTriangles * 3];

            byteArray = new byte[Indices.Length * sizeof(int)];
            byteArray = reader.ReadBytes(Indices.Length * sizeof(int));
            Buffer.BlockCopy(byteArray, 0, Indices, 0, byteArray.Length);

            reader.Close();

            ModelMesh mesh = new ModelMesh(Vertices, Indices, false);
            List<ModelMesh> meshes = new List<ModelMesh>();
            meshes.Add(mesh);
            return new Model(meshes);
        }
Exemple #21
0
        public RegistryHive(string file)
        {
            if (!File.Exists(file))
                throw new FileNotFoundException();

            using (FileStream stream = File.OpenRead(file))
            {
                using (BinaryReader reader = new BinaryReader(stream))
                {
                    byte[] buf = reader.ReadBytes(4);

                    if (buf[0] != 'r' || buf[1] != 'e' || buf[2] != 'g' || buf[3] != 'f')
                        throw new NotSupportedException();

                    reader.ReadBytes(8);
                    buf = reader.ReadBytes(8);

                    long timestamp = BitConverter.ToInt64(buf, 0);
                    this.WasExported = (timestamp == 0) ? true : false;

                    //fast-forward
                    reader.BaseStream.Position += (0x1000 + 0x20 + 4)-reader.BaseStream.Position;

                    this.RootKey = new NodeKey(reader);
                }
            }
        }
        internal NameResolutionRecord(BinaryReader reader)
        {
            UInt16 type = reader.ReadUInt16();
            int valueLength = reader.ReadUInt16();

            if (type != EndRecordType)
            {
                int entriesLength = valueLength;

                if (type == Ip6RecordType)
                {
                    this.IsIpVersion6 = true;
                    this.IpAddress = reader.ReadBytes(Ip6Length);
                    entriesLength -= Ip6Length;
                }
                else
                {
                    this.IsIpVersion6 = false;
                    this.IpAddress = reader.ReadBytes(Ip4Length);
                    entriesLength -= Ip4Length;
                }
                this.DnsEntries = this.ReadDnsEntries(reader, entriesLength);

                int remainderLength = valueLength % ValueAlignmentBoundary;
                if (remainderLength > 0)
                {
                    reader.ReadBytes(ValueAlignmentBoundary - remainderLength);		// Read fill bytes to boundary.
                }
            }
        }
        public void ByteArraySegmentedStream_ReadBytesTest()
        {
            var arr = new byte[100];
            for (byte i = 0; i < 100; i++)
                arr[i] = i;

            var stream = new ByteArraySegmentedStream(true);
            stream.AddSegment(new ArraySegment<byte>(arr, 0, 10));
            stream.AddSegment(new ArraySegment<byte>(arr, 10, 25));
            stream.AddSegment(new ArraySegment<byte>(arr, 5, 10));

            var reader = new BinaryReader(stream);

            var bs = reader.ReadBytes(5);
            Assert.AreEqual(bs.Length, 5);
            for (byte i = 0; i < 5; i++)
                Assert.AreEqual(i, bs[i]);

            bs = reader.ReadBytes(10);
            Assert.AreEqual(bs.Length, 10);
            for (byte i = 0; i < 10; i++)
                Assert.AreEqual(i + 5, bs[i]);

            bs = reader.ReadBytes(100);
            Assert.AreEqual(bs.Length, 30);
            for (byte i = 0; i < 20; i++)
                Assert.AreEqual(i + 15, bs[i]);
            for (byte i = 0; i < 10; i++)
                Assert.AreEqual(i + 5, bs[i + 20]);
        }
Exemple #24
0
        public RPF7File(Stream inputStream, String filname = "")
        {
            this.Filename = filname;
            Stream = inputStream;

            Info = new Structs.RPF7Header(Stream);

            if (new string(Info.Magic) != "RPF7")
            {
                throw new Exception("Invalid RPF Magic");
            }

            sixteenRoundsDecrypt = (Info.Flag >> 28) == 0xf;

            if (sixteenRoundsDecrypt)
            {
                throw new Exception("Needed to be tested first");
            }

            using (BinaryReader binaryStream = new BinaryReader(AES.DecryptStream(new StreamKeeper(this.Stream), sixteenRoundsDecrypt)))
            {
                MemoryStream entriesInfo = new MemoryStream(binaryStream.ReadBytes(0x10 * Info.EntriesCount));
                MemoryStream filenames = new MemoryStream(binaryStream.ReadBytes(Info.EntriesNamesLength));
                this.Root = Entry.CreateFromHeader(new Structs.RPF7EntryInfoTemplate(entriesInfo), this, entriesInfo, filenames);
            }

            if (!(this.Root is DirectoryEntry))
            {
                throw new Exception("Expected root to be directory");
            }
        }
Exemple #25
0
		public FDSFile(BinaryReader r)
		{
			byte[] tmp = r.ReadBytes(4);
			int numdisks;
			if (tmp.SequenceEqual(Check))
			{
				numdisks = r.ReadByte();
				ExtraData = r.ReadBytes(11);
			}
			else if (tmp.SequenceEqual(CheckAlt))
			{
				// compensate (won't write identically)
				r.BaseStream.Seek(0, SeekOrigin.Begin);
				numdisks = (int)(r.BaseStream.Length / 65500);
				ExtraData = new byte[11];
			}
			else
			{
				throw new InvalidOperationException("Bad Header!");
			}
			if (r.BaseStream.Length - r.BaseStream.Position != numdisks * 65500)
				throw new InvalidOperationException("Bad File Length!");
			while (numdisks > 0)
			{
				Disks.Add(new FDSDisk(r));
				numdisks--;
			}
		}
Exemple #26
0
        public static byte[] UncompressStream(Stream stream, int filesize, int memsize)
        {
            BinaryReader r = new BinaryReader(stream);
            long end = stream.Position + filesize;

            byte[] uncdata = new byte[memsize];
            BinaryWriter bw = new BinaryWriter(new MemoryStream(uncdata));

            byte[] data = r.ReadBytes(2);
            if (checking) if (data.Length != 2)
                    throw new InvalidDataException("Hit unexpected end of file at " + stream.Position);

            int datalen = (((data[0] & 0x80) != 0) ? 4 : 3) * (((data[0] & 0x01) != 0) ? 2 : 1);
            data = r.ReadBytes(datalen);
            if (checking) if (data.Length != datalen)
                    throw new InvalidDataException("Hit unexpected end of file at " + stream.Position);

            long realsize = 0;
            for (int i = 0; i < data.Length; i++) realsize = (realsize << 8) + data[i];

            if (checking) if (realsize != memsize)
                    throw new InvalidDataException(String.Format(
                        "Resource data indicates size does not match index at 0x{0}.  Read 0x{1}.  Expected 0x{2}.",
                        stream.Position.ToString("X8"), realsize.ToString("X8"), memsize.ToString("X8")));

            while (stream.Position < end) { Dechunk(stream, bw); }

            if (checking) if (bw.BaseStream.Position != memsize)
                    throw new InvalidDataException(String.Format("Read 0x{0:X8} bytes.  Expected 0x{1:X8}.", bw.BaseStream.Position, memsize));

            bw.Close();

            return uncdata;
        }
Exemple #27
0
        public InstallShieldPackage(string filename, int priority)
        {
            this.priority = priority;
            s = FileSystem.Open(filename);

            // Parse package header
            BinaryReader reader = new BinaryReader(s);
            uint signature = reader.ReadUInt32();
            if (signature != 0x8C655D13)
                throw new InvalidDataException("Not an Installshield package");

            reader.ReadBytes(8);
            /*var FileCount = */reader.ReadUInt16();
            reader.ReadBytes(4);
            /*var ArchiveSize = */reader.ReadUInt32();
            reader.ReadBytes(19);
            var TOCAddress = reader.ReadInt32();
            reader.ReadBytes(4);
            var DirCount = reader.ReadUInt16();

            // Parse the directory list
            s.Seek(TOCAddress, SeekOrigin.Begin);
            BinaryReader TOCreader = new BinaryReader(s);
            for (var i = 0; i < DirCount; i++)
                ParseDirectory(TOCreader);
        }
Exemple #28
0
        public void UOExtPacket(IClientPeer peer, byte header, byte[] buffer, int offset, short length)
        {
            MemoryStream ms = new MemoryStream(buffer, offset, length);
            BinaryReader br = new BinaryReader(ms);

            byte sequence = br.ReadByte();

            switch (sequence)
            {
                case (0x00):
                    byte version = br.ReadByte();
                    byte[] uoextmd5 = br.ReadBytes(16);
                    byte[] uoextguimd5 = br.ReadBytes(16);
                    if (version != 0)
                    {
                        peer.Close();
                    }
                    else
                    {

                        if (!ByteArrayCompare(uoextmd5, Dll.UOExt.MD5))
                        {
                            peer.Send(new Handshake(0x01));
                            peer.Send(Dll.UOExt.SimpleHeader);
                            foreach (DllContent dc in Dll.UOExt.Content)
                            {
                                peer.Send(dc);
                            }
                            return;
                        }
                        else if (!ByteArrayCompare(uoextguimd5, Dll.UOExtGUI.MD5))
                        {
                            peer.Send(new Handshake(0x02));
                            peer.Send(Dll.UOExtGUI.SimpleHeader);
                            foreach (DllContent dc in Dll.UOExtGUI.Content)
                            {
                                peer.Send(dc);
                            }
                        }
                        else
                        {
                            peer.Send(new Handshake(0x00));
                        }
                        peer.Send(m_libraryList);
                        peer.Send(m_pluginsList);
                    }
                    break;
                case (0x03):
                    for (short i = 0; i < Dll.Dlls.Length; i++)
                    {
                        peer.Send(Dll.Dlls[i].Header);
                        foreach (DllContent dc in Dll.Dlls[i].Content)
                        {
                            peer.Send(dc);
                        }
                    }
                    peer.Send(m_initComplete);
                    break;
            }
        }
		private static AntiForgeryToken DeserializeImpl(BinaryReader reader)
		{
			byte b = reader.ReadByte();
			if (b != 1)
			{
				return null;
			}
			AntiForgeryToken antiForgeryToken = new AntiForgeryToken();
			byte[] data = reader.ReadBytes(16);
			antiForgeryToken.SecurityToken = new BinaryBlob(128, data);
			antiForgeryToken.IsSessionToken = reader.ReadBoolean();
			if (!antiForgeryToken.IsSessionToken)
			{
				bool flag = reader.ReadBoolean();
				if (flag)
				{
					byte[] data2 = reader.ReadBytes(32);
					antiForgeryToken.ClaimUid = new BinaryBlob(256, data2);
				}
				else
				{
					antiForgeryToken.Username = reader.ReadString();
				}
				antiForgeryToken.AdditionalData = reader.ReadString();
			}
			if (reader.BaseStream.ReadByte() != -1)
			{
				return null;
			}
			return antiForgeryToken;
		}
        public FAR1Archive(string Path)
        {
            m_Path = Path;
            m_Reader = new BinaryReader(File.Open(Path, FileMode.Open));

            string Header = Encoding.ASCII.GetString(m_Reader.ReadBytes(8));
            uint Version = m_Reader.ReadUInt32();

            if ((Header != "FAR!byAZ") || (Version != 1))
            {
                throw(new Exception("Archive wasn't a valid FAR V.1 archive!"));
            }

            m_ManifestOffset = m_Reader.ReadUInt32();
            m_Reader.BaseStream.Seek(m_ManifestOffset, SeekOrigin.Begin);

            m_NumFiles = m_Reader.ReadUInt32();
            
            for (int i = 0; i < m_NumFiles; i++)
            {
                FarEntry Entry = new FarEntry();
                Entry.DataLength = m_Reader.ReadInt32();
                Entry.DataLength2 = m_Reader.ReadInt32();
                Entry.DataOffset = m_Reader.ReadInt32();
                Entry.FilenameLength = m_Reader.ReadInt16();
                Entry.Filename = Encoding.ASCII.GetString(m_Reader.ReadBytes(Entry.FilenameLength));

                m_Entries.Add(Entry);
            }

            m_Reader.Close();
        }
Exemple #31
0
        private OricFileInfo[] ReadFTDosDirectory()
        {
            OricFileInfo[] diskDirectory = null;

            int iDirFileCount = 0;

            UInt16 i16DirectoryIndex = 1;
            UInt16 i16EntryIndex     = 1;

            System.Text.Encoding enc = System.Text.Encoding.ASCII;

            ArrayList diskCatalog = new ArrayList();

            Byte bNextTrack  = 20;
            Byte bNextSector = 2;

            Byte bCurrTrack  = bNextTrack;
            Byte bCurrSector = bNextSector;

            Boolean bMoreDirectories = true;

            while (bMoreDirectories)
            {
                iDirFileCount = 0;

                Byte[] sectorData = base.ReadSector(bNextTrack, bNextSector);

                System.IO.MemoryStream stm = new System.IO.MemoryStream(sectorData, 0, sectorData.Length);
                System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm);

                Byte[] bByteArray = new Byte[32];
                bByteArray = rdr.ReadBytes(2);

                bNextTrack  = rdr.ReadByte();
                bNextSector = rdr.ReadByte();

                for (int iLoop = 0; iLoop < 14; iLoop++)
                {
                    OricFileInfo diskFile = new OricFileInfo();
                    diskFile.MediaType = OricExplorer.MediaType.DiskFile;

                    diskFile.FirstTrack  = rdr.ReadByte();
                    diskFile.FirstSector = rdr.ReadByte();

                    diskFile.Folder     = base.diskFolder;
                    diskFile.ParentName = base.diskPathname;

                    Byte bProtection = rdr.ReadByte();

                    if (bProtection == 'U')
                    {
                        diskFile.Protection = OricProgram.ProtectionStatus.Unlocked;
                    }
                    else if (bProtection == 'L')
                    {
                        diskFile.Protection = OricProgram.ProtectionStatus.Locked;
                    }
                    else
                    {
                        diskFile.Protection = OricProgram.ProtectionStatus.Unlocked;
                    }

                    bByteArray = rdr.ReadBytes(8);

                    if ((bByteArray[0] != 0xFF && bByteArray[0] != 0x00 && bByteArray[0] != 0x6C) && diskFile.FirstTrack != 0xFF)
                    {
                        String strFilename = enc.GetString(bByteArray).Trim();

                        if (strFilename.Length > 0)
                        {
                            // Read decimal point between filename and extension
                            bByteArray = rdr.ReadBytes(1);

                            // Read the Extension
                            bByteArray = rdr.ReadBytes(3);
                            String strExtension = enc.GetString(bByteArray).Trim();

                            diskFile.Name      = strFilename;
                            diskFile.Extension = strExtension;

                            if (strExtension.Length > 0)
                            {
                                diskFile.ProgramName = String.Format("{0}.{1}", diskFile.Name, diskFile.Extension);
                            }
                            else
                            {
                                diskFile.ProgramName = diskFile.Name;
                            }

                            bByteArray = rdr.ReadBytes(1);

                            if (strExtension.Equals("SCR"))
                            {
                                diskFile.Format = OricProgram.ProgramFormat.TextScreen;
                            }
                            else if (strExtension.Equals("BAS"))
                            {
                                diskFile.Format = OricProgram.ProgramFormat.BasicProgram;
                            }
                            else if (strExtension.Equals("CMD") || strExtension.Equals("BIN") || strExtension.Equals("SYS"))
                            {
                                diskFile.Format = OricProgram.ProgramFormat.CodeFile;
                            }
                            else
                            {
                                diskFile.Format = OricProgram.ProgramFormat.UnknownFile;
                            }

                            diskFile.LengthSectors = rdr.ReadByte();

                            bByteArray = rdr.ReadBytes(1);

                            Byte[] fileDesc = base.ReadSector(diskFile.FirstTrack, diskFile.FirstSector);

                            System.IO.MemoryStream stm2 = new System.IO.MemoryStream(fileDesc, 0, sectorData.Length);
                            System.IO.BinaryReader rdr2 = new System.IO.BinaryReader(stm2);

                            bByteArray = rdr2.ReadBytes(2);

                            diskFile.StartAddress = rdr2.ReadUInt16();
                            diskFile.EndAddress   = (ushort)(diskFile.StartAddress + rdr2.ReadUInt16());
                            diskFile.ExeAddress   = 0;
                            diskFile.AutoRun      = OricProgram.AutoRunFlag.Disabled;

                            if ((diskFile.StartAddress == 0x0000 && diskFile.EndAddress == 0x0000) && strExtension != "SYS")
                            {
                                diskFile.Format = OricProgram.ProgramFormat.UnknownFile;
                            }

                            //diskFile.FirstTrack =

                            diskFile.DirectoryIndex = i16DirectoryIndex;
                            diskFile.EntryIndex     = i16EntryIndex;

                            diskCatalog.Add(diskFile);

                            iDirFileCount++;
                        }

                        i16EntryIndex++;
                    }
                    else
                    {
                        bByteArray = rdr.ReadBytes(7);
                        //swOutfile.WriteLine();
                    }
                }

                iDirFileCount = 0;

                if ((bNextTrack == 0xFF && bNextSector == 0) || (bNextTrack == 0x6C && bNextSector == 0x6C) || (bNextTrack == 0x00 && bNextSector == 0x00))
                {
                    bMoreDirectories = false;
                }
                else
                {
                    bCurrTrack  = bNextTrack;
                    bCurrSector = bNextSector;

                    i16EntryIndex = 1;
                    i16DirectoryIndex++;
                }
            }

            diskDirectory = new OricFileInfo[diskCatalog.Count];
            diskCatalog.CopyTo(diskDirectory);

            return(diskDirectory);
        }
Exemple #32
0
        private void BuildTDosSectorMap2(UInt16[] sectorMap, String diskPathname)
        {
            int iFileNum = 1;

            UInt16 bNextTrack  = 0;
            UInt16 bNextSector = 0;
            UInt16 bNextDescTrack;
            UInt16 bNextDescSector;

            Byte[] bByteArray = new Byte[10];

            String strSectorKey = "";

            OricFileInfo[] programList = ReadDirectory(diskPathname);

            foreach (OricFileInfo programInfo in programList)
            {
                if (programInfo.Format != OricProgram.ProgramFormat.UnknownFile)
                {
                    UInt16 bTrack;
                    UInt16 bSector;

                    bTrack  = programInfo.FirstTrack;
                    bSector = programInfo.FirstSector;

                    if (bTrack == 0x00 && bSector == 0x00)
                    {
                        // This is the DOS file (FTDOS3-2.sys) so don't process it
                    }
                    else
                    {
                        do
                        {
                            Byte[] bitmapSector = base.ReadSector(bTrack, bSector, ref bNextTrack, ref bNextSector);

                            // Add file descriptor to the sector map
                            UpdateSectorMap(sectorMap, bTrack, bSector, (UInt16)(0x1100 + Convert.ToByte(iFileNum)));

                            bTrack  = bNextTrack;
                            bSector = bNextSector;

                            // Safety net

                            /*if (bTrack > tracksPerSide || bNextSector > sectorsPerTrack)
                             * {
                             *  // Might have a problem
                             *  bSector = 0;
                             * }*/
                        } while (bSector != 0);

                        strSectorKey = CreateKey(programInfo.FirstTrack, programInfo.FirstSector);

                        bNextTrack  = programInfo.FirstTrack;
                        bNextSector = programInfo.FirstSector;

                        do
                        {
                            // Read the file descriptor
                            Byte[] sectorData = base.ReadSector(bNextTrack, bNextSector);

                            System.IO.MemoryStream stm = new System.IO.MemoryStream(sectorData, 0, sectorData.Length);
                            System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm);

                            bNextTrack  = rdr.ReadByte();
                            bNextSector = rdr.ReadByte();

                            bNextDescTrack  = bNextTrack;
                            bNextDescSector = bNextSector;

                            rdr.ReadBytes(4);

                            //Byte bFirstDesc = rdr.ReadByte();

                            int iDescIndex        = 0;
                            int iTotalDescriptors = 125;

                            Byte bDataTrack;
                            Byte bDataSector;

                            bDataTrack  = rdr.ReadByte();
                            bDataSector = rdr.ReadByte();

                            if (bDataTrack != 0xFF && bDataSector != 0xFF)
                            {
                                UpdateSectorMap(sectorMap, bDataTrack, bDataSector, (UInt16)(0x1000 + Convert.ToByte(iFileNum)));
                            }

                            while (bDataSector != 0xFF && iDescIndex < iTotalDescriptors)
                            {
                                if (bDataSector != 0xFF)
                                {
                                    bDataTrack  = rdr.ReadByte();
                                    bDataSector = rdr.ReadByte();

                                    if (bDataSector != 0xFF)
                                    {
                                        UpdateSectorMap(sectorMap, bDataTrack, bDataSector, (UInt16)(0x1000 + Convert.ToByte(iFileNum)));
                                    }

                                    iDescIndex++;
                                }
                            }

                            strSectorKey = CreateKey(bNextDescTrack, bNextDescSector);
                        } while (bNextDescTrack != 0xFF && bNextDescSector != 0x00);
                    }
                }

                iFileNum++;
            }
        }
Exemple #33
0
        internal UInt16[] BuildSectorMap(String diskPathname)
        {
            base.LoadDisk(diskPathname);

            UInt16 noOfSectors = (UInt16)((tracksPerSide * sectorsPerTrack) * sides);

            UInt16[] sectorMap = new UInt16[noOfSectors];

            for (int index = 0; index < noOfSectors; index++)
            {
                sectorMap[index] = 0xFFFF;
            }

            // Mark the disk bitmap
            UpdateSectorMap(sectorMap, 20, 1, 0x0200);

            if (diskType == DiskTypes.Master)
            {
                SetDOSSectors(sectorMap, 0, 1, 62);
            }

            Byte directoryTrack  = 0x14;
            Byte directorySector = 0x02;

            // Mark Directories
            UpdateSectorMap(sectorMap, directoryTrack, directorySector, 0x0400);

            Byte nextDirectoryTrack  = directoryTrack;
            Byte nextDirectorySector = directorySector;

            while ((directoryTrack != 0xFF) && (directoryTrack != 0x6C && directorySector != 0x6C) && (directoryTrack != 0x00 && directorySector != 0x00))
            {
                Byte[] directory = this.ReadSector(directoryTrack, directorySector);

                System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(directory, 0, directory.Length);
                System.IO.BinaryReader binReader    = new System.IO.BinaryReader(memoryStream);

                binReader.ReadBytes(2);

                nextDirectoryTrack  = binReader.ReadByte();
                nextDirectorySector = binReader.ReadByte();

                //Byte nextFreeEntry = binReader.ReadByte();

                Byte noOfFiles = 0;

                /*if (nextFreeEntry == 0x00)
                 * {
                 *  noOfFiles = 15;
                 * }
                 * else
                 * {
                 * }*/

                if (directoryTrack != 0x6C && directorySector != 0x6C)
                {
                    UpdateSectorMap(sectorMap, directoryTrack, directorySector, (UInt16)(0x0400 + noOfFiles));
                }

                directoryTrack  = nextDirectoryTrack;
                directorySector = nextDirectorySector;
            }

            BuildTDosSectorMap2(sectorMap, diskPathname);

            return(sectorMap);
        }
Exemple #34
0
        /*! \brief Private function to read GRF0x2xx headers
         *
         * Reads the information about files within the archive...
         * for archive versions 0x02xx
         *
         * \todo Find GRF versions other than just 0x200 (do any exist?)
         *
         * \param grf Pointer to the Grf struct to read to
         * \param error Pointer to a GrfErrorType struct/enum for error reporting
         * \param callback Function to call for each read file. It should return 0 if
         *		everything is fine, 1 if everything is fine (but further
         *		reading should stop), or -1 if there has been an error
         * \return 0 if everything went fine, 1 if something went wrong
         */
        static uint GRF_readVer2_info(System.IO.BinaryReader br, Grf grf, GrfOpenCallback callback)
        {
            uint i, offset, len, len2;

            byte[] buf, zbuf;

            /* Check grf */
            if (grf.version != 0x200)
            {
                throw new Exception("GE_NSUP");
            }

            /* Read the original and compressed sizes */
            buf = br.ReadBytes(8);

            /* Allocate memory and read the compressed file table */
            len  = GrfSupport.LittleEndian32(buf, 0);
            zbuf = br.ReadBytes((int)len);

            if (0 == (len2 = GrfSupport.LittleEndian32(buf, 4)))
            {
                return(0);
            }

            /* Allocate memory and uncompress the compressed file table */
            Array.Resize(ref buf, (int)len2);

            var stream = new InflaterInputStream(new MemoryStream(zbuf));

            stream.Read(buf, 0, buf.Length);

            stream.Close();

            /* Read information about each file */
            for (i = offset = 0; i < grf.nfiles; i++)
            {
                /* Grab the filename length */
                len = GrfSupport.getCStringLength(buf, offset) + 1;

                /* Make sure its not too large */
                if (len >= GrfTypes.GRF_NAMELEN)
                {
                    throw new Exception("GE_CORRUPTED");
                }

                /* Grab filename */
                GrfFile file = new GrfFile();
                file.name = GrfSupport.getCString(buf, offset);

                offset += len;

                /* Grab the rest of the information */
                file.compressed_len         = GrfSupport.LittleEndian32(buf, (int)offset);
                file.compressed_len_aligned = GrfSupport.LittleEndian32(buf, (int)offset + 4);
                file.real_len = GrfSupport.LittleEndian32(buf, (int)offset + 8);
                file.flags    = buf[offset + 0xC];
                file.pos      = GrfSupport.LittleEndian32(buf, (int)(offset + 0xD)) + (uint)GRF_HEADER_FULL_LEN;
                file.hash     = GrfSupport.GRF_NameHash(file.name);

                file.name = NormalizePath(file.name);

                grf.files.Add(file.name, file);

                /* Advance to the next file */
                offset += 0x11;

                /* Run the callback, if we have one */
                if (callback != null)
                {
                    callback.doCallback(file);

                    if (!callback.hasReturned())
                    {
                        throw new Exception("NO_RETURN");
                    }

                    if (callback.Response < 0)
                    {
                        /* Callback function had an error, so we
                         * have an error
                         */
                        return(1);
                    }
                    else if (callback.Response > 0)
                    {
                        /* Callback function found the file it needed,
                         * just exit now
                         */
                        return(0);
                    }
                }
            }

            /* Calling functions will set success...
             * GRF_SETERR(error,GE_SUCCESS,GRF_readVer2_info);
             */

            return(0);
        }
Exemple #35
0
        /// <summary>
        /// Encrypt a token with an RSA public key
        /// </summary>
        /// <param name="plainText">Plaintext string</param>
        /// <returns>Encrypted string</returns>
        public string Encrypt(string plainText)
        {
            //// read pem public key
            Stream s = System.Reflection.Assembly.GetExecutingAssembly().
                       GetManifestResourceStream("KountRisSdk.kount.rsa.public.key");

            System.IO.StreamReader reader = new System.IO.StreamReader(s, Encoding.UTF8);
            string pem = reader.ReadToEnd();

            string header = String.Format("-----BEGIN PUBLIC KEY-----");
            string footer = String.Format("-----END PUBLIC KEY-----");
            int    start  = pem.IndexOf(header, StringComparison.Ordinal) + header.Length;
            int    end    = pem.IndexOf(footer, start, StringComparison.Ordinal) - start;

            byte[] key = Convert.FromBase64String(pem.Substring(start, end));

            UnicodeEncoding converter = new UnicodeEncoding();

            byte[] plainBytes = converter.GetBytes(plainText);

            RSACryptoServiceProvider rsa = null;

            //// encoded OID sequence for PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
            byte[] seqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };

            byte[] seq = new byte[15];

            //// Read the asn.1 encoded SubjectPublicKeyInfo blob
            System.IO.MemoryStream mem  = new System.IO.MemoryStream(key);
            System.IO.BinaryReader binr = new System.IO.BinaryReader(mem);
            byte   bt       = 0;
            ushort twobytes = 0;

            try
            {
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                {
                    //// data read as little endian order
                    //// (actual data order for Sequence is 30 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                seq = binr.ReadBytes(15); //// read the Sequence OID
                if (!this.CompareBytearrays(seq, seqOID))
                {
                    //// make sure Sequence for OID is correct
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8103)
                {
                    //// data read as little endian order (actual data order for Bit String is 03 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8203)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                bt = binr.ReadByte();
                if (bt != 0x00)
                {
                    //// expect null byte next
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                {
                    //// data read as little endian order (actual data order for Sequence is 30 81)
                    binr.ReadByte(); //// advance 1 byte
                }
                else if (twobytes == 0x8230)
                {
                    binr.ReadInt16(); //// advance 2 bytes
                }
                else
                {
                    return(null);
                }

                twobytes = binr.ReadUInt16();
                byte lowbyte  = 0x00;
                byte highbyte = 0x00;

                if (twobytes == 0x8102)
                {
                    //// data read as little endian order
                    //// (actual data order for Integer is 02 81)
                    lowbyte = binr.ReadByte();  //// read next bytes which is bytes in modulus
                }
                else if (twobytes == 0x8202)
                {
                    highbyte = binr.ReadByte(); //// advance 2 bytes
                    lowbyte  = binr.ReadByte();
                }
                else
                {
                    return(null);
                }

                byte[] modint =
                {
                    lowbyte, highbyte, 0x00, 0x00
                };

                int modsize = BitConverter.ToInt32(modint, 0);

                int firstbyte = binr.PeekChar();
                if (firstbyte == 0x00)
                {
                    //// if first byte (highest order) of modulus is zero, don't include it
                    binr.ReadByte(); //// skip this null byte
                    modsize -= 1;    //// reduce modulus buffer size by 1
                }

                byte[] modulus = binr.ReadBytes(modsize); //// read the modulus bytes
                if (binr.ReadByte() != 0x02)
                {
                    //// expect an Integer for the exponent data
                    return(null);
                }

                int    expbytes = (int)binr.ReadByte();
                byte[] exponent = binr.ReadBytes(expbytes);

                //// create RSACryptoServiceProvider instance and initialize public key
                rsa = new RSACryptoServiceProvider();
                RSAParameters rsaKeyInfo = new RSAParameters();
                rsaKeyInfo.Modulus  = modulus;
                rsaKeyInfo.Exponent = exponent;
                rsa.ImportParameters(rsaKeyInfo);
            }
            finally
            {
                binr.Close();
            }

            byte[] encryptedBytes = rsa.Encrypt(plainBytes, false);
            return(Convert.ToBase64String(encryptedBytes));
        }
Exemple #36
0
        internal static ZigbeeCommand Parse(byte[] buffer, out uint bytesRead)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            bytesRead = 0;
            System.IO.BinaryReader br = new System.IO.BinaryReader(new MemoryStream(buffer));
            var SOP = br.ReadByte();

            if (SOP != 0x02)
            {
                throw new ArgumentException("Invalid SOP. Not a Zigbee response");
            }
            if (buffer.Length < 4)
            {
                return(null);
            }
            var cmd           = SwapUInt16(br.ReadUInt16());
            var NACK          = cmd & 32768;
            var ACK           = cmd & 16384;
            var Response      = cmd & 4096;
            var CommandNumber = 4095 & cmd;
            var LEN           = br.ReadByte();   //pos=3

            if (buffer.Length < 5 + LEN)
            {
                return(null);
            }
            var payload = br.ReadBytes(LEN);
            var fcs     = br.ReadByte();

            bytesRead = 5u + LEN;

            var xor = XOR(buffer, 1u, bytesRead - 2u);

            if ((xor ^ fcs) != 0)
            {
                throw new ArgumentException("Invalid message");
            }
            if (CidResponseTypes == null)
            {
                lock (lockObject)
                {
                    if (CidResponseTypes == null)
                    {
                        LoadResponseTypes();
                    }
                }
            }
            if (CidResponseTypes.ContainsKey(cmd))
            {
                var type = CidResponseTypes[cmd];
                try
                {
                    return(type.Invoke(new object[] { payload }) as ZigbeeCommand);
                }
                catch (System.Exception ex)
                {
                    return(new UnknownCidResponse(cmd, payload));
                }
            }
            else if (CidResponseCreators.ContainsKey(cmd))
            {
                var type = CidResponseCreators[cmd];
                return(type.Invoke(null, new object[] { payload }) as ZigbeeCommand);
            }
            else
            {
                return(new UnknownCidResponse(cmd, payload));
            }
        }
 public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
 {
     System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
     this.Type         = ((TypeEnum)(binaryReader.ReadInt16()));
     this.fieldpad     = binaryReader.ReadBytes(2);
     this.fieldpad0    = binaryReader.ReadBytes(16);
     this.AnchorOffset = binaryReader.ReadPoint();
     this.WidthScale   = binaryReader.ReadSingle();
     this.HeightScale  = binaryReader.ReadSingle();
     this.UnitHudAuxilaryPanelScalingFlags = ((ScalingFlags)(binaryReader.ReadInt16()));
     this.fieldpad1       = binaryReader.ReadBytes(2);
     this.fieldpad2       = binaryReader.ReadBytes(20);
     this.InterfaceBitmap = binaryReader.ReadTagReference();
     this.DefaultColor    = binaryReader.ReadColourA1R1G1B1();
     this.FlashingColor   = binaryReader.ReadColourA1R1G1B1();
     this.FlashPeriod     = binaryReader.ReadSingle();
     this.FlashDelay      = binaryReader.ReadSingle();
     this.NumberOfFlashes = binaryReader.ReadInt16();
     this.UnitHudAuxilaryPanelFlashFlags = ((FlashFlags)(binaryReader.ReadInt16()));
     this.FlashLength   = binaryReader.ReadSingle();
     this.DisabledColor = binaryReader.ReadColourA1R1G1B1();
     this.fieldpad3     = binaryReader.ReadBytes(4);
     this.SequenceIndex = binaryReader.ReadInt16();
     this.fieldpad4     = binaryReader.ReadBytes(2);
     pointerQueue.Enqueue(binaryReader.ReadBlamPointer(452));
     this.fieldpad5     = binaryReader.ReadBytes(4);
     this.AnchorOffset0 = binaryReader.ReadPoint();
     this.WidthScale0   = binaryReader.ReadSingle();
     this.HeightScale0  = binaryReader.ReadSingle();
     this.UnitHudAuxilaryPanelUnitHudAuxilaryPanelScalingFlags0 = ((UnitHudAuxilaryPanelScalingFlags0)(binaryReader.ReadInt16()));
     this.fieldpad6                 = binaryReader.ReadBytes(2);
     this.fieldpad7                 = binaryReader.ReadBytes(20);
     this.MeterBitmap               = binaryReader.ReadTagReference();
     this.ColorAtMeterMinimum       = binaryReader.ReadColourR1G1B1();
     this.ColorAtMeterMaximum       = binaryReader.ReadColourR1G1B1();
     this.FlashColor                = binaryReader.ReadColourR1G1B1();
     this.EmptyColor                = binaryReader.ReadColourA1R1G1B1();
     this.UnitHudAuxilaryPanelFlags = ((Flags)(binaryReader.ReadByte()));
     this.MinumumMeterValue         = binaryReader.ReadByte();
     this.SequenceIndex0            = binaryReader.ReadInt16();
     this.AlphaMultiplier           = binaryReader.ReadByte();
     this.AlphaBias                 = binaryReader.ReadByte();
     this.ValueScale                = binaryReader.ReadInt16();
     this.Opacity        = binaryReader.ReadSingle();
     this.Translucency   = binaryReader.ReadSingle();
     this.DisabledColor0 = binaryReader.ReadColourA1R1G1B1();
     pointerQueue.Enqueue(binaryReader.ReadBlamPointer(0));
     this.fieldpad8             = binaryReader.ReadBytes(4);
     this.MinimumFractionCutoff = binaryReader.ReadSingle();
     this.UnitHudAuxilaryPanelUnitHudAuxilaryPanelFlags0 = ((UnitHudAuxilaryPanelFlags0)(binaryReader.ReadInt32()));
     this.fieldpad9  = binaryReader.ReadBytes(24);
     this.fieldpad10 = binaryReader.ReadBytes(64);
     return(pointerQueue);
 }
Exemple #38
0
        public static object[][] ReadToObject(string dbfFileName, string tableName)
        {
            System.IO.Stream stream = new System.IO.FileStream(dbfFileName, System.IO.FileMode.Open);

            System.IO.BinaryReader reader = new System.IO.BinaryReader(stream);

            byte[] buffer = reader.ReadBytes(Marshal.SizeOf(typeof(DbfHeader)));

            DbfHeader header = IRI.Ket.IO.BinaryStream.ByteArrayToStructure <DbfHeader>(buffer);

            List <DbfFieldDescriptor> columns = new List <DbfFieldDescriptor>();

            if ((header.LengthOfHeader - 33) % 32 != 0)
            {
                throw new NotImplementedException();
            }

            int numberOfFields = (header.LengthOfHeader - 33) / 32;

            for (int i = 0; i < numberOfFields; i++)
            {
                buffer = reader.ReadBytes(Marshal.SizeOf(typeof(DbfFieldDescriptor)));

                columns.Add(DbfFieldDescriptor.Parse(buffer, DbfFileFormat.fieldsEncoding));
            }

            //System.Data.DataTable result = MakeTableSchema(tableName, columns);
            var result = new object[header.NumberOfRecords][];

            ((FileStream)reader.BaseStream).Seek(header.LengthOfHeader, SeekOrigin.Begin);

            for (int i = 0; i < header.NumberOfRecords; i++)
            {
                // First we'll read the entire record into a buffer and then read each field from the buffer
                // This helps account for any extra space at the end of each record and probably performs better
                buffer = reader.ReadBytes(header.LengthOfEachRecord);
                BinaryReader recordReader = new BinaryReader(new MemoryStream(buffer));

                // All dbf field records begin with a deleted flag field. Deleted - 0x2A (asterisk) else 0x20 (space)
                if (recordReader.ReadChar() == '*')
                {
                    continue;
                }

                object[] values = new object[columns.Count];

                for (int j = 0; j < columns.Count; j++)
                {
                    int fieldLenth = columns[j].Length;

                    values[j] = MapFunction[columns[j].Type](recordReader.ReadBytes(fieldLenth));
                }

                recordReader.Close();

                result[i] = values;
            }

            reader.Close();

            stream.Close();

            return(result);
        }
Exemple #39
0
        public ActionResult Edit([Bind(Include = "intPetID,strPetNumber,strMicrochipID,strPetName,intPetTypeID,intGenderID,intBreedID,dtmDateofBirth,dblWeight,isBlind,isDeaf,isAggressive,isDeceased,isAllergic,strColor,strNotes,isDeceased,intOwnerID")] TPet tPet, HttpPostedFileBase upload)
        {
            try {
                if (ModelState.IsValid)
                {
                    SqlParameter[] param = new SqlParameter[] {
                        new SqlParameter("@intPetID", tPet.intPetID),
                        new SqlParameter("@strPetName", tPet.strPetName),
                        new SqlParameter("@strPetNumber", tPet.strPetNumber),
                        new SqlParameter("@strMicrochipID", tPet.strMicrochipID),
                        new SqlParameter("@intPetTypeID", tPet.intPetTypeID),
                        //.intPetTypeID),
                        new SqlParameter("@intGenderID", tPet.intGenderID),
                        new SqlParameter("@intBreedID", tPet.intBreedID),
                        new SqlParameter("@dtmDateofBirth", tPet.dtmDateofBirth),
                        new SqlParameter("@dblWeight", tPet.dblWeight),
                        new SqlParameter("@isBlind", tPet.isBlind),
                        new SqlParameter("@isDeaf", tPet.isDeaf),
                        new SqlParameter("@isAggressive", tPet.isAggressive),
                        new SqlParameter("@isDeceased", tPet.isDeceased),
                        new SqlParameter("@isAllergic", tPet.isAllergic),
                        new SqlParameter("@strColor", tPet.strColor),
                        new SqlParameter("@strNotes", tPet.strNotes),
                        new SqlParameter("@intOwnerID", tPet.intOwnerID)
                    };
                    db.Database.ExecuteSqlCommand("uspUpdatePets @strPetName, @strPetNumber, @strMicrochipID, @intPetTypeID, @intGenderID, @intBreedID, @dtmDateofBirth, @dblWeight, @isBlind, @isDeaf, @isAggressive, @isDeceased, @isAllergic, @strColor, @strNotes, @intOwnerID", param);

                    //PetImage
                    if (upload != null && upload.ContentLength > 0)
                    {
                        var image = new TPetImage {
                            strFileName    = Path.GetFileName(upload.FileName),
                            strFileType    = Path.GetExtension(upload.FileName),
                            strContentType = upload.ContentType,
                            intPetID       = tPet.intPetID
                        };
                        using (var reader = new System.IO.BinaryReader(upload.InputStream)) {
                            image.imgContent = reader.ReadBytes(upload.ContentLength);
                        }
                        tPet.TPetImages = new List <TPetImage> {
                            image
                        };
                    }

                    db.Entry(tPet.TPetImage).State = EntityState.Modified;
                    db.SaveChanges();
                    return(RedirectToAction("Index"));
                }
            }
            catch (RetryLimitExceededException /* dex */) {
                //Log the error (uncomment dex variable name and add a line here to write a log.
                ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists see your system administrator.");
            }
            ViewBag.intPetTypeID = new SelectList(db.TPetTypes, "intPetTypeID", "strPetType", tPet.intPetTypeID);
            ViewBag.intGenderID  = new SelectList(db.TGenders, "intGenderID", "strGender", tPet.intGenderID);
            ViewBag.intOwnerID   = new SelectList(db.TOwners, "intOwnerID", "strLastName", tPet.intOwnerID);
            ViewBag.intBreedID   = new SelectList(db.TBreeds, "intBreedID", "strBreedName", tPet.intBreedID);

            ViewBag.intPetID = new SelectList(db.TPets, "intPetID", "strPetNumber", tPet.intPetID);
            return(View(tPet.TPetImage));
        }
        public static void DDSToTexture(GameDatabase.TextureInfo texture, bool inPlace, Vector2 size, string cache = null, bool mipmaps = false)
        {
            /**
             * Kopernicus Planetary System Modifier
             * ====================================
             * Created by: BryceSchroeder and Teknoman117 (aka. Nathaniel R. Lewis)
             * Maintained by: Thomas P., NathanKell and KillAshley
             * Additional Content by: Gravitasi, aftokino, KCreator, Padishar, Kragrathea, OvenProofMars, zengei, MrHappyFace
             * -------------------------------------------------------------
             * This library is free software; you can redistribute it and/or
             * modify it under the terms of the GNU Lesser General Public
             * License as published by the Free Software Foundation; either
             * version 3 of the License, or (at your option) any later version.
             *
             * This library is distributed in the hope that it will be useful,
             * but WITHOUT ANY WARRANTY; without even the implied warranty of
             * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             * Lesser General Public License for more details.
             *
             * You should have received a copy of the GNU Lesser General Public
             * License along with this library; if not, write to the Free Software
             * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
             * MA 02110-1301  USA
             *
             * This library is intended to be used as a plugin for Kerbal Space Program
             * which is copyright 2011-2015 Squad. Your usage of Kerbal Space Program
             * itself is governed by the terms of its EULA, not the license above.
             *
             * https://kerbalspaceprogram.com
             */
            // Borrowed from stock KSP 1.0 DDS loader (hi Mike!)
            // Also borrowed the extra bits from Sarbian.
            byte[] buffer = System.IO.File.ReadAllBytes(texture.file.fullPath);
            System.IO.BinaryReader binaryReader = new System.IO.BinaryReader(new System.IO.MemoryStream(buffer));
            uint num = binaryReader.ReadUInt32();

            if (num == DDSHeaders.DDSValues.uintMagic)
            {
                DDSHeaders.DDSHeader dDSHeader = new DDSHeaders.DDSHeader(binaryReader);

                if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDX10)
                {
                    new DDSHeaders.DDSHeaderDX10(binaryReader);
                }
                bool alpha      = (dDSHeader.dwFlags & 0x00000002) != 0;
                bool fourcc     = (dDSHeader.dwFlags & 0x00000004) != 0;
                bool rgb        = (dDSHeader.dwFlags & 0x00000040) != 0;
                bool alphapixel = (dDSHeader.dwFlags & 0x00000001) != 0;
                bool luminance  = (dDSHeader.dwFlags & 0x00020000) != 0;
                bool rgb888     = dDSHeader.ddspf.dwRBitMask == 0x000000ff && dDSHeader.ddspf.dwGBitMask == 0x0000ff00 && dDSHeader.ddspf.dwBBitMask == 0x00ff0000;
                //bool bgr888 = dDSHeader.ddspf.dwRBitMask == 0x00ff0000 && dDSHeader.ddspf.dwGBitMask == 0x0000ff00 && dDSHeader.ddspf.dwBBitMask == 0x000000ff;
                bool rgb565   = dDSHeader.ddspf.dwRBitMask == 0x0000F800 && dDSHeader.ddspf.dwGBitMask == 0x000007E0 && dDSHeader.ddspf.dwBBitMask == 0x0000001F;
                bool argb4444 = dDSHeader.ddspf.dwABitMask == 0x0000f000 && dDSHeader.ddspf.dwRBitMask == 0x00000f00 && dDSHeader.ddspf.dwGBitMask == 0x000000f0 && dDSHeader.ddspf.dwBBitMask == 0x0000000f;
                bool rbga4444 = dDSHeader.ddspf.dwABitMask == 0x0000000f && dDSHeader.ddspf.dwRBitMask == 0x0000f000 && dDSHeader.ddspf.dwGBitMask == 0x000000f0 && dDSHeader.ddspf.dwBBitMask == 0x00000f00;

                bool mipmap      = (dDSHeader.dwCaps & DDSHeaders.DDSPixelFormatCaps.MIPMAP) != (DDSHeaders.DDSPixelFormatCaps) 0u;
                bool isNormalMap = ((dDSHeader.ddspf.dwFlags & 524288u) != 0u || (dDSHeader.ddspf.dwFlags & 2147483648u) != 0u);

                Vector2 newSize = size == default(Vector2) ? new Vector2(dDSHeader.dwWidth, dDSHeader.dwHeight) : size;
                if (fourcc)
                {
                    if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDXT1)
                    {
                        if (inPlace && !texture.isReadable)
                        {
                            //This is a small hack to re-load the texture, even when it isn't readable. Unfortnately,
                            //we can't control compression, mipmaps, or anything else really, as the texture is still
                            //marked as unreadable. This will update the size and pixel data however.
                            Texture2D tmpTex    = new Texture2D((int)newSize.x, (int)newSize.y, TextureFormat.ARGB32, mipmap);
                            Texture2D tmpTexSrc = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.DXT1, mipmap);
                            tmpTexSrc.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            Color32[] colors = tmpTexSrc.GetPixels32();
                            colors = ResizePixels(colors, tmpTexSrc.width, tmpTexSrc.height, (int)newSize.x, (int)newSize.y);
                            tmpTex.SetPixels32(colors);
                            tmpTex.Apply(false);
                            //size using JPG to force DXT1

                            byte[] file = ImageConversion.EncodeToPNG(tmpTex);//tmpTex.EncodeToJPG();
                            if (cache != null)
                            {
                                Directory.GetParent(cache).Create();
                                System.IO.File.WriteAllBytes(cache, file);
                            }
                            texture.texture.LoadImage(file);

                            GameObject.DestroyImmediate(tmpTex);
                            GameDatabase.DestroyImmediate(tmpTexSrc);
                        }
                        else if (inPlace)
                        {
                            texture.texture.Resize((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.RGB24, mipmap);
                            texture.texture.Compress(false);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                        else
                        {
                            GameObject.DestroyImmediate(texture.texture);
                            texture.texture = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.DXT1, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                    }
                    else if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDXT3)
                    {
                        if (inPlace && !texture.isReadable)
                        {
                            //This is a small hack to re-load the texture, even when it isn't readable. Unfortnately,
                            //we can't control compression, mipmaps, or anything else really, as the texture is still
                            //marked as unreadable. This will update the size and pixel data however.
                            Texture2D tmpTex    = new Texture2D((int)newSize.x, (int)newSize.y, TextureFormat.ARGB32, mipmap);
                            Texture2D tmpTexSrc = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, (TextureFormat)11, mipmap);
                            tmpTexSrc.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            Color32[] colors = tmpTexSrc.GetPixels32();
                            colors = ResizePixels(colors, tmpTexSrc.width, tmpTexSrc.height, (int)newSize.x, (int)newSize.y);
                            tmpTex.SetPixels32(colors);
                            tmpTex.Apply(false);
                            //size using JPG to force DXT5
                            byte[] file = ImageConversion.EncodeToPNG(tmpTex);
                            if (cache != null)
                            {
                                Directory.GetParent(cache).Create();
                                System.IO.File.WriteAllBytes(cache, file);
                            }
                            texture.texture.LoadImage(file);

                            GameObject.DestroyImmediate(tmpTex);
                            GameDatabase.DestroyImmediate(tmpTexSrc);
                        }
                        else if (inPlace)
                        {
                            texture.texture.Resize((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, (TextureFormat)11, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                        else
                        {
                            GameObject.DestroyImmediate(texture.texture);
                            texture.texture = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, (TextureFormat)11, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                    }
                    else if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDXT5)
                    {
                        if (inPlace && !texture.isReadable)
                        {
                            //This is a small hack to re-load the texture, even when it isn't readable. Unfortnately,
                            //we can't control compression, mipmaps, or anything else really, as the texture is still
                            //marked as unreadable. This will update the size and pixel data however.
                            Texture2D tmpTex    = new Texture2D((int)newSize.x, (int)newSize.y, TextureFormat.ARGB32, mipmap);
                            Texture2D tmpTexSrc = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.DXT5, mipmap);
                            tmpTexSrc.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            Color32[] colors = tmpTexSrc.GetPixels32();
                            colors = ResizePixels(colors, tmpTexSrc.width, tmpTexSrc.height, (int)newSize.x, (int)newSize.y);
                            tmpTex.SetPixels32(colors);
                            tmpTex.Apply(false);
                            //size using JPG to force DXT5
                            byte[] file = ImageConversion.EncodeToPNG(tmpTex);
                            if (cache != null)
                            {
                                Directory.GetParent(cache).Create();
                                System.IO.File.WriteAllBytes(cache, file);
                            }
                            texture.texture.LoadImage(file);
                            GameObject.DestroyImmediate(tmpTex);
                            GameDatabase.DestroyImmediate(tmpTexSrc);
                        }
                        else if (inPlace)
                        {
                            texture.texture.Resize((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.ARGB32, mipmap);
                            texture.texture.Compress(false);

                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                        else
                        {
                            GameObject.DestroyImmediate(texture.texture);
                            texture.texture = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, TextureFormat.DXT5, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                    }
                    else if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDXT2)
                    {
                        Debug.Log("DXT2 not supported");
                    }
                    else if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDXT4)
                    {
                        Debug.Log("DXT4 not supported: ");
                    }
                    else if (dDSHeader.ddspf.dwFourCC == DDSHeaders.DDSValues.uintDX10)
                    {
                        Debug.Log("DX10 dds not supported: ");
                    }
                    else
                    {
                        fourcc = false;
                    }
                }
                if (!fourcc)
                {
                    TextureFormat textureFormat = TextureFormat.ARGB32;
                    bool          ok            = true;
                    if (rgb && (rgb888 /*|| bgr888*/))
                    {
                        // RGB or RGBA format
                        textureFormat = alphapixel
                        ? TextureFormat.RGBA32
                        : TextureFormat.RGB24;
                    }
                    else if (rgb && rgb565)
                    {
                        // Nvidia texconv B5G6R5_UNORM
                        textureFormat = TextureFormat.RGB565;
                    }
                    else if (rgb && alphapixel && argb4444)
                    {
                        // Nvidia texconv B4G4R4A4_UNORM
                        textureFormat = TextureFormat.ARGB4444;
                    }
                    else if (rgb && alphapixel && rbga4444)
                    {
                        textureFormat = TextureFormat.RGBA4444;
                    }
                    else if (!rgb && alpha != luminance)
                    {
                        // A8 format or Luminance 8
                        textureFormat = TextureFormat.Alpha8;
                    }
                    else
                    {
                        ok = false;
                        Debug.Log("Only DXT1, DXT5, A8, RGB24, RGBA32, RGB565, ARGB4444 and RGBA4444 are supported");
                    }
                    if (ok)
                    {
                        if (inPlace && !texture.isReadable)
                        {
                            //This is a small hack to re-load the texture, even when it isn't readable. Unfortnately,
                            //we can't control compression, mipmaps, or anything else really, as the texture is still
                            //marked as unreadable. This will update the size and pixel data however.
                            Texture2D tmpTex    = new Texture2D((int)newSize.x, (int)newSize.y, TextureFormat.ARGB32, mipmap);
                            Texture2D tmpTexSrc = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, textureFormat, mipmap);
                            tmpTexSrc.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            Color32[] colors = tmpTexSrc.GetPixels32();
                            colors = ResizePixels(colors, tmpTexSrc.width, tmpTexSrc.height, (int)newSize.x, (int)newSize.y);
                            tmpTex.SetPixels32(colors);
                            tmpTex.Apply(false);
                            //size using JPG to force alpha-less
                            byte[] file;
                            if (alphapixel)
                            {
                                file = ImageConversion.EncodeToPNG(tmpTex);
                            }
                            else
                            {
                                file = ImageConversion.EncodeToPNG(tmpTex);//file = tmpTex.EncodeToJPG();
                            }
                            if (cache != null)
                            {
                                Directory.GetParent(cache).Create();
                                System.IO.File.WriteAllBytes(cache, file);
                            }
                            texture.texture.LoadImage(file);
                            GameDatabase.DestroyImmediate(tmpTex);
                            GameDatabase.DestroyImmediate(tmpTexSrc);
                        }
                        else if (inPlace)
                        {
                            texture.texture.Resize((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, textureFormat, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                        else
                        {
                            GameDatabase.DestroyImmediate(texture.texture);
                            texture.texture = new Texture2D((int)dDSHeader.dwWidth, (int)dDSHeader.dwHeight, textureFormat, mipmap);
                            texture.texture.LoadRawTextureData(binaryReader.ReadBytes((int)(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position)));
                            texture.texture.Apply(false, !texture.isReadable);
                        }
                    }
                }
            }
            else
            {
                Debug.Log("Bad DDS header.");
            }
        }
Exemple #41
0
        public SyncTexture BuildTexture(ObjParser.Types.Material mat)
        {
            // ストリップパスとか相対パスの場合を考慮する
            string filePath = System.IO.Path.GetDirectoryName(mat.map_Kd);

            if (filePath.Length == 0)
            {
                filePath = System.IO.Path.GetDirectoryName(fileName) + "\\" + mat.map_Kd;
            }

            string      name    = System.IO.Path.GetFileNameWithoutExtension(filePath);
            string      ext     = System.IO.Path.GetExtension(filePath);
            SyncTexture texture = new SyncTexture(new SyncId("TextureId_" + name), name);

            Console.WriteLine("\tTexture file: " + filePath);
            try
            {
                //System.Drawing.Image img = System.Drawing.Image.FromFile(filePath);
#if false
                // 最初の案→なんかおかしい
                byte[] ary;
                using (MemoryStream ms = new MemoryStream())
                {
                    if (ext.ToLower() == ".jpg" || ext.ToLower() == ".jpeg")
                    {
                        img.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                    }
                    else if (ext.ToLower() == ".png")
                    {
                        img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
                    }
                    else
                    {
                        Console.WriteLine("\t" + mat.map_Kd + " is unknown format");
                        return(null);
                    }
                    ary = ms.ToArray();
                }
                texture.Source = ary.ToArray();
#else
                // 更に改善:解像度を2のN乗にする
                bool   requireResize = false;
                Bitmap bmp           = new Bitmap(filePath);
                int    width         = bmp.Width;
                int    height        = bmp.Height;
                if (!IsPow2(width))
                {
                    requireResize = true;
                    int beki = 1;
                    while (true)
                    {
                        if (width < beki)
                        {
                            width = beki / 2; // 1段階小さくする
                            break;
                        }
                        beki *= 2;
                    }
                }
                if (!IsPow2(bmp.Height))
                {
                    requireResize = true;
                    int beki = 1;
                    while (true)
                    {
                        if (height < beki)
                        {
                            height = beki / 2; // 1段階小さくする
                            break;
                        }
                        beki *= 2;
                    }
                }
                Bitmap bmpResize = new Bitmap(bmp, width, height);

                // ファイル名変更
                string resizeFileName = filePath;
                if (requireResize)
                {
                    resizeFileName.ToLower();
                    resizeFileName = resizeFileName.Replace(".jpg", "_resize.jpg"); // ファイル名差し替え
                    bmpResize.Save(resizeFileName);                                 // リサイズして画像出力
                }
                bmpResize.Dispose();
                bmp.Dispose();

                // 2021.5.26の案 // UnityEditorで上手くいくのを確認した方法 //
                System.IO.FileStream   fileStream = new System.IO.FileStream(resizeFileName, System.IO.FileMode.Open, System.IO.FileAccess.Read);
                System.IO.BinaryReader bin        = new System.IO.BinaryReader(fileStream);
                byte[] ary = bin.ReadBytes((int)bin.BaseStream.Length);
                bin.Close();
                texture.Source = ary;

                /*
                 * // こっちだとどうかな // [?]という画像に置き換わる現象が出た
                 * List<byte> ary2 = new List<byte>();
                 *
                 * Bitmap bmp = new Bitmap(filePath);
                 * for (int x = 0; x < bmp.Width; x++)
                 * {
                 *  for (int y = 0; y < bmp.Height; y++)
                 *  {
                 *      Color color = bmp.GetPixel(x, y);
                 *      ary2.Add(color.R);
                 *      ary2.Add(color.G);
                 *      ary2.Add(color.B);
                 *      ary2.Add(color.A);
                 *  }
                 * }
                 * texture.Source = ary2.ToArray();
                 */
#endif
            }
            catch (System.IO.FileNotFoundException e)
            {
                Console.WriteLine("FileNotFoundException: " + e.Message);
            }
            return(texture);
        }
        public void Read(System.IO.BinaryReader br)
        {
            ByteOrder        = br.ReadUInt16();
            Version          = br.ReadUInt16();
            SystemIdentifier = br.ReadUInt32();
            CLSID            = new Guid(br.ReadBytes(16));
            NumPropertySets  = br.ReadUInt32();
            FMTID0           = new Guid(br.ReadBytes(16));
            Offset0          = br.ReadUInt32();

            if (NumPropertySets == 2)
            {
                FMTID1  = new Guid(br.ReadBytes(16));
                Offset1 = br.ReadUInt32();
            }

            PropertySet0               = new PropertySet();
            PropertySet0.Size          = br.ReadUInt32();
            PropertySet0.NumProperties = br.ReadUInt32();


            // Read property offsets (P0)
            for (int i = 0; i < PropertySet0.NumProperties; i++)
            {
                PropertyIdentifierAndOffset pio = new PropertyIdentifierAndOffset();
                pio.PropertyIdentifier = br.ReadUInt32();
                pio.Offset             = br.ReadUInt32();
                PropertySet0.PropertyIdentifierAndOffsets.Add(pio);
            }

            PropertySet0.LoadContext((int)Offset0, br);  //Read CodePage, Locale

            // Read properties (P0)
            for (int i = 0; i < PropertySet0.NumProperties; i++)
            {
                br.BaseStream.Seek(Offset0 + PropertySet0.PropertyIdentifierAndOffsets[i].Offset, System.IO.SeekOrigin.Begin);
                PropertySet0.Properties.Add(ReadProperty(PropertySet0.PropertyIdentifierAndOffsets[i].PropertyIdentifier, PropertySet0.PropertyContext.CodePage, br));
            }

            if (NumPropertySets == 2)
            {
                br.BaseStream.Seek(Offset1, System.IO.SeekOrigin.Begin);
                PropertySet1               = new PropertySet();
                PropertySet1.Size          = br.ReadUInt32();
                PropertySet1.NumProperties = br.ReadUInt32();

                // Read property offsets
                for (int i = 0; i < PropertySet1.NumProperties; i++)
                {
                    PropertyIdentifierAndOffset pio = new PropertyIdentifierAndOffset();
                    pio.PropertyIdentifier = br.ReadUInt32();
                    pio.Offset             = br.ReadUInt32();
                    PropertySet1.PropertyIdentifierAndOffsets.Add(pio);
                }

                PropertySet1.LoadContext((int)Offset1, br);

                // Read properties
                for (int i = 0; i < PropertySet1.NumProperties; i++)
                {
                    br.BaseStream.Seek(Offset1 + PropertySet1.PropertyIdentifierAndOffsets[i].Offset, System.IO.SeekOrigin.Begin);
                    PropertySet1.Properties.Add(ReadProperty(PropertySet1.PropertyIdentifierAndOffsets[i].PropertyIdentifier, PropertySet1.PropertyContext.CodePage, br));
                }
            }
        }
Exemple #43
0
        internal override void Read(System.IO.BinaryReader reader, BinaryReadInfo readInfo)
        {
            uint length = reader.ReadUInt32();

            ID = reader.ReadUInt32();
            uint numSections = reader.ReadUInt32();

            string componentName = null;
            bool   canResize     = false;
            bool   canFlip       = false;
            double minSize       = ComponentHelper.GridSize;
            List <ComponentProperty>          properties          = new List <ComponentProperty>();
            List <ConnectionGroup>            connections         = new List <ConnectionGroup>();
            List <RenderDescription>          renderDescriptions  = new List <RenderDescription>();
            List <Conditional <FlagOptions> > flagOptions         = new List <Conditional <FlagOptions> >();
            ComponentDescriptionMetadata      descriptionMetadata = new ComponentDescriptionMetadata();
            uint?iconResourceId = null;

            for (uint sectionCounter = 0; sectionCounter < numSections; sectionCounter++)
            {
                ushort sectionType   = reader.ReadUInt16();
                uint   sectionLength = reader.ReadUInt32();

                #region Metadata
                if (sectionType == (uint)BinaryConstants.ComponentSectionType.Metadata)
                {
                    componentName              = reader.ReadString();
                    canResize                  = reader.ReadBoolean();
                    canFlip                    = reader.ReadBoolean();
                    minSize                    = reader.ReadDouble();
                    descriptionMetadata.Type   = String.Format("Binary r{0} (*.cdcom)", readInfo.FormatVersion);
                    descriptionMetadata.GUID   = new Guid(reader.ReadBytes(16));
                    descriptionMetadata.Author = reader.ReadString();
                    if (readInfo.IsSignatureValid && readInfo.Certificate != null && readInfo.IsCertificateTrusted)
                    {
                        descriptionMetadata.Author = readInfo.Certificate.GetNameInfo(X509NameType.EmailName, false);
                    }
                    descriptionMetadata.Version = new Version(reader.ReadUInt16(), reader.ReadUInt16());
                    descriptionMetadata.AdditionalInformation          = reader.ReadString();
                    descriptionMetadata.ImplementSet                   = reader.ReadString();
                    descriptionMetadata.ImplementItem                  = reader.ReadString();
                    descriptionMetadata.Signature.IsHashValid          = readInfo.IsSignatureValid;
                    descriptionMetadata.Signature.Certificate          = readInfo.Certificate;
                    descriptionMetadata.Signature.IsCertificateTrusted = readInfo.IsCertificateTrusted;
                    int iconResource = reader.ReadInt32();
                    if (iconResource != -1)
                    {
                        iconResourceId = (uint)iconResource;
                    }
                    long created = reader.ReadInt64();
                }
                #endregion
                #region Flags
                else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Flags)
                {
                    uint numFlagGroups = reader.ReadUInt32();
                    for (uint j = 0; j < numFlagGroups; j++)
                    {
                        IConditionTreeItem conditions;
                        if (readInfo.FormatVersion > 1)
                        {
                            conditions = reader.ReadConditionTree();
                        }
                        else
                        {
                            conditions = reader.ReadConditionCollection();
                        }

                        FlagOptions value = (FlagOptions)reader.ReadUInt32();
                        flagOptions.Add(new Conditional <FlagOptions>(value, conditions));
                    }
                }
                #endregion
                #region Properties
                else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Properties)
                {
                    uint numProperties = reader.ReadUInt32();
                    for (uint j = 0; j < numProperties; j++)
                    {
                        string        propertyName   = reader.ReadString();
                        string        serializedName = reader.ReadString();
                        string        displayName    = reader.ReadString();
                        BinaryType    propType;
                        object        rawDefaultValue = reader.ReadType(out propType);
                        PropertyUnion defaultValue    = propType.ToPropertyUnion(rawDefaultValue);
                        string[]      enumOptions     = null;
                        if (propType == BinaryType.Enum)
                        {
                            enumOptions = new string[reader.ReadInt32()];
                            for (int k = 0; k < enumOptions.Length; k++)
                            {
                                enumOptions[k] = reader.ReadString();
                            }
                        }

                        // Format rules
                        List <ComponentPropertyFormat> formatRules = new List <ComponentPropertyFormat>();
                        uint numFormatRules = reader.ReadUInt32();
                        for (uint k = 0; k < numFormatRules; k++)
                        {
                            IConditionTreeItem conditions;
                            if (readInfo.FormatVersion > 1)
                            {
                                conditions = reader.ReadConditionTree();
                            }
                            else
                            {
                                conditions = reader.ReadConditionCollection();
                            }
                            string formatRule = reader.ReadString();
                            formatRules.Add(new ComponentPropertyFormat(formatRule, conditions));
                        }

                        // Other conditions
                        uint numOtherConditions = reader.ReadUInt32();
                        Dictionary <PropertyOtherConditionType, IConditionTreeItem> otherConditions = new Dictionary <PropertyOtherConditionType, IConditionTreeItem>((int)numOtherConditions);
                        for (uint k = 0; k < numOtherConditions; k++)
                        {
                            uint uintConditionType = reader.ReadUInt32();
                            IConditionTreeItem conditions;
                            if (readInfo.FormatVersion > 1)
                            {
                                conditions = reader.ReadConditionTree();
                            }
                            else
                            {
                                conditions = reader.ReadConditionCollection();
                            }
                            PropertyOtherConditionType conditionType = (PropertyOtherConditionType)uintConditionType;
                            otherConditions.Add(conditionType, conditions);
                        }

                        properties.Add(new ComponentProperty(propertyName, serializedName, displayName, BinaryIOExtentions.BinaryTypeToPropertyType(propType), defaultValue, formatRules.ToArray(), otherConditions, enumOptions));
                    }
                }
                #endregion
                #region Configurations
                else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Configurations)
                {
                    uint numConfigurations = reader.ReadUInt32();
                    for (int j = 0; j < numConfigurations; j++)
                    {
                        string configurationName  = reader.ReadString();
                        string implementationName = reader.ReadString();

                        int numSetters = reader.ReadInt32();
                        var setters    = new Dictionary <string, PropertyUnion>(numSetters);
                        for (int k = 0; k < numSetters; k++)
                        {
                            BinaryType tempType;
                            string     name        = reader.ReadString();
                            var        setterValue = reader.ReadType(out tempType);
                            setters.Add(name, tempType.ToPropertyUnion(setterValue));
                        }

                        int iconID = reader.ReadInt32();

                        var configuration = new ComponentConfiguration(implementationName, configurationName, setters);
                        descriptionMetadata.Configurations.Add(configuration);

                        if (iconID != -1)
                        {
                            iconResources.Add(configuration, (uint)iconID);
                        }
                    }
                }
                #endregion
                #region Connections
                else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Connections)
                {
                    uint numConnectionGroups = reader.ReadUInt32();
                    List <ConnectionGroup> connectionGroups = new List <ConnectionGroup>();
                    for (int j = 0; j < numConnectionGroups; j++)
                    {
                        IConditionTreeItem conditions;
                        if (readInfo.FormatVersion > 1)
                        {
                            conditions = reader.ReadConditionTree();
                        }
                        else
                        {
                            conditions = reader.ReadConditionCollection();
                        }

                        List <ConnectionDescription> tConnections = new List <ConnectionDescription>();
                        uint numConnections = reader.ReadUInt32();
                        for (uint k = 0; k < numConnections; k++)
                        {
                            tConnections.Add(new ConnectionDescription(reader.ReadComponentPoint(), reader.ReadComponentPoint(), (ConnectionEdge)reader.ReadInt32(), reader.ReadString()));
                        }

                        connections.Add(new ConnectionGroup(conditions, tConnections.ToArray()));
                    }
                }
                #endregion
                #region Render
                else if (sectionType == (uint)BinaryConstants.ComponentSectionType.Render)
                {
                    uint numRenderGroups = reader.ReadUInt32();
                    for (uint j = 0; j < numRenderGroups; j++)
                    {
                        IConditionTreeItem conditions;
                        if (readInfo.FormatVersion > 1)
                        {
                            conditions = reader.ReadConditionTree();
                        }
                        else
                        {
                            conditions = reader.ReadConditionCollection();
                        }

                        int numRenderCommands = (int)reader.ReadUInt32();
                        List <IRenderCommand> renderCommands = new List <IRenderCommand>(numRenderCommands);
                        for (int k = 0; k < numRenderCommands; k++)
                        {
                            RenderCommandType commandType = (RenderCommandType)reader.ReadUInt32();
                            switch (commandType)
                            {
                            case RenderCommandType.Line:
                            {
                                ComponentPoint start     = reader.ReadComponentPoint();
                                ComponentPoint end       = reader.ReadComponentPoint();
                                double         thickness = reader.ReadDouble();
                                renderCommands.Add(new Line(start, end, thickness));
                            }
                                continue;

                            case RenderCommandType.Rect:
                            {
                                ComponentPoint location  = reader.ReadComponentPoint();
                                double         width     = reader.ReadDouble();
                                double         height    = reader.ReadDouble();
                                double         thickness = reader.ReadDouble();
                                bool           fill      = (reader.ReadUInt32() == 0 ? false : true);
                                renderCommands.Add(new Rectangle(location, width, height, thickness, fill));
                            }
                                continue;

                            case RenderCommandType.Ellipse:
                            {
                                ComponentPoint centre    = reader.ReadComponentPoint();
                                double         radiusX   = reader.ReadDouble();
                                double         radiusY   = reader.ReadDouble();
                                double         thickness = reader.ReadDouble();
                                bool           fill      = (reader.ReadUInt32() == 0 ? false : true);
                                renderCommands.Add(new Ellipse(centre, radiusX, radiusY, thickness, fill));
                            }
                                continue;

                            case RenderCommandType.Path:
                            {
                                ComponentPoint start     = reader.ReadComponentPoint();
                                double         thickness = reader.ReadDouble();
                                bool           fill      = (reader.ReadUInt32() == 0 ? false : true);

                                int numCommands = reader.ReadInt32();
                                List <IPathCommand> pathCommands = new List <IPathCommand>(numCommands);
                                for (int l = 0; l < numCommands; l++)
                                {
                                    CommandType  pType      = (CommandType)reader.ReadInt32();
                                    IPathCommand theCommand = null;
                                    switch (pType)
                                    {
                                    case CommandType.MoveTo:
                                        theCommand = new MoveTo();
                                        break;

                                    case CommandType.LineTo:
                                        theCommand = new LineTo();
                                        break;

                                    case CommandType.CurveTo:
                                        theCommand = new CurveTo();
                                        break;

                                    case CommandType.EllipticalArcTo:
                                        theCommand = new EllipticalArcTo();
                                        break;

                                    case CommandType.QuadraticBeizerCurveTo:
                                        theCommand = new QuadraticBeizerCurveTo();
                                        break;

                                    case CommandType.SmoothCurveTo:
                                        theCommand = new SmoothCurveTo();
                                        break;

                                    case CommandType.SmoothQuadraticBeizerCurveTo:
                                        theCommand = new SmoothQuadraticBeizerCurveTo();
                                        break;

                                    default:
                                        theCommand = new ClosePath();
                                        break;
                                    }
                                    theCommand.Read(reader);
                                    pathCommands.Add(theCommand);
                                }

                                renderCommands.Add(new RenderPath(start, thickness, fill, pathCommands));
                            }
                                continue;

                            case RenderCommandType.Text:
                            {
                                byte           formattedTextVersion = reader.ReadByte();
                                ComponentPoint location             = reader.ReadComponentPoint();
                                TextAlignment  alignment            = (TextAlignment)reader.ReadUInt32();

                                uint           numTextRuns = reader.ReadUInt32();
                                List <TextRun> textRuns    = new List <TextRun>((int)numTextRuns);
                                for (uint l = 0; l < numTextRuns; l++)
                                {
                                    TextRunFormattingType formattingType = (TextRunFormattingType)reader.ReadUInt32();
                                    double runSize = reader.ReadDouble();
                                    string runText = reader.ReadString();
                                    textRuns.Add(new TextRun(runText, new TextRunFormatting(formattingType, runSize)));
                                }

                                renderCommands.Add(new Text(location, alignment, textRuns));
                            }
                                continue;
                            }
                        }

                        renderDescriptions.Add(new RenderDescription(conditions, renderCommands.ToArray()));
                    }
                }
                #endregion
                #region Skip
                else
                {
                    // Unknown type - skip
                    reader.BaseStream.Seek(sectionLength, SeekOrigin.Current);
                }
                #endregion
            }

            ComponentDescription = new ComponentDescription(ID.ToString(), componentName, canResize, canFlip, minSize, properties.ToArray(), connections.ToArray(), renderDescriptions.ToArray(), flagOptions.ToArray(), descriptionMetadata);

            if (iconResourceId.HasValue)
            {
                mainIconResource = iconResourceId.Value;
            }
        }
Exemple #44
0
        /// <summary>
        /// Get the SkipperRule associated with a given stream
        /// </summary>
        /// <param name="input">Name of the file to be checked</param>
        /// <param name="skipperName">Name of the skipper to be used, blank to find a matching skipper</param>
        /// <param name="logger">Logger object for file and console output</param>
        /// <param name="keepOpen">True if the underlying stream should be kept open, false otherwise</param>
        /// <returns>The SkipperRule that matched the file</returns>
        public static SkipperRule GetMatchingRule(Stream input, string skipperName, bool keepOpen = false)
        {
            SkipperRule skipperRule = new SkipperRule();

            // If we have a null skipper name, we return since we're not matching skippers
            if (skipperName == null)
            {
                return(skipperRule);
            }

            // Loop through and find a Skipper that has the right name
            Globals.Logger.Verbose("Beginning search for matching header skip rules");
            List <Skipper> tempList = new List <Skipper>();

            tempList.AddRange(List);

            foreach (Skipper skipper in tempList)
            {
                // If we're searching for the skipper OR we have a match to an inputted one
                if (String.IsNullOrWhiteSpace(skipperName) ||
                    (!String.IsNullOrWhiteSpace(skipper.Name) && skipperName.ToLowerInvariant() == skipper.Name.ToLowerInvariant()) ||
                    (!String.IsNullOrWhiteSpace(skipper.Name) && skipperName.ToLowerInvariant() == skipper.SourceFile.ToLowerInvariant()))
                {
                    // Loop through the rules until one is found that works
                    BinaryReader br = new BinaryReader(input);

                    foreach (SkipperRule rule in skipper.Rules)
                    {
                        // Always reset the stream back to the original place
                        input.Seek(0, SeekOrigin.Begin);

                        // For each rule, make sure it passes each test
                        bool success = true;
                        foreach (SkipperTest test in rule.Tests)
                        {
                            bool result = true;
                            switch (test.Type)
                            {
                            case HeaderSkipTest.Data:
                                // First seek to the correct position
                                if (test.Offset == null)
                                {
                                    input.Seek(0, SeekOrigin.End);
                                }
                                else if (test.Offset > 0 && test.Offset <= input.Length)
                                {
                                    input.Seek((long)test.Offset, SeekOrigin.Begin);
                                }
                                else if (test.Offset < 0 && Math.Abs((long)test.Offset) <= input.Length)
                                {
                                    input.Seek((long)test.Offset, SeekOrigin.End);
                                }

                                // Then read and compare bytewise
                                result = true;
                                for (int i = 0; i < test.Value.Length; i++)
                                {
                                    try
                                    {
                                        if (br.ReadByte() != test.Value[i])
                                        {
                                            result = false;
                                            break;
                                        }
                                    }
                                    catch
                                    {
                                        result = false;
                                        break;
                                    }
                                }

                                // Return if the expected and actual results match
                                success &= (result == test.Result);
                                break;

                            case HeaderSkipTest.Or:
                            case HeaderSkipTest.Xor:
                            case HeaderSkipTest.And:
                                // First seek to the correct position
                                if (test.Offset == null)
                                {
                                    input.Seek(0, SeekOrigin.End);
                                }
                                else if (test.Offset > 0 && test.Offset <= input.Length)
                                {
                                    input.Seek((long)test.Offset, SeekOrigin.Begin);
                                }
                                else if (test.Offset < 0 && Math.Abs((long)test.Offset) <= input.Length)
                                {
                                    input.Seek((long)test.Offset, SeekOrigin.End);
                                }

                                result = true;
                                try
                                {
                                    // Then apply the mask if it exists
                                    byte[] read   = br.ReadBytes(test.Mask.Length);
                                    byte[] masked = new byte[test.Mask.Length];
                                    for (int i = 0; i < read.Length; i++)
                                    {
                                        masked[i] = (byte)(test.Type == HeaderSkipTest.And ? read[i] & test.Mask[i] :
                                                           (test.Type == HeaderSkipTest.Or ? read[i] | test.Mask[i] : read[i] ^ test.Mask[i])
                                                           );
                                    }

                                    // Finally, compare it against the value
                                    for (int i = 0; i < test.Value.Length; i++)
                                    {
                                        if (masked[i] != test.Value[i])
                                        {
                                            result = false;
                                            break;
                                        }
                                    }
                                }
                                catch
                                {
                                    result = false;
                                }

                                // Return if the expected and actual results match
                                success &= (result == test.Result);
                                break;

                            case HeaderSkipTest.File:
                                // First get the file size from stream
                                long size = input.Length;

                                // If we have a null size, check that the size is a power of 2
                                result = true;
                                if (test.Size == null)
                                {
                                    // http://stackoverflow.com/questions/600293/how-to-check-if-a-number-is-a-power-of-2
                                    result = (((ulong)size & ((ulong)size - 1)) == 0);
                                }
                                else if (test.Operator == HeaderSkipTestFileOperator.Less)
                                {
                                    result = (size < test.Size);
                                }
                                else if (test.Operator == HeaderSkipTestFileOperator.Greater)
                                {
                                    result = (size > test.Size);
                                }
                                else if (test.Operator == HeaderSkipTestFileOperator.Equal)
                                {
                                    result = (size == test.Size);
                                }

                                // Return if the expected and actual results match
                                success &= (result == test.Result);
                                break;
                            }
                        }

                        // If we still have a success, then return this rule
                        if (success)
                        {
                            // If we're not keeping the stream open, dispose of the binary reader
                            if (!keepOpen)
                            {
                                input.Dispose();
                            }

                            Globals.Logger.User(" Matching rule found!");
                            return(rule);
                        }
                    }
                }
            }

            // If we're not keeping the stream open, dispose of the binary reader
            if (!keepOpen)
            {
                input.Dispose();
            }

            // If we have a blank rule, inform the user
            if (skipperRule.Tests == null)
            {
                Globals.Logger.Verbose("No matching rule found!");
            }

            return(skipperRule);
        }
 protected override void Load(System.IO.BinaryReader reader)
 {
     m_data = reader.ReadBytes(88);
 }
Exemple #46
0
        public ActionResult EditPost(int?id, HttpPostedFileBase upload)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            var studentToUpdate = db.Students.Find(id);

            if (TryUpdateModel(studentToUpdate, "",
                               new string[] { "LastName", "FirstMidName", "EnrollmentDate" }))
            {
                try
                {
                    if (upload != null && upload.ContentLength > 0)
                    {
                        //string typeFile = Path.GetExtension(upload.FileName);
                        CheckImage check = new CheckImage();
                        //getting the image
                        string fileName = System.IO.Path.GetExtension(upload.FileName);

                        //call of the verification Extension method
                        bool extensionIsTrue = check.checkExtension(fileName);

                        if (extensionIsTrue == false)
                        {
                            ViewBag.ErrorType = ErrorMessages.ErrorExtension();
                            Student student = db.Students.Include(s => s.Files).SingleOrDefault(s => s.ID == id);
                            return(View(student));
                        }

                        //call of the verfication Size method
                        bool sizeIsCorrect = check.checkSize(upload.ContentLength);

                        if (sizeIsCorrect == false)
                        {
                            ViewBag.ErrorSize = ErrorMessages.ErrorSize();
                            Student student = db.Students.Include(s => s.Files).SingleOrDefault(s => s.ID == id);
                            return(View(student));
                        }

                        //Remove the the previous image
                        if (studentToUpdate.Files.Any(f => f.FileType == FileType.Avatar))
                        {
                            db.Files.Remove(studentToUpdate.Files.First(f => f.FileType == FileType.Avatar));
                        }

                        var avatar = new FileImage
                        {
                            FileName    = System.IO.Path.GetFileName(upload.FileName),
                            FileType    = FileType.Avatar,
                            ContentType = upload.ContentType
                        };

                        using (var reader = new System.IO.BinaryReader(upload.InputStream))
                        {
                            avatar.Content = reader.ReadBytes(upload.ContentLength);
                        }
                        studentToUpdate.Files = new List <FileImage> {
                            avatar
                        };
                    }

                    db.Entry(studentToUpdate).State = EntityState.Modified;
                    db.SaveChanges();

                    return(RedirectToAction("Index"));
                }
                catch (RetryLimitExceededException /* dex */)
                {
                    //Log the error (uncomment dex variable name and add a line here to write a log.
                    ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
                }
            }
            return(View(studentToUpdate));
        }
 protected override void Load(System.IO.BinaryReader reader)
 {
     m_data = reader.ReadBytes(560);
     UpdateParticipants();
 }
Exemple #48
0
        //public string suva_EventDatetimeDate;
        //public string suva_EventDatetimeHour;
        //public string suva_EventDatetimeMin;
        //public string suva_EventDatetimeWeekday;
        //public bool suva_CompanyMode1;
        //public bool suva_CompanyMode2;
        //public bool suva_CompanyMode3;
        //public string suva_CompanyName;
        //public string suva_CompanyAddress;
        //public string suva_CompanyZIP;
        //public string suva_CompanyCity;
        //public string suva_CompanySector;
        //public string suva_EmployerAccountNo;
        //public string suva_NumberOfEmployees;
        //public string suva_ContractorName;
        //public string suva_ContractorAddress;
        //public string suva_ContractorZIP;
        //public string suva_ContractorCity;
        //public string suva_ContractorAccountNo;
        //public string suva_ContractorContact;
        //public string suva_ContractorContactTel;
        //public string suva_VictimLastname;
        //public string suva_VictimFirstname;
        //public string suva_VictimAddress;
        //public string suva_VictimZIP;
        //public string suva_VictimCity;
        //public string suva_VictimInsuranceComp;
        //public string suva_VictimInsuranceNo;
        //public string suva_VictimBirthdateDay;
        //public string suva_VictimBirthdateMonth;
        //public string suva_VictimBirthdateYear;
        //public bool suva_VictimGender1;
        //public bool suva_VictimGender2;
        //public string suva_VictimNationality;
        //public string suva_VictimHiredate;
        //public string suva_VictimEmployedAs;
        //public string suva_VictimPersnr;
        //public string suva_VictimCostCenter;
        //public bool suva_EmploymentStatus1;
        //public bool suva_EmploymentStatus2;
        //public bool suva_EmploymentStatus3;
        //public bool suva_EmploymentStatus4;
        //public bool suva_EmploymentExtent1;
        //public bool suva_EmploymentExtent2;
        //public bool suva_EmploymentLimit0;
        //public bool suva_EmploymentLimit1;
        //public string suva_WorktimeStartHour;
        //public string suva_WorktimeStartMin;
        //public string suva_WorktimeEndHour;
        //public string suva_WorktimeEndMin;
        //public string suva_OvertimeStartHour;
        //public string suva_OvertimeStartMin;
        //public string suva_OvertimeEndHour;
        //public string suva_OvertimeEndMin;
        //public bool suva_AccidentLocation1;
        //public bool suva_AccidentLocation2;
        //public string suva_AccidentWorkplace;
        //public string suva_AccidentWorkplaceDet;
        //public string suva_TypeOfWork;
        //public string suva_CourseOfEvents;
        //public bool suva_ReportedBy1;
        //public bool suva_ReportedBy2;
        //public bool suva_ReportedBy4;
        //public bool suva_ReportedBy8;
        //public string suva_Bodypart;
        //public string suva_NatureOfInjury;
        //public bool suva_Attenders1;
        //public bool suva_Attenders2;
        //public bool suva_Attenders3;
        //public string suva_AttenderDetails;
        //public bool suva_TravelaccidentType1;
        //public bool suva_TravelaccidentType2;
        //public bool suva_TravelaccidentType3;
        //public bool suva_TravelaccidentType4;
        //public string suva_TravelaccidentPurpos;
        //public string suva_TravelaccidentOffset;
        //public string suva_TravelaccidentDest;
        //public bool suva_Ambulance1;
        //public bool suva_Ambulance2;
        //public bool suva_Ambulance3;
        //public string suva_AmbulanceOrganisat;
        //public bool suva_InvestigatorPolice;
        //public string suva_InvestigatorPoliceSt;
        //public bool suva_InvestAuthority;
        //public string suva_InvestAuthorityOff;
        //public bool suva_Workstopped1;
        //public bool suva_Workstopped2;
        //public bool suva_Workstopped3;
        //public string suva_WorkstoppedDate;
        //public string suva_WorkstoppedHour;
        //public string suva_WorkstoppedMin;
        //public bool suva_FatalityRelatives0;
        //public bool suva_FatalityRelatives1;
        //public bool suva_FatalityRelations1;
        //public bool suva_FatalityRelations2;
        //public bool suva_SickLeave0;
        //public bool suva_SickLeave1;
        //public bool suva_SickLeave2;
        //public string suva_SickLeaveEnded;
        //public bool suva_Hospital0;
        //public bool suva_Hospital1;
        //public bool suva_HospitalStay1;
        //public bool suva_HospitalStay2;
        //public string suva_HospitalEntry;
        //public string suva_HospitalName;
        //public string suva_Hospitaladdress;
        //public bool suva_DoctorTreatment0;
        //public bool suva_DoctorTreatment1;
        //public string suva_DoctorDate;
        //public string suva_DoctorName;
        //public string suva_DoctorAddress;
        //public bool suva_ObligationToTrain0;
        //public bool suva_ObligationToTrain1;
        //public string suva_TrainingText;
        //public string suva_ReporterNameFunction;
        //public string suva_BossNameFunction;
        //public string suva_ContactTel;
        //public string suva_ContactFax;
        //public string suva_ContactEMail;
        //public string suva_IssuedAt;
        //public string suva_Issued;

        /// <summary>
        /// Makes a doc file representing the filled-in SUVA form
        /// </summary>
        public bool Render(string rpt_temp_path, ref MemoryStream docstream)
        {
#if LINUX
            return(false);
#else
            DateTime     nowtime              = DateTime.UtcNow;
            const string temp_file_naming     = "sherm-suva-temp-doc-template-{0}.doc";
            const string dest_file_naming     = "sherm-suva-temp-doc-complete-{0}.doc";
            const string result_file_naming   = "sherm-suva-temp-doc-result-{0}.{1}";
            string       temp_file_name       = String.Format(temp_file_naming, nowtime.ToString("yyyyMMddHHmmss"));
            string       dest_file_name       = String.Format(dest_file_naming, nowtime.ToString("yyyyMMddHHmmss"));
            string       result_file_name     = String.Format(result_file_naming, nowtime.ToString("yyyyMMddHHmmss"), this.GetResultFileExtension());
            object       missing              = System.Reflection.Missing.Value;
            object       o_false              = false;
            object       o_true               = true;
            string       templateResourcePath = GetTemplateResourcePath();
            try
            {
                if (docstream == null)
                {
                    docstream = new MemoryStream();
                }
                string tempPath         = rpt_temp_path; /* [dlatikay 20121121] we do not bother the system, we have our own: was: Path.GetTempPath(); */
                string temp_file_path   = Path.Combine(tempPath, temp_file_name);
                string dest_file_path   = Path.Combine(tempPath, dest_file_name);
                object result_file_path = Path.Combine(tempPath, result_file_name);
                /* 1. open the template */
                using (var t_doc = new System.IO.BinaryReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(templateResourcePath)))
                {
                    /* 1a. we must persist it in the temporary files folder */
                    using (var os = new FileStream(temp_file_path, FileMode.Create, FileAccess.Write))
                    {
                        using (BinaryWriter t_doc_wr = new BinaryWriter(os))
                        {
                            byte[] tempdoccontent = t_doc.ReadBytes((int)t_doc.BaseStream.Length);
                            t_doc_wr.Write(tempdoccontent);
                        }
                    }
                }
                /* remove the read-only attribute */
                FileAttributes attr = File.GetAttributes(temp_file_path);
                attr &= ~FileAttributes.ReadOnly; /* lovely */
                File.SetAttributes(temp_file_path, attr);
                /* 1b. get us an instance of MS Word and open the template */
                Word.Application word = null;
                try
                {
                    object o_temp_file_path = temp_file_path;
                    object o_dest_file_path = dest_file_path;
                    word = new Word.Application();
                    Word.Document doc = word.Documents.Open(ref o_temp_file_path, ref o_false, ref o_true, ref o_false, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref o_false, ref o_false, ref missing, ref o_true, ref missing);
                    doc.SaveAs(ref o_dest_file_path, ref missing, ref missing, ref missing, ref o_false, ref missing, ref o_false, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);
                    /* set the standard (builtin) document properties */
                    object oBuiltInProps = doc.BuiltInDocumentProperties;
                    Type   tBuiltInProps = oBuiltInProps.GetType();
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Title", documenttitle });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Subject", documentsubject });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Author", documentauthor });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Manager", documentmanager });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Company", documentcompany });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Category", documentcategory });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Keywords", documentkeywords });
                    tBuiltInProps.InvokeMember("Item", BindingFlags.Default | BindingFlags.SetProperty, null, oBuiltInProps, new object[] { "Comments", documentcomments });
                    /* set the extended (custom) document properties */


                    /* now its time to set all the bookmarks */
                    //doc.Unprotect(ref missing);
                    SetFormfieldText(doc, "VictimBirthDate", suva_VictimBirthdate);
                    SetFormfieldText(doc, "VictimEmployedAs", suva_VictimEmployedAs);
                    SetFormfieldText(doc, "Bodypart", suva_Bodypart);
                    SetFormfieldText(doc, "Bodyside", suva_Bodyside);
                    SetFormfieldCheck(doc, "WorkStoppedYes", suva_WorkStopped);
                    SetFormfieldCheck(doc, "WorkStoppedNo", !suva_WorkStopped);
                    SetFormfieldText(doc, "WorkStoppedDate", suva_WorkStoppedDatetime);
                    SetFormfieldText(doc, "LastWorkDay", suva_LastWorkday);
                    SetFormfieldText(doc, "ResumedWork", suva_ResumedWork);
                    SetFormfieldText(doc, "HospitalName", suva_HospitalName);
                    SetFormfieldText(doc, "HospitalName2", suva_HospitalName2);
                    SetFormfieldText(doc, "HospitalAddress", suva_HosptialAddress);
                    SetFormfieldText(doc, "HospitalAddress2", suva_HosptialAddress2);
                    //SetFormfieldText(doc, "EventDatetimeDate", suva_EventDatetimeDate);
                    //SetFormfieldText(doc, "EventDatetimeHour", suva_EventDatetimeHour);
                    //SetFormfieldText(doc, "EventDatetimeMin", suva_EventDatetimeMin);
                    //SetFormfieldText(doc, "EventDatetimeWeekday", suva_EventDatetimeWeekday);
                    //SetFormfieldCheck(doc, "CompanyMode1", suva_CompanyMode1);
                    //SetFormfieldCheck(doc, "CompanyMode2", suva_CompanyMode2);
                    //SetFormfieldCheck(doc, "CompanyMode3", suva_CompanyMode3);
                    //SetFormfieldText(doc, "CompanyName", suva_CompanyName);
                    //SetFormfieldText(doc, "CompanyAddress", suva_CompanyAddress);
                    //SetFormfieldText(doc, "CompanyZIP", suva_CompanyZIP);
                    //SetFormfieldText(doc, "CompanyCity", suva_CompanyCity);
                    //SetFormfieldText(doc, "CompanySector", suva_CompanySector);
                    //SetFormfieldText(doc, "EmployerAccountNo", suva_EmployerAccountNo);
                    //SetFormfieldText(doc, "NumberOfEmployees", suva_NumberOfEmployees);
                    //SetFormfieldText(doc, "ContractorName", suva_ContractorName);
                    //SetFormfieldText(doc, "ContractorAddress", suva_ContractorAddress);
                    //SetFormfieldText(doc, "ContractorZIP", suva_ContractorZIP);
                    //SetFormfieldText(doc, "ContractorCity", suva_ContractorCity);
                    //SetFormfieldText(doc, "ContractorAccountNo", suva_ContractorAccountNo);
                    //SetFormfieldText(doc, "ContractorContact", suva_ContractorContact);
                    //SetFormfieldText(doc, "ContractorContactTel", suva_ContractorContactTel);
                    //SetFormfieldText(doc, "VictimLastname", suva_VictimLastname);
                    //SetFormfieldText(doc, "VictimFirstname", suva_VictimFirstname);
                    //SetFormfieldText(doc, "VictimAddress", suva_VictimAddress);
                    //SetFormfieldText(doc, "VictimZIP", suva_VictimZIP);
                    //SetFormfieldText(doc, "VictimCity", suva_VictimCity);
                    //SetFormfieldText(doc, "VictimInsuranceComp", suva_VictimInsuranceComp);
                    //SetFormfieldText(doc, "VictimInsuranceNo", suva_VictimInsuranceNo);
                    //SetFormfieldText(doc, "VictimBirthdateDay", suva_VictimBirthdateDay);
                    //SetFormfieldText(doc, "VictimBirthdateMonth", suva_VictimBirthdateMonth);
                    //SetFormfieldText(doc, "VictimBirthdateYear", suva_VictimBirthdateYear);
                    //SetFormfieldCheck(doc, "VictimGender1", suva_VictimGender1);
                    //SetFormfieldCheck(doc, "VictimGender2", suva_VictimGender2);
                    //SetFormfieldText(doc, "VictimNationality", suva_VictimNationality);
                    //SetFormfieldText(doc, "VictimHiredate", suva_VictimHiredate);
                    //SetFormfieldText(doc, "VictimEmployedAs", suva_VictimEmployedAs);
                    //SetFormfieldCheck(doc, "EmploymentStatus1", suva_EmploymentStatus1);
                    //SetFormfieldCheck(doc, "EmploymentStatus2", suva_EmploymentStatus2);
                    //SetFormfieldCheck(doc, "EmploymentStatus3", suva_EmploymentStatus3);
                    //SetFormfieldCheck(doc, "EmploymentStatus4", suva_EmploymentStatus4);
                    //SetFormfieldCheck(doc, "EmploymentExtent1", suva_EmploymentExtent1);
                    //SetFormfieldCheck(doc, "EmploymentExtent2", suva_EmploymentExtent2);
                    //SetFormfieldCheck(doc, "EmploymentLimit0", suva_EmploymentLimit0);
                    //SetFormfieldCheck(doc, "EmploymentLimit1", suva_EmploymentLimit1);
                    //SetFormfieldText(doc, "WorktimeStartHour", suva_WorktimeStartHour);
                    //SetFormfieldText(doc, "WorktimeStartMin", suva_WorktimeStartMin);
                    //SetFormfieldText(doc, "WorktimeEndHour", suva_WorktimeEndHour);
                    //SetFormfieldText(doc, "WorktimeEndMin", suva_WorktimeEndMin);
                    //SetFormfieldText(doc, "OvertimeStartHour", suva_OvertimeStartHour);
                    //SetFormfieldText(doc, "OvertimeStartMin", suva_OvertimeStartMin);
                    //SetFormfieldText(doc, "OvertimeEndHour", suva_OvertimeEndHour);
                    //SetFormfieldText(doc, "OvertimeEndMin", suva_OvertimeEndMin);
                    //SetFormfieldCheck(doc, "AccidentLocation1", suva_AccidentLocation1);
                    //SetFormfieldCheck(doc, "AccidentLocation2", suva_AccidentLocation2);
                    //SetFormfieldText(doc, "AccidentWorkplace", suva_AccidentWorkplace);
                    //SetFormfieldText(doc, "AccidentWorkplaceDet", suva_AccidentWorkplaceDet);
                    //SetFormfieldText(doc, "TypeOfWork", suva_TypeOfWork);
                    //SetFormfieldText(doc, "CourseOfEvents", suva_CourseOfEvents);
                    //SetFormfieldCheck(doc, "ReportedBy1", suva_ReportedBy1);
                    //SetFormfieldCheck(doc, "ReportedBy2", suva_ReportedBy2);
                    //SetFormfieldCheck(doc, "ReportedBy4", suva_ReportedBy4);
                    //SetFormfieldCheck(doc, "ReportedBy8", suva_ReportedBy8);
                    //SetFormfieldText(doc, "Bodypart", suva_Bodypart);
                    //SetFormfieldText(doc, "NatureOfInjury", suva_NatureOfInjury);
                    //SetFormfieldCheck(doc, "Attenders1", suva_Attenders1);
                    //SetFormfieldCheck(doc, "Attenders2", suva_Attenders2);
                    //SetFormfieldCheck(doc, "Attenders3", suva_Attenders3);
                    //SetFormfieldText(doc, "AttenderDetails", suva_AttenderDetails);
                    //SetFormfieldCheck(doc, "TravelaccidentType1", suva_TravelaccidentType1);
                    //SetFormfieldCheck(doc, "TravelaccidentType2", suva_TravelaccidentType2);
                    //SetFormfieldCheck(doc, "TravelaccidentType3", suva_TravelaccidentType3);
                    //SetFormfieldCheck(doc, "TravelaccidentType4", suva_TravelaccidentType4);
                    //SetFormfieldText(doc, "TravelaccidentPurpos", suva_TravelaccidentPurpos);
                    //SetFormfieldText(doc, "TravelaccidentOffset", suva_TravelaccidentOffset);
                    //SetFormfieldText(doc, "TravelaccidentDest", suva_TravelaccidentDest);
                    //SetFormfieldCheck(doc, "Ambulance1", suva_Ambulance1);
                    //SetFormfieldCheck(doc, "Ambulance2", suva_Ambulance2);
                    //SetFormfieldCheck(doc, "Ambulance3", suva_Ambulance3);
                    //SetFormfieldText(doc, "AmbulanceOrganisat", suva_AmbulanceOrganisat);
                    //SetFormfieldCheck(doc, "InvestigatorPolice", suva_InvestigatorPolice);
                    //SetFormfieldText(doc, "InvestigatorPoliceSt", suva_InvestigatorPoliceSt);
                    //SetFormfieldCheck(doc, "InvestAuthority", suva_InvestAuthority);
                    //SetFormfieldText(doc, "InvestAuthorityOff", suva_InvestAuthorityOff);
                    //SetFormfieldCheck(doc, "Workstopped1", suva_Workstopped1);
                    //SetFormfieldCheck(doc, "Workstopped2", suva_Workstopped2);
                    //SetFormfieldCheck(doc, "Workstopped3", suva_Workstopped3);
                    //SetFormfieldText(doc, "WorkstoppedDate", suva_WorkstoppedDate);
                    //SetFormfieldText(doc, "WorkstoppedHour", suva_WorkstoppedHour);
                    //SetFormfieldText(doc, "WorkstoppedMin", suva_WorkstoppedMin);
                    //SetFormfieldCheck(doc, "FatalityRelatives0", suva_FatalityRelatives0);
                    //SetFormfieldCheck(doc, "FatalityRelatives1", suva_FatalityRelatives1);
                    //SetFormfieldCheck(doc, "FatalityRelations1", suva_FatalityRelations1);
                    //SetFormfieldCheck(doc, "FatalityRelations2", suva_FatalityRelations2);
                    //SetFormfieldCheck(doc, "SickLeave0", suva_SickLeave0);
                    //SetFormfieldCheck(doc, "SickLeave1", suva_SickLeave1);
                    //SetFormfieldCheck(doc, "SickLeave2", suva_SickLeave2);
                    //SetFormfieldText(doc, "SickLeaveEnded", suva_SickLeaveEnded);
                    //SetFormfieldCheck(doc, "Hospital0", suva_Hospital0);
                    //SetFormfieldCheck(doc, "Hospital1", suva_Hospital1);
                    //SetFormfieldCheck(doc, "HospitalStay1", suva_HospitalStay1);
                    //SetFormfieldCheck(doc, "HospitalStay2", suva_HospitalStay2);
                    //SetFormfieldText(doc, "HospitalEntry", suva_HospitalEntry);
                    //SetFormfieldText(doc, "HospitalName", suva_HospitalName);
                    //SetFormfieldText(doc, "Hospitaladdress", suva_Hospitaladdress);
                    //SetFormfieldCheck(doc, "DoctorTreatment0", suva_DoctorTreatment0);
                    //SetFormfieldCheck(doc, "DoctorTreatment1", suva_DoctorTreatment1);
                    //SetFormfieldText(doc, "DoctorDate", suva_DoctorDate);
                    //SetFormfieldText(doc, "DoctorName", suva_DoctorName);
                    //SetFormfieldText(doc, "DoctorAddress", suva_DoctorAddress);
                    //SetFormfieldCheck(doc, "ObligationToTrain0", suva_ObligationToTrain0);
                    //SetFormfieldCheck(doc, "ObligationToTrain1", suva_ObligationToTrain1);
                    //SetFormfieldText(doc, "TrainingText", suva_TrainingText);
                    //SetFormfieldText(doc, "ReporterNameFunction", suva_ReporterNameFunction);
                    //SetFormfieldText(doc, "BossNameFunction", suva_BossNameFunction);
                    //SetFormfieldText(doc, "ContactTel", suva_ContactTel);
                    //SetFormfieldText(doc, "ContactFax", suva_ContactFax);
                    //SetFormfieldText(doc, "ContactEMail", suva_ContactEMail);
                    //SetFormfieldText(doc, "IssuedAt", suva_IssuedAt);
                    //SetFormfieldText(doc, "Issued", suva_Issued);
                    /* set export type dependend bookmarks */
                    switch (this.SUVAExportType)
                    {
                    default:
                    {
                        break;
                    }
                    }
                    doc.Protect(Microsoft.Office.Interop.Word.WdProtectionType.wdAllowOnlyFormFields, ref o_true, ref missing, ref o_false, ref o_false);
                    /* persist it */
#pragma warning disable 0467
                    /* the pragma is for the event member */

                    doc.Save();

                    object fileFormat = missing;
                    if (this.SUVAExportType != SUVAExportType.Default)
                    {
                        fileFormat = Word.WdSaveFormat.wdFormatPDF;
                    }
                    doc.SaveAs(ref result_file_path, ref fileFormat, ref missing, ref missing, ref o_false, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing, ref missing);
                    doc.Close(ref o_false, ref missing, ref missing);
#pragma warning restore 0467
                }
                catch (Exception)
                {
                    /* up the exception chain */
                    throw;
                }
                finally
                {
                    /* cleanup word */
                    if (word != null)
                    {
                        try
                        {
#pragma warning disable 0467
                            /* the pragma is for the event member */
                            word.Quit(ref missing, ref missing, ref missing);
#pragma warning restore 0467
                        }
                        catch (Exception) { }
                        try
                        {
                            System.Runtime.InteropServices.Marshal.FinalReleaseComObject(word);
                        }
                        catch (System.Exception) { }
                        word = null;
                    }
                }
                /* need to wait until the COM handles are really closed */

                /* now we load the document into memory and deliver the stream. the file is deleted. */
                using (FileStream ifs = new FileStream(result_file_path.ToString(), FileMode.Open, FileAccess.Read))
                {
                    using (BinaryReader rd = new BinaryReader(ifs))
                    {
                        docstream.Write(rd.ReadBytes((int)rd.BaseStream.Length), 0, (int)rd.BaseStream.Length);
                        rd.Close();
                        docstream.Seek(0, SeekOrigin.Begin);
                    }
                }
                File.Delete(temp_file_path);
                File.Delete(dest_file_path);
                File.Delete(result_file_path.ToString());
                /* succeeded */
                return(true);
            }
            catch (Exception)
            {
                /* for debugging purposes */
                throw;
            }
#endif
        }
Exemple #49
0
        public override OricProgram LoadFile(string diskName, OricFileInfo oricFileInfo)
        {
            int index            = 0;
            int totalDescriptors = 0;

            Byte dataTrack      = 0;
            Byte dataSector     = 0;
            Byte nextDescTrack  = 0;
            Byte nextDescSector = 1;

            OricProgram loadedProgram = new OricProgram();

            loadedProgram.New();

            String diskPathname = Path.Combine(oricFileInfo.Folder, oricFileInfo.ParentName);

            if (base.LoadDisk(diskPathname))
            {
                Byte[] fileDescriptor = GetFileDescriptor(oricFileInfo.ProgramName);

                loadedProgram.Format      = GetFileFormat(fileDescriptor);
                loadedProgram.ProgramName = oricFileInfo.ProgramName;

                if (loadedProgram.ProgramName.ToUpper().EndsWith(".CHS"))
                {
                    loadedProgram.Format = OricProgram.ProgramFormat.CharacterSet;
                }

                if (loadedProgram.ProgramName.ToUpper().EndsWith(".HRS"))
                {
                    loadedProgram.Format = OricProgram.ProgramFormat.HiresScreen;
                }

                Byte formatFlag = fileDescriptor[0x03];

                if ((formatFlag & 0x01) == 0x01)
                {
                    loadedProgram.AutoRun = OricProgram.AutoRunFlag.Enabled;
                }
                else
                {
                    loadedProgram.AutoRun = OricProgram.AutoRunFlag.Disabled;
                }

                UInt16 sectorsToLoad = (UInt16)(fileDescriptor[0x0A] + (fileDescriptor[0x0B] * 256));

                // Get program header info
                switch (loadedProgram.Format)
                {
                case OricProgram.ProgramFormat.DirectAccessFile:
                    loadedProgram.RecordCount  = (UInt16)(fileDescriptor[0x04] + (fileDescriptor[0x05] * 256));
                    loadedProgram.RecordLength = (UInt16)(fileDescriptor[0x06] + (fileDescriptor[0x07] * 256));

                    loadedProgram.StartAddress = 0x0000;
                    loadedProgram.EndAddress   = (UInt16)(loadedProgram.RecordCount * loadedProgram.RecordLength);
                    break;

                case OricProgram.ProgramFormat.SequentialFile:
                    loadedProgram.RecordCount  = 0;
                    loadedProgram.RecordLength = 0;

                    loadedProgram.StartAddress = 0x0000;
                    loadedProgram.EndAddress   = (UInt16)(sectorsToLoad * fileDescriptor.Length);
                    break;

                default:
                    loadedProgram.RecordCount  = 0;
                    loadedProgram.RecordLength = 0;

                    loadedProgram.StartAddress = (UInt16)(fileDescriptor[0x04] + (fileDescriptor[0x05] * 256));
                    loadedProgram.EndAddress   = (UInt16)(fileDescriptor[0x06] + (fileDescriptor[0x07] * 256));
                    break;
                }

                do
                {
                    System.IO.MemoryStream stm = new System.IO.MemoryStream(fileDescriptor, 0, fileDescriptor.Length);
                    System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm);

                    Byte[] byteArray = new Byte[32];

                    nextDescTrack  = rdr.ReadByte();
                    nextDescSector = rdr.ReadByte();

                    Byte firstDescriptorFlag = rdr.ReadByte();

                    int descriptorIndex = 0;

                    if (firstDescriptorFlag == 0xFF)
                    {
                        byteArray = rdr.ReadBytes(9);

                        dataTrack  = rdr.ReadByte();
                        dataSector = rdr.ReadByte();

                        totalDescriptors = 121;
                    }
                    else
                    {
                        dataTrack  = firstDescriptorFlag;
                        dataSector = rdr.ReadByte();

                        totalDescriptors = 126;
                    }

                    int programLength = (loadedProgram.EndAddress - loadedProgram.StartAddress) + 1;

                    //loadedProgram.m_programData = new Byte[0xFFFF];
                    loadedProgram.m_programData = new Byte[programLength];

                    while (dataSector != 0 && descriptorIndex < totalDescriptors)
                    {
                        Byte[] programData = base.ReadSector(dataTrack, dataSector);

                        System.IO.MemoryStream stm2 = new System.IO.MemoryStream(programData, 0, programData.Length);
                        System.IO.BinaryReader rdr2 = new System.IO.BinaryReader(stm2);

                        Byte tmpByte = 0;

                        for (int loop = 0; loop < programData.Length; loop++)
                        {
                            tmpByte = rdr2.ReadByte();

                            if (index < programLength)
                            {
                                loadedProgram.m_programData[index] = tmpByte;
                            }

                            index++;
                        }

                        if (dataSector != 0)
                        {
                            dataTrack  = rdr.ReadByte();
                            dataSector = rdr.ReadByte();

                            descriptorIndex++;
                        }
                    }

                    if (nextDescSector != 0)
                    {
                        fileDescriptor.Initialize();
                        fileDescriptor = base.ReadSector(nextDescTrack, nextDescSector);
                    }
                } while (nextDescSector != 0);
            }

            return(loadedProgram);
        }
Exemple #50
0
        public string ReadStr()
        {
            int c = IPAddress.NetworkToHostOrder(br.ReadInt32());

            return((c > 0) ? encoding.GetString(br.ReadBytes(c)) : string.Empty);
        }
Exemple #51
0
        private OricFileInfo[] ReadSedOricDirectory()
        {
            OricFileInfo[] diskDirectory = null;

            //int noOfFiles = 0;

            System.Text.Encoding enc = System.Text.Encoding.ASCII;

            ArrayList diskCatalog = new ArrayList();

            Byte bNextTrack  = Convert.ToByte(20);
            Byte bNextSector = Convert.ToByte(4);

            Byte bCurrTrack  = bNextTrack;
            Byte bCurrSector = bNextSector;

            Boolean MoreDirectories = true;

            while (MoreDirectories)
            {
                // Read the first directory sector
                Byte[] directory = base.ReadSector(bCurrTrack, bCurrSector);

                if (directory[0] == 0x00 && directory[1] == 0x00)
                {
                    MoreDirectories = false;
                }
                else
                {
                    bCurrTrack  = directory[0];
                    bCurrSector = directory[1];
                }

                // Scan thru all 15 entries to build the directory
                UInt16 DirectoryIndex = 0;

                System.IO.MemoryStream stm = new System.IO.MemoryStream(directory, 0, 256);
                System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm);
                stm.Seek(0x10, SeekOrigin.Begin);

                do
                {
                    if (rdr.PeekChar() != 0x00)
                    {
                        // Read the filename
                        String Filename = enc.GetString(rdr.ReadBytes(9)).Trim();

                        // Read the file extension
                        String FileExtension = enc.GetString(rdr.ReadBytes(3)).Trim();

                        // Read the file descriptor track
                        Byte FileDescTrack = rdr.ReadByte();

                        // Read the file descriptor sector
                        Byte FileDescSector = rdr.ReadByte();

                        // Read the no. of sectors used by file (includes file descriptor)
                        Byte SectorsUsed = rdr.ReadByte();

                        // Read the files protection status
                        Byte ProtectionStatus = rdr.ReadByte();

                        OricFileInfo diskFileInfo = new OricFileInfo();
                        diskFileInfo.MediaType = OricExplorer.MediaType.DiskFile;

                        //diskFileInfo.m_bDosFormat = OricDisk.DOSFormat.SedOric;

                        diskFileInfo.Folder     = base.diskFolder;
                        diskFileInfo.ParentName = base.diskPathname;

                        diskFileInfo.ProgramName = Filename;
                        diskFileInfo.Extension   = FileExtension;

                        if (FileExtension.Length > 0)
                        {
                            diskFileInfo.ProgramName = String.Format("{0}.{1}", Filename, FileExtension);
                        }
                        else
                        {
                            diskFileInfo.ProgramName = Filename;
                        }

                        diskFileInfo.FirstTrack    = FileDescTrack;
                        diskFileInfo.FirstSector   = FileDescSector;
                        diskFileInfo.LengthSectors = SectorsUsed;

                        if (ProtectionStatus == 0xC0)
                        {
                            diskFileInfo.Protection = OricProgram.ProtectionStatus.Protected;
                        }
                        else if (ProtectionStatus == 0x40)
                        {
                            diskFileInfo.Protection = OricProgram.ProtectionStatus.Unprotected;
                        }
                        else
                        {
                            diskFileInfo.Protection = OricProgram.ProtectionStatus.Unprotected;
                        }

                        Byte[] FileDescriptor = base.ReadSector(FileDescTrack, FileDescSector);

                        System.IO.MemoryStream stmFileDescriptor = new System.IO.MemoryStream(FileDescriptor, 0, FileDescriptor.Length);
                        System.IO.BinaryReader rdrFileDescriptor = new System.IO.BinaryReader(stmFileDescriptor);

                        stmFileDescriptor.Seek(0x03, SeekOrigin.Begin);

                        Byte FileType = rdrFileDescriptor.ReadByte();

                        if ((FileType & 0x08) == 0x08)
                        {
                            // We have a direct access file
                            diskFileInfo.m_ui16NoOfRecords  = rdrFileDescriptor.ReadUInt16();
                            diskFileInfo.m_ui16RecordLength = rdrFileDescriptor.ReadUInt16();

                            diskFileInfo.StartAddress = 0x0000;
                            diskFileInfo.EndAddress   = (ushort)(diskFileInfo.m_ui16NoOfRecords * diskFileInfo.m_ui16RecordLength);
                        }
                        else if ((FileType & 0x10) == 0x10)
                        {
                            // We have a sequential file
                            diskFileInfo.StartAddress = 0x0000;
                            diskFileInfo.EndAddress   = (ushort)((diskFileInfo.LengthSectors - 1) * 256);
                        }
                        else
                        {
                            diskFileInfo.StartAddress = rdrFileDescriptor.ReadUInt16();
                            diskFileInfo.EndAddress   = rdrFileDescriptor.ReadUInt16();
                        }

                        diskFileInfo.ExeAddress = rdrFileDescriptor.ReadUInt16();

                        if ((FileType & 0x08) == 0x08)
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.DirectAccessFile;
                        }
                        else if ((FileType & 0x10) == 0x10)
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.SequentialFile;
                        }
                        else if ((FileType & 0x20) == 0x20)
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.WindowFile;
                        }
                        else if ((FileType & 0x40) == 0x40)
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.CodeFile;
                        }
                        else if ((FileType & 0x80) == 0x80)
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.BasicProgram;
                        }
                        else
                        {
                            diskFileInfo.Format = OricProgram.ProgramFormat.UnknownFile;
                        }

                        if (diskFileInfo.Format == OricProgram.ProgramFormat.CodeFile)
                        {
                            switch (diskFileInfo.StartAddress)
                            {
                            case 0xBB80:
                                if (diskFileInfo.ProgramName.ToUpper().EndsWith(".HLP"))
                                {
                                    diskFileInfo.Format = OricProgram.ProgramFormat.HelpFile;
                                }
                                else
                                {
                                    diskFileInfo.Format = OricProgram.ProgramFormat.TextScreen;
                                }
                                break;

                            case 0xBBA8:
                                if (diskFileInfo.ProgramName.ToUpper().EndsWith(".HLP"))
                                {
                                    diskFileInfo.Format = OricProgram.ProgramFormat.HelpFile;
                                }
                                else
                                {
                                    diskFileInfo.Format = OricProgram.ProgramFormat.TextScreen;
                                }
                                break;

                            case 0xA000: diskFileInfo.Format = OricProgram.ProgramFormat.HiresScreen; break;

                            case 0xB500: diskFileInfo.Format = OricProgram.ProgramFormat.CharacterSet; break;

                            default: diskFileInfo.Format = OricProgram.ProgramFormat.CodeFile; break;
                            }

                            if (diskFileInfo.StartAddress >= 0xA000 && diskFileInfo.StartAddress <= 0xBF3F)
                            {
                                // Possibly a HIRES screen
                                if (diskFileInfo.ProgramName.ToUpper().EndsWith(".HRS"))
                                {
                                    diskFileInfo.Format = OricProgram.ProgramFormat.HiresScreen;
                                }
                            }

                            if (diskFileInfo.ProgramName.ToUpper().EndsWith(".CHS"))
                            {
                                diskFileInfo.Format = OricProgram.ProgramFormat.CharacterSet;
                            }
                        }

                        if ((FileType & 0x01) == 0x01)
                        {
                            diskFileInfo.AutoRun = OricProgram.AutoRunFlag.Enabled;
                        }
                        else
                        {
                            diskFileInfo.AutoRun = OricProgram.AutoRunFlag.Disabled;
                        }

                        diskCatalog.Add(diskFileInfo);
                    }

                    DirectoryIndex++;
                } while (DirectoryIndex < 15);
            }

            diskDirectory = new OricFileInfo[diskCatalog.Count];
            diskCatalog.CopyTo(diskDirectory);

            return(diskDirectory);
        }
Exemple #52
0
        private void BuildSedOricSectorMap2(UInt16[] sectorMap, String diskPathname)
        {
            int iFileNum = 1;

            UInt16 bNextTrack  = 0;
            UInt16 bNextSector = 0;
            UInt16 bNextDescTrack;
            UInt16 bNextDescSector;

            Byte[] bByteArray = new Byte[10];

            String strSectorKey = "";

            OricFileInfo[] programList = ReadDirectory(diskPathname);

            foreach (OricFileInfo programInfo in programList)
            {
                UInt16 bTrack;
                UInt16 bSector;

                bTrack  = programInfo.FirstTrack;
                bSector = programInfo.FirstSector;

                do
                {
                    Byte[] bitmapSector = base.ReadSector(bTrack, bSector, ref bNextTrack, ref bNextSector);

                    // Add file descriptor to the sector map
                    UpdateSectorMap(sectorMap, bTrack, bSector, (UInt16)(0x1100 + Convert.ToByte(iFileNum)));

                    bTrack  = bNextTrack;
                    bSector = bNextSector;

                    // Safety net
                    if (bTrack > tracksPerSide || bNextSector > sectorsPerTrack)
                    {
                        // Might have a problem
                        bSector = 0;
                    }
                } while (bSector != 0);

                strSectorKey = CreateKey(programInfo.FirstTrack, programInfo.FirstSector);

                bNextTrack  = programInfo.FirstTrack;
                bNextSector = programInfo.FirstSector;

                do
                {
                    // Read the file descriptor
                    Byte[] sectorData = base.ReadSector(bNextTrack, bNextSector);

                    System.IO.MemoryStream stm = new System.IO.MemoryStream(sectorData, 0, sectorData.Length);
                    System.IO.BinaryReader rdr = new System.IO.BinaryReader(stm);

                    bNextTrack  = rdr.ReadByte();
                    bNextSector = rdr.ReadByte();

                    bNextDescTrack  = bNextTrack;
                    bNextDescSector = bNextSector;

                    Byte bFirstDesc = rdr.ReadByte();

                    int iDescIndex = 0;

                    Byte bDataTrack;
                    Byte bDataSector;

                    int iTotalDescriptors;

                    if (bFirstDesc == 0xFF)
                    {
                        bByteArray = rdr.ReadBytes(9);

                        bDataTrack  = rdr.ReadByte();
                        bDataSector = rdr.ReadByte();

                        iTotalDescriptors = 121;
                    }
                    else
                    {
                        bDataTrack  = bFirstDesc;
                        bDataSector = rdr.ReadByte();

                        iTotalDescriptors = 126;
                    }

                    if (bDataSector != 0)
                    {
                        UpdateSectorMap(sectorMap, bDataTrack, bDataSector, (UInt16)(0x1000 + Convert.ToByte(iFileNum)));
                    }

                    while (bDataSector != 0 && iDescIndex < iTotalDescriptors)
                    {
                        if (bDataSector != 0)
                        {
                            bDataTrack  = rdr.ReadByte();
                            bDataSector = rdr.ReadByte();

                            if (bDataSector != 0)
                            {
                                UpdateSectorMap(sectorMap, bDataTrack, bDataSector, (UInt16)(0x1000 + Convert.ToByte(iFileNum)));
                            }

                            iDescIndex++;
                        }
                    }

                    strSectorKey = CreateKey(bNextDescTrack, bNextDescSector);
                } while (bNextDescSector != 0);

                iFileNum++;
            }
        }
Exemple #53
0
        private Boolean FindFile(String filename, ref Byte track, ref Byte sector, ref Byte index)
        {
            System.Text.Encoding enc = System.Text.Encoding.ASCII;

            Boolean fileMatchFound = false;

            Byte dirTrack  = 20;
            Byte dirSector = 4;

            Byte nextDirTrack  = 20;
            Byte nextDirSector = 4;

            while ((nextDirTrack != 0 && nextDirSector != 0) && fileMatchFound == false)
            {
                // Read current Directory Sector
                Byte[] directory = base.ReadSector(dirTrack, dirSector);

                nextDirTrack  = directory[0x00];
                nextDirSector = directory[0x01];

                index = 0;

                // Scan thru each file in the current directory
                System.IO.MemoryStream memStream    = new System.IO.MemoryStream(directory, 0, directory.Length);
                System.IO.BinaryReader binaryReader = new System.IO.BinaryReader(memStream);

                // Move to first entry
                memStream.Seek(0x10, SeekOrigin.Begin);

                while (!fileMatchFound && index < 15)
                {
                    if (binaryReader.PeekChar() != 0x00)
                    {
                        Byte[] fileName  = binaryReader.ReadBytes(9);
                        Byte[] extension = binaryReader.ReadBytes(3);

                        String dirFilename  = enc.GetString(fileName).Trim();
                        String dirExtension = enc.GetString(extension).Trim();

                        String pathname = String.Format("{0}.{1}", dirFilename, dirExtension);

                        if (pathname == filename)
                        {
                            fileMatchFound = true;
                        }
                        else
                        {
                            index++;
                        }
                    }

                    binaryReader.ReadBytes(4);
                }

                if (!fileMatchFound)
                {
                    dirTrack  = nextDirTrack;
                    dirSector = nextDirSector;
                }
                else
                {
                    track  = dirTrack;
                    sector = dirSector;

                    index++;
                }
            }

            return(fileMatchFound);
        }
Exemple #54
0
        public static Grf grf_callback_open(string fname, string mode, GrfOpenCallback callback)
        {
            byte[] buf = new byte[GRF_HEADER_FULL_LEN];
            uint   i;//, zero_fcount = GrfSupport.ToLittleEndian32(7), create_ver = GrfSupport.ToLittleEndian32(0x0200);
            Grf    grf;

            if (fname == null || mode == null)
            {
                throw new Exception("GE_BADARGS");
            }

            /* Allocate memory for grf */
            grf = new Grf();

            /* Copy the filename */
            grf.filename = fname;

            /* Open the file */
            var fStream = FileManager.Load(grf.filename) as Stream;

            if (fStream == null)
            {
                throw new Exception("GE_ERRNO");
            }

            using (var br = new System.IO.BinaryReader(fStream))
            {
                grf.allowWrite = !mode.Contains("+") && mode.Contains("w");

                //***skipped write***/

                /* Read the header */
                buf = br.ReadBytes(GRF_HEADER_FULL_LEN);

                /* Check the header */
                string strA = Encoding.ASCII.GetString(buf);
                int    v    = string.Compare(strA, 0, GRF_HEADER, 0, GRF_HEADER_LEN);
                if (v != 0)
                {
                    throw new Exception("GE_INVALID");
                }

                /* Continued header check...
                 *
                 * GRF files that allow encryption of the files inside the archive
                 * have a hex header following "Master of Magic" (not including
                 * the nul-terminator) that looks like:
                 * 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E
                 *
                 * GRF files that do not allow it have a hex header that looks like:
                 * 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
                 *
                 * GRF files that do not allow it are generally found after a
                 * "Ragnarok.exe /repak" command has been issued
                 */
                if (buf[GRF_HEADER_LEN + 1] == 1)
                {
                    grf.allowCrypt = 1;
                    /* 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E */
                    for (i = 0; i < 0xF; i++)
                    {
                        if (buf[GRF_HEADER_LEN + i] != (int)i)
                        {
                            throw new Exception("GE_CORRUPTED");
                        }
                    }
                }
                else if (buf[GRF_HEADER_LEN] == 0)
                {
                    grf.allowCrypt = 0;
                    /* 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 */
                    for (i = 0; i < 0xF; i++)
                    {
                        if (buf[GRF_HEADER_LEN + i] != 0)
                        {
                            new Exception("GE_CORRUPTED");
                        }
                    }
                }
                else
                {
                    throw new Exception("GE_CORRUPTED");
                }

                /* Okay, so we finally are sure that its a valid GRF/GPF file.
                 * now its time to read info from it
                 */

                /* Set the type of archive this is */
                grf.type = GRF_TYPE_GRF;

                /* Read the version */
                grf.version = GrfSupport.LittleEndian32(buf, GRF_HEADER_MID_LEN + 0xC);

                /* Read the number of files */
                grf.nfiles  = GrfSupport.LittleEndian32(buf, GRF_HEADER_MID_LEN + 8);
                grf.nfiles -= GrfSupport.LittleEndian32(buf, GRF_HEADER_MID_LEN + 4) + 7;

                /* Create the array of files */
                grf.files = new Hashtable(StringComparer.OrdinalIgnoreCase);

                /* Grab the filesize */
                grf.len = (uint)fStream.Length;

                /* Seek to the offset of the file tables */
                br.BaseStream.Seek(GrfSupport.LittleEndian32(buf, GRF_HEADER_MID_LEN) + GRF_HEADER_FULL_LEN, SeekOrigin.Begin);

                /* Run a different function to read the file information based on
                 * the major version number
                 */
                switch (grf.version & 0xFF00)
                {
                case 0x0200:
                    i = GRF_readVer2_info(br, grf, callback);
                    break;

                default:
                    throw new Exception("UNSUP_GRF_VERSION");
                }

                if (i > 0)
                {
                    return(null);
                }
            }

            return(grf);
        }
        private void OnAcceptCommand()
        {
            if (_sVerificationCode == "")
            {
                return;
            }

            Log.DebugFormat("Sending verification code {0}", _sVerificationCode);

            // Create a collection object and populate it using the PFX file

            bool   bResult        = true;
            string sStationNumber = null;

#if STAGINGUITEST
            sStationNumber = _sVerificationCode.Substring(0, 4);
#else
            if (System.Diagnostics.Debugger.IsAttached && string.IsNullOrEmpty(ConfigurationManager.AppSettings["CertificateUrl"]))
            {
                sStationNumber = _sVerificationCode.Substring(0, 4);
            }
            else if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings["CertificateUrl"]))
            {
                string url = ConfigurationManager.AppSettings["CertificateUrl"];

                HttpWebRequest httpWReq = (HttpWebRequest)WebRequest.Create(url);
                ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };

                ASCIIEncoding encoding = new ASCIIEncoding();
                string        postData = "c=" + _sVerificationCode;
                byte[]        data     = encoding.GetBytes(postData);

                httpWReq.Method        = "POST";
                httpWReq.ContentType   = "application/x-www-form-urlencoded";
                httpWReq.ContentLength = data.Length;

                using (Stream stream = httpWReq.GetRequestStream())
                {
                    stream.Write(data, 0, data.Length);
                }

                HttpWebResponse  response   = (HttpWebResponse)httpWReq.GetResponse();
                System.IO.Stream dataStream = response.GetResponseStream();

                System.IO.BinaryReader streamReader = new System.IO.BinaryReader(dataStream);

                IList <byte[]> array = new List <byte[]>();
                do
                {
                    byte[] tmpfile = streamReader.ReadBytes(1024);
                    array.Add(tmpfile);
                } while (array.Last().Length == 1024);

                byte[] file = new byte[array.Sum(x => x.Length)];

                int i = 0;
                foreach (var bytese in array)
                {
                    foreach (var b in bytese)
                    {
                        file[i++] = b;
                    }
                }


                dataStream.Close();
                streamReader.Close();
                string certFilename = DateTime.Now.ToFileTime() + "cert.p12";

                FileStream   fs = new FileStream(certFilename, FileMode.CreateNew);
                BinaryWriter bw = new BinaryWriter(fs);

                for (int j = 0; j < file.Length; j++)
                {
                    bw.Write(file[j]);
                }

                streamReader.Close();
                response.Close();
                fs.Flush();
                fs.Close();

                try
                {
                    X509Certificate2 cert = new X509Certificate2(file, _sVerificationCode);
                    var serviceRuntimeUserCertificateStore = new X509Store(StoreName.My);
                    serviceRuntimeUserCertificateStore.Open(OpenFlags.ReadWrite);
                    foreach (var certificate in serviceRuntimeUserCertificateStore.Certificates)
                    {
                        if (certificate.Subject.Contains("Sportradar AG"))
                        {
                            serviceRuntimeUserCertificateStore.Remove(certificate);
                            break;
                        }
                    }

                    var process   = new Process();
                    var startInfo = new ProcessStartInfo();
                    startInfo.WindowStyle = ProcessWindowStyle.Hidden;
                    startInfo.FileName    = "certutil.exe";
                    startInfo.Arguments   = " -f -user -p " + _sVerificationCode + " -importpfx " + certFilename;
                    process.StartInfo     = startInfo;
                    process.Start();

                    serviceRuntimeUserCertificateStore.Close();
                    sStationNumber = cert.Subject.Substring(cert.Subject.IndexOf("CN=") + 3, cert.Subject.IndexOf(", ", cert.Subject.IndexOf("CN=")) - cert.Subject.IndexOf("CN=") - 3);
                    sStationNumber = sStationNumber.Replace("terminal", "");
                }
                catch (Exception e)
                {
                    Log.Error(e.Message, e);
                    ShowError(TranslationProvider.Translate(MultistringTags.CERTIFICATE_ERROR).ToString());
                    return;
                }
            }
            else
            {
                try
                {
                    sStationNumber = WsdlRepository.GetStationByVerificationNumber(_sVerificationCode);
                }
                catch (Exception ex)
                {
                    Log.Error("", ex);
                    ShowError(ex.Message);
                    return;
                }
            }
#endif
            try
            {
                if (bResult)
                {
                    Log.InfoFormat("Saving station number {0} to database", sStationNumber);
                    StationRepository.SetStationAppConfigValue("StationNumber", sStationNumber);
                }
            }
            catch (Exception Ex)
            {
                Log.Error("", Ex);
                ShowError("Can't connect to database " + Ex.Message);
                return;
            }

            _sVerificationCode = "";
            Log.Debug("Closing verification window");

            /* ChangeTracker.VerifivationCancelled = false;
             * ChangeTracker.VerificationRestart = true;*/
            Log.Debug("Exiting verification window");
            Mediator.SendMessage <long>(0, MsgTag.RestartApplication);
        }
Exemple #56
0
        protected override sealed bool SendRequest_Internal(AstoriaRequest request, out AstoriaResponse response)
        {
            HttpWebRequest underlyingRequest = (HttpWebRequest)HttpWebRequest.Create(request.URI);
            WebResponse    underlyingResponse;

            #region set up request

            // workaround: Protocol Violation in HttpWebRequest when receiving an immediate error response from server before sending request body
            // ideally, we would only flip this to false if we knew the request would have an error,
            // but we can't reliably tell at this point
            if (AstoriaTestProperties.Host == Host.IDSH || AstoriaTestProperties.Host == Host.IDSH2)
            {
                if (Environment.OSVersion.Version.Major < 6 || Environment.OSVersion.Version.Minor < 1)
                {
                    underlyingRequest.ServicePoint.Expect100Continue = false;
                }
            }

            underlyingRequest.UseDefaultCredentials =
                AstoriaTestProperties.HostAuthenicationMethod.Equals("Windows", StringComparison.InvariantCultureIgnoreCase);
            underlyingRequest.Method = request.Verb.ToHttpMethod();

            underlyingRequest.Accept      = request.Accept;
            underlyingRequest.ContentType = request.ContentType;

            foreach (KeyValuePair <string, string> header in request.Headers)
            {
                switch (header.Key)
                {
                case "Accept":
                case "Content-Type":
                    break;

                default:
                    underlyingRequest.Headers.Add(header.Key, header.Value);
                    break;
                }
            }

            underlyingRequest.ContentLength = 0;

            byte[] bytes = request.PayloadBytes;

            if (bytes != null)
            {
                underlyingRequest.ContentLength = bytes.Length;
                try
                {
                    using (Stream os = underlyingRequest.GetRequestStream())
                    {
                        os.Write(bytes, 0, bytes.Length);
                    }
                }
                catch (WebException ex)
                {
                    HandleWebException(ex, out underlyingResponse);
                    response = null;
                    return(false);
                }
            }
            else if (request.HttpStreamWriter != null)
            {
                // Call external stream writer.
                try
                {
                    // Set ContentLength header.
                    underlyingRequest.ContentLength = request.HttpStreamWriter(null);

                    // Stream payload.
                    using (Stream requestStream = underlyingRequest.GetRequestStream())
                    {
                        request.HttpStreamWriter(requestStream);
                    }
                }
                catch (WebException ex)
                {
                    HandleWebException(ex, out underlyingResponse);
                    response = null;
                    return(false);
                }
            }

            #endregion

            try
            {
                underlyingResponse = underlyingRequest.GetResponse();
            }
            catch (WebException webException)
            {
                if (HandleWebException(webException, out underlyingResponse))
                {
                    if (underlyingResponse == null)
                    {
                        response = null;
                        return(false);
                    }
                }
                else
                {
                    throw webException;
                }
            }

            // This should not be possible
            if (underlyingResponse == null)
            {
                AstoriaTestLog.FailAndThrow("Somehow got a null underlying response");
            }

            HttpWebResponse httpResponse = underlyingResponse as HttpWebResponse;

            response = new AstoriaResponse(request);

            #region populate response
            response.ContentType = underlyingResponse.ContentType;

            // hook everything up
            if (httpResponse != null)
            {
                response.ActualStatusCode = httpResponse.StatusCode;
            }
            else
            {
                response.ActualStatusCode = HttpStatusCode.Ambiguous;
            }

            // have to be careful and only mark ETag as found if it was actually sent
            // regardless of whether the value was null
            response.ETagHeaderFound = false;
            foreach (string header in underlyingResponse.Headers.AllKeys)
            {
                if (header == "ETag")
                {
                    response.ETagHeaderFound = true;
                }

                if (underlyingResponse is HttpWebResponse)
                {
                    response.Headers[header] = (underlyingResponse as HttpWebResponse).GetResponseHeader(header);
                }
                else
                {
                    response.Headers[header] = string.Join(", ", underlyingResponse.Headers.GetValues(header));
                }
            }

            // For Streamed/StreamedResponse, Transfer-Encoding is chunked and ContentLength could be -1
            if ((underlyingResponse.Headers[HttpResponseHeader.TransferEncoding] == "chunked" || underlyingResponse.ContentLength > 0))
            {
                Encoding encoding = Encoding.UTF8;

                using (Stream responseStream = underlyingResponse.GetResponseStream())
                {
                    if (request.HttpStreamReader != null)
                    {
                        // Call external stream reader.
                        response.Payload = request.HttpStreamReader(responseStream);
                    }
                    else
                    {
                        if (underlyingResponse.ContentLength > 0 && response.ContentType == SerializationFormatKinds.MimeApplicationOctetStream)
                        {
                            using (System.IO.BinaryReader reader = new System.IO.BinaryReader(responseStream))
                                response.Bytes = reader.ReadBytes((int)underlyingResponse.ContentLength);
                        }
                        else
                        {
                            using (System.IO.TextReader reader = new System.IO.StreamReader(responseStream, encoding))
                                response.Payload = reader.ReadToEnd();
                        }
                    }
                }
            }
            else
            {
                // only make an assignment to response.Payload if we're sure there was no content
                // if we set this prematurely, it can mess up the internal state of the response
                response.Payload = string.Empty;
            }
            #endregion

            return(true);
        }
 public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
 {
     System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
     this.fieldskip = binaryReader.ReadBytes(6);
     return(pointerQueue);
 }
Exemple #58
0
        /// <summary> Receive the response from the server
        /// Message format :
        /// 8 bytes = lenght of the following message
        /// block   = error no + "\001" + datas
        /// </summary>
        //UPGRADE_NOTE: Synchronized keyword was removed from method 'receive'. Lock expression was added. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1027"'
        private D3Buffer receive()
        {
            lock (this)
            {
                int           length;
                byte[]        buf;
                System.String stat;
                int           status = D3Constants.D3_ERR;
                System.Collections.ArrayList inBuffer = new System.Collections.ArrayList();

                try
                {
                    buf = new byte[8];
                    // Reading the lenght
                    //UPGRADE_TODO: Equivalent of method 'java.io.DataInputStream.readFully' may not have an optimal performance in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1117"'
                    //SupportClass.ReadInput(d3sIn.BaseStream, ref buf, 0, 8);

                    buf = d3sIn.ReadBytes(8);

                    char[] tmpChar;
                    tmpChar = new char[buf.Length];
                    buf.CopyTo(tmpChar, 0);
                    System.String slen = new System.String(tmpChar, 0, 8);
                    length = System.Int32.Parse(slen);

                    buf = new byte[length];
                    // reading datas with this lenght
                    //UPGRADE_TODO: Equivalent of method 'java.io.DataInputStream.readFully' may not have an optimal performance in C#. 'ms-help://MS.VSCC/commoner/redir/redirect.htm?keyword="jlca1117"'
                    //SupportClass.ReadInput(d3sIn.BaseStream, ref buf, 0, length);
                    buf = d3sIn.ReadBytes(length);
                }
                catch (System.Exception e)
                {
                    throw new D3Exception("Could not receive response from " + this.server + " {" + e.Message + "}");
                }

                // Converting into vector with "\001" as separator
                char[] tmpChar2;
                tmpChar2 = new char[buf.Length];
                buf.CopyTo(tmpChar2, 0);
                //SupportClass.Tokenizer st = new SupportClass.Tokenizer(new System.String(tmpChar2), "\x0001");

                char     seps = '\x0001';
                String[] st   = (new System.String(tmpChar2)).Split(seps);
                // Error no is always the first
                //stat = st.NextToken();
                int cnt = 0;
                stat = "";
                foreach (String line in st)
                {
                    if (cnt == 0)
                    {
                        stat = line;
                    }
                    else
                    {
                        if (line == String.Empty)
                        {
                            inBuffer.Add("");
                        }
                        else
                        {
                            inBuffer.Add(line);
                        }
                    }
                    cnt++;

                    if (line == String.Empty)
                    {
                        continue;
                    }
                }

                /*
                 * if (st.HasMoreTokens())
                 * {
                 *      do
                 *      {
                 *              inBuffer.Add(st.NextToken());
                 *      }
                 *      while (st.HasMoreTokens());
                 * }
                 * else
                 * {
                 *      // if there is no data, we must add an empty string
                 *      inBuffer.Add("");
                 * }
                 *
                 */
                // get error code returned as first ASCII string
                try
                {
                    status = System.Int32.Parse(stat);
                }
                catch
                {
                    status = -1;
                }

                return(new D3Buffer(status, inBuffer));
            }
        }
Exemple #59
0
        /// <summary>
        /// (INCOMPLETE) Retrieve file information for a RAR file
        /// </summary>
        /// TODO: Write the rest of this RAR file handling
        public void GetRarFileInfo()
        {
            if (!File.Exists(this.Filename))
            {
                return;
            }

            BinaryReader br = new BinaryReader(Utilities.TryOpenRead(this.Filename));

            // Check for the signature first (Skipping the SFX Module)
            byte[] signature = br.ReadBytes(8);
            int    startpos  = 0;

            while (startpos < Constants.MibiByte && !signature.StartsWith(Constants.RarSignature, exact: true) && !signature.StartsWith(Constants.RarFiveSignature, exact: true))
            {
                startpos++;
                br.BaseStream.Position = startpos;
                signature = br.ReadBytes(8);
            }
            if (!signature.StartsWith(Constants.RarSignature, exact: true) && !signature.StartsWith(Constants.RarFiveSignature, exact: true))
            {
                return;
            }

            CoreRarArchive cra = new CoreRarArchive();

            if (startpos > 0)
            {
                br.BaseStream.Position = 0;
                cra.SFX = br.ReadBytes(startpos);
            }

            // Get all archive header information
            cra.HeaderCRC32 = br.ReadUInt32();
            cra.HeaderSize  = br.ReadUInt32();
            uint headerType = br.ReadUInt32();

            // Special encryption information
            bool hasEncryptionHeader = false;

            // If it's encrypted
            if (headerType == (uint)RarHeaderType.ArchiveEncryption)
            {
                hasEncryptionHeader       = true;
                cra.EncryptionHeaderCRC32 = cra.HeaderCRC32;
                cra.EncryptionHeaderSize  = cra.HeaderSize;
                cra.EncryptionHeaderFlags = (RarHeaderFlags)br.ReadUInt32();
                cra.EncryptionVersion     = br.ReadUInt32();
                cra.EncryptionFlags       = br.ReadUInt32();
                cra.KDFCount   = br.ReadByte();
                cra.Salt       = br.ReadBytes(16);
                cra.CheckValue = br.ReadBytes(12);

                cra.HeaderCRC32 = br.ReadUInt32();
                cra.HeaderSize  = br.ReadUInt32();
                headerType      = br.ReadUInt32();
            }

            cra.HeaderFlags = (RarHeaderFlags)br.ReadUInt32();
            if ((cra.HeaderFlags & RarHeaderFlags.ExtraAreaPresent) != 0)
            {
                cra.ExtraAreaSize = br.ReadUInt32();
            }
            cra.ArchiveFlags = (RarArchiveFlags)br.ReadUInt32();
            if ((cra.ArchiveFlags & RarArchiveFlags.VolumeNumberField) != 0)
            {
                cra.VolumeNumber = br.ReadUInt32();
            }
            if (((cra.HeaderFlags & RarHeaderFlags.ExtraAreaPresent) != 0) && cra.ExtraAreaSize != 0)
            {
                cra.ExtraArea = br.ReadBytes((int)cra.ExtraAreaSize);
            }

            // Archive Comment Service Header

            // Now for file headers
            for (; ;)
            {
                CoreRarArchiveEntry crae = new CoreRarArchiveEntry();
                crae.HeaderCRC32 = br.ReadUInt32();
                crae.HeaderSize  = br.ReadUInt32();
                crae.HeaderType  = (RarHeaderType)br.ReadUInt32();

                if (crae.HeaderType == RarHeaderType.EndOfArchive)
                {
                    break;
                }

                crae.HeaderFlags = (RarHeaderFlags)br.ReadUInt32();
                if ((crae.HeaderFlags & RarHeaderFlags.ExtraAreaPresent) != 0)
                {
                    crae.ExtraAreaSize = br.ReadUInt32();
                }
                if ((crae.HeaderFlags & RarHeaderFlags.DataAreaPresent) != 0)
                {
                    crae.DataAreaSize = br.ReadUInt32();
                }
                crae.FileFlags    = (RarFileFlags)br.ReadUInt32();
                crae.UnpackedSize = br.ReadUInt32();
                if ((crae.FileFlags & RarFileFlags.UnpackedSizeUnknown) != 0)
                {
                    crae.UnpackedSize = 0;
                }
                crae.Attributes             = br.ReadUInt32();
                crae.mtime                  = br.ReadUInt32();
                crae.DataCRC32              = br.ReadUInt32();
                crae.CompressionInformation = br.ReadUInt32();
                crae.HostOS                 = br.ReadUInt32();
                crae.NameLength             = br.ReadUInt32();
                crae.Name = br.ReadBytes((int)crae.NameLength);
                if ((crae.HeaderFlags & RarHeaderFlags.ExtraAreaPresent) != 0)
                {
                    uint extraSize = br.ReadUInt32();
                    switch (br.ReadUInt32())               // Extra Area Type
                    {
                    case 0x01:                             // File encryption information
                        crae.EncryptionSize  = extraSize;
                        crae.EncryptionFlags = (RarEncryptionFlags)br.ReadUInt32();
                        crae.KDFCount        = br.ReadByte();
                        crae.Salt            = br.ReadBytes(16);
                        crae.IV         = br.ReadBytes(16);
                        crae.CheckValue = br.ReadBytes(12);
                        break;

                    case 0x02:                             // File data hash
                        crae.HashSize = extraSize;
                        crae.HashType = br.ReadUInt32();
                        crae.HashData = br.ReadBytes(32);
                        break;

                    case 0x03:                             // High precision file time
                        crae.TimeSize  = extraSize;
                        crae.TimeFlags = (RarTimeFlags)br.ReadUInt32();
                        if ((crae.TimeFlags & RarTimeFlags.TimeInUnixFormat) != 0)
                        {
                            if ((crae.TimeFlags & RarTimeFlags.ModificationTimePresent) != 0)
                            {
                                crae.TimeMtime64 = br.ReadUInt64();
                            }
                            if ((crae.TimeFlags & RarTimeFlags.CreationTimePresent) != 0)
                            {
                                crae.TimeCtime64 = br.ReadUInt64();
                            }
                            if ((crae.TimeFlags & RarTimeFlags.LastAccessTimePresent) != 0)
                            {
                                crae.TimeLtime64 = br.ReadUInt64();
                            }
                        }
                        else
                        {
                            if ((crae.TimeFlags & RarTimeFlags.ModificationTimePresent) != 0)
                            {
                                crae.TimeMtime = br.ReadUInt32();
                            }
                            if ((crae.TimeFlags & RarTimeFlags.CreationTimePresent) != 0)
                            {
                                crae.TimeCtime = br.ReadUInt32();
                            }
                            if ((crae.TimeFlags & RarTimeFlags.LastAccessTimePresent) != 0)
                            {
                                crae.TimeLtime = br.ReadUInt32();
                            }
                        }
                        break;

                    case 0x04:                             // File version number
                        crae.VersionSize = extraSize;
                        /* crae.VersionFlags = */
                        br.ReadUInt32();
                        crae.VersionNumber = br.ReadUInt32();
                        break;

                    case 0x05:                             // File system redirection
                        crae.RedirectionSize       = extraSize;
                        crae.RedirectionType       = (RarRedirectionType)br.ReadUInt32();
                        crae.RedirectionFlags      = br.ReadUInt32();
                        crae.RedirectionNameLength = br.ReadUInt32();
                        crae.RedirectionName       = br.ReadBytes((int)crae.RedirectionNameLength);
                        break;

                    case 0x06:                             // Unix owner and group information
                        crae.UnixOwnerSize  = extraSize;
                        crae.UnixOwnerFlags = (RarUnixOwnerRecordFlags)br.ReadUInt32();
                        if ((crae.UnixOwnerFlags & RarUnixOwnerRecordFlags.UserNameStringIsPresent) != 0)
                        {
                            crae.UnixOwnerUserNameLength = br.ReadUInt32();
                            crae.UnixOwnerUserName       = br.ReadBytes((int)crae.UnixOwnerUserNameLength);
                        }
                        if ((crae.UnixOwnerFlags & RarUnixOwnerRecordFlags.GroupNameStringIsPresent) != 0)
                        {
                            crae.UnixOwnerGroupNameLength = br.ReadUInt32();
                            crae.UnixOwnerGroupName       = br.ReadBytes((int)crae.UnixOwnerGroupNameLength);
                        }
                        if ((crae.UnixOwnerFlags & RarUnixOwnerRecordFlags.NumericUserIdIsPresent) != 0)
                        {
                            crae.UnixOwnerUserId = br.ReadUInt32();
                        }
                        if ((crae.UnixOwnerFlags & RarUnixOwnerRecordFlags.NumericGroupIdIsPresent) != 0)
                        {
                            crae.UnixOwnerGroupId = br.ReadUInt32();
                        }
                        break;

                    case 0x07:                             // Service header data array

                        break;
                    }
                }
                if ((crae.HeaderFlags & RarHeaderFlags.DataAreaPresent) != 0)
                {
                    crae.DataArea = br.ReadBytes((int)crae.DataAreaSize);
                }
            }
        }
Exemple #60
0
 public override System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> ReadFields(System.IO.BinaryReader binaryReader)
 {
     System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer> pointerQueue = new System.Collections.Generic.Queue <Moonfish.Tags.BlamPointer>(base.ReadFields(binaryReader));
     this.fieldpad                     = binaryReader.ReadBytes(8);
     this.EnglishStringCount           = binaryReader.ReadInt32();
     this.EnglishStringTableLength     = binaryReader.ReadInt32();
     this.EnglishStringIndexAddress    = binaryReader.ReadInt32();
     this.EnglishStringTableAddress    = binaryReader.ReadInt32();
     this.fieldpad0                    = binaryReader.ReadBytes(4);
     this.fieldpad1                    = binaryReader.ReadBytes(8);
     this.JapaneseStringCount          = binaryReader.ReadInt32();
     this.JapaneseStringTableLength    = binaryReader.ReadInt32();
     this.JapaneseStringIndexAddress   = binaryReader.ReadInt32();
     this.JapaneseStringTableAddress   = binaryReader.ReadInt32();
     this.fieldpad2                    = binaryReader.ReadBytes(4);
     this.fieldpad3                    = binaryReader.ReadBytes(8);
     this.DutchStringCount             = binaryReader.ReadInt32();
     this.DutchStringTableLength       = binaryReader.ReadInt32();
     this.DutchStringIndexAddress      = binaryReader.ReadInt32();
     this.DutchStringTableAddress      = binaryReader.ReadInt32();
     this.fieldpad4                    = binaryReader.ReadBytes(4);
     this.fieldpad5                    = binaryReader.ReadBytes(8);
     this.FrenchStringCount            = binaryReader.ReadInt32();
     this.FrenchStringTableLength      = binaryReader.ReadInt32();
     this.FrenchStringIndexAddress     = binaryReader.ReadInt32();
     this.FrenchStringTableAddress     = binaryReader.ReadInt32();
     this.fieldpad6                    = binaryReader.ReadBytes(4);
     this.fieldpad7                    = binaryReader.ReadBytes(8);
     this.SpanishStringCount           = binaryReader.ReadInt32();
     this.SpanishStringTableLength     = binaryReader.ReadInt32();
     this.SpanishStringIndexAddress    = binaryReader.ReadInt32();
     this.SpanishStringTableAddress    = binaryReader.ReadInt32();
     this.fieldpad8                    = binaryReader.ReadBytes(4);
     this.fieldpad9                    = binaryReader.ReadBytes(8);
     this.ItalianStringCount           = binaryReader.ReadInt32();
     this.ItalianStringTableLength     = binaryReader.ReadInt32();
     this.ItalianStringIndexAddress    = binaryReader.ReadInt32();
     this.ItalianStringTableAddress    = binaryReader.ReadInt32();
     this.fieldpad10                   = binaryReader.ReadBytes(4);
     this.fieldpad11                   = binaryReader.ReadBytes(8);
     this.KoreanStringCount            = binaryReader.ReadInt32();
     this.KoreanStringTableLength      = binaryReader.ReadInt32();
     this.KoreanStringIndexAddress     = binaryReader.ReadInt32();
     this.KoreanStringTableAddress     = binaryReader.ReadInt32();
     this.fieldpad12                   = binaryReader.ReadBytes(4);
     this.fieldpad13                   = binaryReader.ReadBytes(8);
     this.ChineseStringCount           = binaryReader.ReadInt32();
     this.ChineseStringTableLength     = binaryReader.ReadInt32();
     this.ChineseStringIndexAddress    = binaryReader.ReadInt32();
     this.ChineseStringTableAddress    = binaryReader.ReadInt32();
     this.fieldpad14                   = binaryReader.ReadBytes(4);
     this.fieldpad15                   = binaryReader.ReadBytes(8);
     this.PortugueseStringCount        = binaryReader.ReadInt32();
     this.PortugueseStringTableLength  = binaryReader.ReadInt32();
     this.PortugueseStringIndexAddress = binaryReader.ReadInt32();
     this.PortugueseStringTableAddress = binaryReader.ReadInt32();
     this.fieldpad16                   = binaryReader.ReadBytes(4);
     return(pointerQueue);
 }