public override object Deserialize(Stream stream)
        {
            if (encryptionEnabled)
            {
                string descriptorName = stream.ReadUTF();
                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                string privateKey = serverAuthority.GenerateAgreementValue(remotePublicKey).ToString(16);
                RijndaelCrypto crypto = new RijndaelCrypto();

                Type t = registry.GetTypeForDescriptor(crypto.Decrypt(descriptorName, privateKey));
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", crypto.Decrypt(buffer, privateKey));
                }

            }
            else
            {
                string descriptorName = stream.ReadUTF();

                int length = stream.ReadInt();
                byte[] buffer = stream.Read(length);

                Type t = registry.GetTypeForDescriptor(descriptorName);
                if (t != null)
                {
                    return ReflectionHelper.InvokeStaticMethodOnType(t, "ParseFrom", buffer);
                }
            }

            return null;
        }
Example #2
0
        /// <summary>
        /// Reconstructs remote data, given a delta stream and a random access / seekable input stream,
        /// all written to outputStream.
        /// </summary>
        /// <param name="deltaStream">sequential stream of deltas</param>
        /// <param name="inputStream">seekable and efficiently random access stream</param>
        /// <param name="outputStream">sequential stream for output</param>
        public void Receive(Stream deltaStream, Stream inputStream, Stream outputStream)
        {
            if (deltaStream == null) throw new ArgumentNullException("deltaStream");
            if (inputStream == null) throw new ArgumentNullException("inputStream");
            if (outputStream == null) throw new ArgumentNullException("outputStream");
            if (inputStream.CanSeek == false) throw new InvalidOperationException("inputStream must be seekable");

            int commandByte;
            while ((commandByte = deltaStream.ReadByte()) != -1)
            {
                if (commandByte == DeltaStreamConstants.NEW_BLOCK_START_MARKER)
                {
                    int length = deltaStream.ReadInt();
                    var buffer = new byte[length];
                    deltaStream.Read(buffer, 0, length);
                    outputStream.Write(buffer, 0, length);
                }
                else if (commandByte == DeltaStreamConstants.COPY_BLOCK_START_MARKER)
                {
                    long sourceOffset = deltaStream.ReadLong();
                    int length = deltaStream.ReadInt();
                    var buffer = new byte[length];
                    inputStream.Seek(sourceOffset, SeekOrigin.Begin);
                    inputStream.Read(buffer, 0, length);
                    outputStream.Write(buffer, 0, length);
                }
                else throw new IOException("Invalid data found in deltaStream");
            }
        }
Example #3
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     Type = aStream.ReadObjType ();
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
 }
Example #4
0
        /* Unpack a GMP into a Bitmap */
        public override Bitmap Unpack(ref Stream data)
        {
            try
            {
                /* Get and set image variables */
                int width      = data.ReadInt(0xC); // Width
                int height     = data.ReadInt(0x8); // Height
                short bitDepth = data.ReadShort(0x1E); // Bit Depth
                short colors   = data.ReadShort(0x1C); // Pallete Entries

                /* Throw an exception if this is not an 8-bit gmp (for now) */
                if (bitDepth != 8)
                    throw new Exception();

                /* Set up the image */
                Bitmap image = new Bitmap(width, height, PixelFormat.Format8bppIndexed);
                BitmapData imageData = image.LockBits(
                    new Rectangle(0, 0, width, height),
                    ImageLockMode.WriteOnly, image.PixelFormat);

                /* Read the data from the GMP */
                unsafe
                {
                    /* Write the palette */
                    ColorPalette palette = image.Palette;
                    for (int i = 0; i < colors; i++)
                        palette.Entries[i] = Color.FromArgb(data.ReadByte(0x20 + (i * 0x4) + 0x2), data.ReadByte(0x20 + (i * 0x4) + 0x1), data.ReadByte(0x20 + (i * 0x4)));

                    image.Palette = palette;

                    /* Start getting the pixels from the source image */
                    for (int y = 0; y < height; y++)
                    {
                        for (int x = 0; x < width; x++)
                        {
                            byte* rowData = (byte*)imageData.Scan0 + (y * imageData.Stride);
                            rowData[x] = data.ReadByte(0x20 + (colors * 0x4) + (width * height) - ((y + 1) * width) + x);
                        }
                    }
                }

                /* Unlock the bits now. */
                image.UnlockBits(imageData);

                return image;
            }
            catch
            {
                return null;
            }
        }
Example #5
0
        private FrameReader(Stream stream, bool streaming)
        {
            try
            {
                MessageOpcode = (MessageOpcodes)stream.ReadByte();
                int bodyLen = stream.ReadInt();
                if (streaming)
                {
                    _ms = new WindowedReadStream(stream, bodyLen);
                }
                else
                {
                    byte[] buffer = new byte[bodyLen];
                    if (0 < bodyLen)
                    {
                        stream.Read(buffer, 0, bodyLen);
                        _ms = new MemoryStream(buffer);
                    }
                }

                if (MessageOpcodes.Error == MessageOpcode)
                {
                    ThrowError();
                }
            }
            catch
            {
                Dispose();
                throw;
            }
        }
Example #6
0
 /// <summary>
 /// RSYNC file transfer with exchange of delta representatives (receiving end)
 /// </summary>
 /// <param name="stream">Connection stream</param>
 /// <param name="path">Path of file to transfer, must exist</param>
 public static void Receive(Stream stream, string path)
 {
     // Receive new file size
     int fileSizeNew = stream.ReadInt();
     int prevReadTimeout = stream.ReadTimeout;
     int prevWriteTimeout = stream.WriteTimeout;
     string tempPath = Shared.TempFile();
     var fileSizeOld = (int)new FileInfo(path).Length;
     var buffer = new byte[BufferSize];
     try
     {
         using (var fileStreamOld = new FileStream(path, FileMode.Open, FileAccess.Read))
         {
             Dictionary<int, List<Chunk>> remoteChunks = ReceiveChunkInformation(stream, fileSizeNew);
             stream.ReadTimeout = stream.WriteTimeout = fileSizeNew;
             List<Chunk> chunks = DiscoverChunksInLocalFile(remoteChunks, new C3C4TaylorsRollingChecksum(fileStreamOld, BlockSize), fileStreamOld,
                                                             fileSizeOld, buffer);
             stream.ReadTimeout = prevReadTimeout;
             stream.WriteTimeout = prevWriteTimeout;
             UniteCloseChunks(chunks);
             int chunksToRequest = AddChunksNotFoundInfo(chunks);
             chunksToRequest += AddChunkNotFoundTail(chunks, fileSizeNew);
             using (var fileStreamNew = new FileStream(tempPath, FileMode.CreateNew, FileAccess.Write))
             {
                 SendAndReceiveChunksAndRebuildFile(stream, chunks, fileStreamNew, fileStreamOld, chunksToRequest, buffer);
             }
         }
     }
     catch
     {
         if (File.Exists(tempPath))
             File.Delete(tempPath);
         stream.ReadTimeout = prevReadTimeout;
         stream.WriteTimeout = prevWriteTimeout;
     }
     // Verify file hash is as expected
     byte[] fileReceivedHash;
     using (var fs = File.OpenRead(tempPath))
     {
         fileReceivedHash = Md5.ComputeHash(fs);
     }
     // Receive hash of whole file
     var fileHash = new byte[16];
     stream.ForceRead(fileHash, 0, 16);
     if (!fileReceivedHash.AreEqual(fileHash))
     {
         File.Delete(tempPath);
         throw new Exception("File transfer error: file hash test failure");
     }
     // File transfer okay
     File.Delete(path);
     File.Move(tempPath, path);
 }
Example #7
0
        public override void ReadFrom(Stream stream, bool readName)
        {
            base.ReadFrom(stream, readName);

            Length = stream.ReadInt();

            Items = new byte[Length];

            for (int i = 0; i < Length; ++i)
            {
                Items[i] = (byte)stream.ReadByte();
            }
        }
Example #8
0
 public static HashBlock[] Destream(Stream inputStream)
 {
     uint count = inputStream.ReadUInt();
     var hashBlocks = new HashBlock[count];
     for (int i = 0; i < count; ++i)
     {
         hashBlocks[i] = new HashBlock {Hash = new byte[16]};
         inputStream.Read(hashBlocks[i].Hash, 0, 16);
         hashBlocks[i].Length = inputStream.ReadInt();
         hashBlocks[i].Offset = inputStream.ReadLong();
         hashBlocks[i].Checksum = inputStream.ReadUInt();
     }
     return hashBlocks;
 }
Example #9
0
        public override void ReadFrom(Stream stream, bool readName)
        {
            base.ReadFrom(stream, readName);

            ItemType = (byte)stream.ReadByte();
            Length = stream.ReadInt();
            Items = new Tag[Length];

            for (int i = 0; i < Length; ++i)
            {
                var tag = TagType.CreateTag(ItemType);
                tag.ReadFrom(stream, false);
                Items[i] = tag;
            }
        }
        public override void Deserialize(Stream stream, Type type, ref object value)
        {
            var elementType = GetElementType(type);
            var add = GetAddMethod(type, elementType).DelegateForCall();
            var clear = GetClearMethod(type);
            clear.Invoke(value);

            int count = stream.ReadInt();
            for (int i = 0; i < count; i++)
            {
                object item = null;
                ctx.Serializer.Deserialize_Main(stream, elementType, ref item);
                addArgs[0] = item;
                add.Invoke(value, addArgs);
            }
        }
Example #11
0
        public override object Deserialize(Stream stream)
        {
            string typeName = stream.ReadLine(MessageEncoding);

            int length = stream.ReadInt();
            byte[] messageBuffer = stream.Read(length);
            Type type = ReflectionHelper.FindType(typeName);

            if (type != null)
            {
                MemoryStream messageStream = new MemoryStream(messageBuffer);
                return Serializer.NonGeneric.Deserialize(type, messageStream);
            }
            else
            {
                throw new Exception("Invalid message type");
            }
        }
Example #12
0
        public override void Deserialize(Stream stream, Type type, ref object instance)
        {
            int count = stream.ReadInt();
            if (instance == null || ((Array)instance).Length != count)
            {
                instance = Array.CreateInstance(type.GetElementType(), count);
                ctx.Serializer.ReMark(instance);
            }

            var array = instance as IList;
            var elementType = type.GetElementType();
            for (int i = 0; i < count; i++)
            {
                object element = null;
                ctx.Serializer.Deserialize_Main(stream, elementType, ref element);
                array[i] = element;
            }
        }
        private FrameReader(Stream stream, bool streaming, bool tracing)
        {
            try
            {
                MessageOpcode = (MessageOpcodes)stream.ReadByte();
                int bodyLen = stream.ReadInt();
                if (streaming)
                {
                    _ms = new WindowedReadStream(stream, bodyLen);
                }
                else
                {
                    byte[] buffer = new byte[bodyLen];
                    if (0 < bodyLen)
                    {
                        // read whole frame in memory
                        int read = stream.Read(buffer, 0, bodyLen);
                        while (read != bodyLen)
                        {
                            read += stream.Read(buffer, read, bodyLen - read);
                        }
                        _ms = new MemoryStream(buffer);
                    }
                }

                if (tracing)
                {
                    // skip traceId
                    byte[] traceId = new byte[16];
                    int count = traceId.Length;
                    _ms.Read(traceId, 0, count);
                }

                if (MessageOpcodes.Error == MessageOpcode)
                {
                    ThrowError();
                }
            }
            catch
            {
                Dispose();
                throw;
            }
        }
        private static object ReadInternal(Stream stream, FormatItem format, DbEnvironment env)
        {
            switch (format.DataType)
            {
            case TdsDataType.TDS_BIT:
                return(stream.ReadBool());

            case TdsDataType.TDS_INT1:
                return((byte)stream.ReadByte());

            case TdsDataType.TDS_SINT1:
                return((sbyte)stream.ReadByte());

            case TdsDataType.TDS_INT2:
                return(stream.ReadShort());

            case TdsDataType.TDS_UINT2:
                return(stream.ReadUShort());

            case TdsDataType.TDS_INT4:
                return(stream.ReadInt());

            case TdsDataType.TDS_UINT4:
                return(stream.ReadUInt());

            case TdsDataType.TDS_INT8:
                return(stream.ReadLong());

            case TdsDataType.TDS_UINT8:
                return(stream.ReadULong());

            case TdsDataType.TDS_INTN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 1: return((byte)stream.ReadByte());        //both INTN(1) and UINTN(1) are an INT1. Never an SINT1.

                case 2: return(stream.ReadShort());

                case 4: return(stream.ReadInt());

                case 8: return(stream.ReadLong());
                }
                break;

            case TdsDataType.TDS_UINTN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 1: return((byte)stream.ReadByte());

                case 2: return(stream.ReadUShort());

                case 4: return(stream.ReadUInt());

                case 8: return(stream.ReadULong());
                }
                break;

            case TdsDataType.TDS_FLT4:
                return(stream.ReadFloat());

            case TdsDataType.TDS_FLT8:
                return(stream.ReadDouble());

            case TdsDataType.TDS_FLTN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 4: return(stream.ReadFloat());

                case 8: return(stream.ReadDouble());
                }
                break;

            case TdsDataType.TDS_CHAR:
            case TdsDataType.TDS_VARCHAR:
            case TdsDataType.TDS_BOUNDARY:
            case TdsDataType.TDS_SENSITIVITY:
                return(stream.ReadNullableByteLengthPrefixedString(env.Encoding));

            case TdsDataType.TDS_BINARY:
            case TdsDataType.TDS_VARBINARY:
                return(stream.ReadNullableByteLengthPrefixedByteArray());

            case TdsDataType.TDS_LONGCHAR:
                return(stream.ReadNullableIntLengthPrefixedString(env.Encoding));

            /*
             * TDS_LONGBINARY serialization 55 serialized java object or instance (i.e. java object)
             * TDS_LONGBINARY serialized java class 56 serialized java class (i.e. byte code)
             * TDS_LONGBINARY smallbinary 59 64K max length binary data (ASA)
             * TDS_LONGBINARY unichar 34 fixed length UTF-16 encoded data
             * TDS_LONGBINARY univarchar 35 variable length UTF-16 encoded data
             */
            case TdsDataType.TDS_LONGBINARY:
            {
                //the UserType can affect how we need to interpret the result data
                switch (format.UserType)
                {
                case 34:
                case 35:
                    return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));

                default:
                    return(stream.ReadNullableIntLengthPrefixedByteArray());
                }
            }

            case TdsDataType.TDS_DECN:
            case TdsDataType.TDS_NUMN:
            {
                var precision = format.Precision ?? 1;
                var scale     = format.Scale ?? 0;

                Logger.Instance?.WriteLine($"  <- {format.DisplayColumnName} ({precision}, {scale})");

                var aseDecimal = stream.ReadAseDecimal(precision, scale);

                return(aseDecimal.HasValue
                            ? env.UseAseDecimal
                                ? (object)aseDecimal.Value
                                : aseDecimal.Value.ToDecimal()
                            : DBNull.Value);
            }

            case TdsDataType.TDS_MONEY:
                return(stream.ReadMoney());

            case TdsDataType.TDS_SHORTMONEY:
                return(stream.ReadSmallMoney());

            case TdsDataType.TDS_MONEYN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 4:
                    return(stream.ReadSmallMoney());

                case 8:
                    return(stream.ReadMoney());
                }
                break;

            case TdsDataType.TDS_DATETIME:
                return(stream.ReadIntPartDateTime());

            case TdsDataType.TDS_SHORTDATE:
                return(stream.ReadShortPartDateTime());

            case TdsDataType.TDS_DATETIMEN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 4:
                    return(stream.ReadShortPartDateTime());

                case 8:
                    return(stream.ReadIntPartDateTime());
                }
                break;

            case TdsDataType.TDS_DATE:
                return(stream.ReadDate());

            case TdsDataType.TDS_DATEN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 4:
                    return(stream.ReadDate());
                }
                break;

            case TdsDataType.TDS_TIME:
                return(stream.ReadTime());

            case TdsDataType.TDS_TIMEN:
                switch (stream.ReadByte())
                {
                case 0: return(DBNull.Value);

                case 4:
                    return(stream.ReadTime());
                }
                break;

            case TdsDataType.TDS_TEXT:
            case TdsDataType.TDS_XML:
            {
                var textPtrLen = (byte)stream.ReadByte();
                if (textPtrLen == 0)
                {
                    return(DBNull.Value);
                }
                var textPtr = new byte[textPtrLen];
                stream.Read(textPtr, 0, textPtrLen);
                stream.ReadULong();         //timestamp
                return(stream.ReadNullableIntLengthPrefixedString(env.Encoding));
            }

            case TdsDataType.TDS_IMAGE:
            {
                var textPtrLen = (byte)stream.ReadByte();
                if (textPtrLen == 0)
                {
                    return(DBNull.Value);
                }
                var textPtr = new byte[textPtrLen];
                stream.Read(textPtr, 0, textPtrLen);
                stream.ReadULong();         //timestamp
                var dataLen = stream.ReadInt();
                var data    = new byte[dataLen];
                stream.Read(data, 0, dataLen);
                return(data);
            }

            case TdsDataType.TDS_UNITEXT:
            {
                var textPtrLen = (byte)stream.ReadByte();
                if (textPtrLen == 0)
                {
                    return(DBNull.Value);
                }
                var textPtr = new byte[textPtrLen];
                stream.Read(textPtr, 0, textPtrLen);
                stream.ReadULong();         //timestamp
                return(stream.ReadNullableIntLengthPrefixedString(Encoding.Unicode));
            }

            default:
                Debug.Assert(false, $"Unsupported data type {format.DataType}");
                break;
            }

            return(DBNull.Value); // Catch-all.
        }
Example #15
0
 public void Read(Stream s)
 {
     Name   = s.ReadUTF();
     Offset = (uint)s.ReadInt() + PakFile.DataOffset;
     Length = s.ReadInt();
 }
Example #16
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     Animate = aStream.ReadByte2 ();
 }
Example #17
0
 public override void ReadFromStream(Stream aStream)
 {
     base.ReadFromStream (aStream);
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
     Yaw = aStream.ReadByte2 ();
     Pitch = aStream.ReadByte2 ();
 }
        public List <PackageInformation> Parse(Stream stream)
        {
            var dirInfos = new List <PackageInformation>();

            stream.Seek(0x28, SeekOrigin.Begin); // skip unknown headers

            while (true)
            {
                var dirInfo = new PackageInformation();

                byte[] directoryNameBytes  = null;
                var    directoryNameLength = stream.ReadInt();
                if (directoryNameLength > 0)
                {
                    stream.Read(directoryNameLength - 1, out directoryNameBytes);
                    stream.Seek(1, SeekOrigin.Current); // trim no needed '\0'
                }
                else
                {
                    if (stream.Position == 0x2C)
                    {
                        directoryNameBytes = Encoding.UTF8.GetBytes("root");
                        stream.Seek(4, SeekOrigin.Current);
                    }
                    else
                    {
                        // end of file
                        return(dirInfos);
                    }
                }

                var directoryName = (directoryNameBytes != null) ?
                                    Encoding.UTF8.GetString(directoryNameBytes) :
                                    null;

                dirInfo.DirectoryName = directoryName;
                var itemLength = stream.ReadInt();
                dirInfo.Files = new List <PackageFilenformation>();

                for (var i = 0; i < itemLength; i++)
                {
                    var fileNameLength = stream.ReadInt();
                    stream.Read(fileNameLength - 1, out var fileNameBytes);
                    stream.Seek(1, SeekOrigin.Current); // trim no needed '\0'
                    var fileSize   = stream.ReadInt();
                    var unknown1   = stream.ReadInt();
                    var hashLength = stream.ReadInt();
                    stream.Read(hashLength, out var hashBytes);

                    dirInfo.Files.Add(new PackageFilenformation
                    {
                        FileName        = Encoding.UTF8.GetString(fileNameBytes),
                        Unknown01       = unknown1,
                        FileSize        = fileSize,
                        Sha256HashValue = hashBytes
                    });
                }
                dirInfo.DirectoryCount = stream.ReadInt();
                dirInfos.Add(dirInfo);
            }
        }
Example #19
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
 }
Example #20
0
 public override void ReadFromStream(Stream aStream)
 {
     UserID = aStream.ReadInt ();
     TargetID = aStream.ReadInt ();
     LeftClick = aStream.ReadBoolean ();
 }
Example #21
0
        private static void readMapData(Stream s, Map map)
        {
            map.RelativeId            = s.ReadUInt();
            map.Type                  = s.ReadByte();
            map.SubAreaId             = s.ReadInt();
            map.Neighbours.Top        = s.ReadUInt();
            map.Neighbours.Bottom     = s.ReadUInt();
            map.Neighbours.Left       = s.ReadUInt();
            map.Neighbours.Right      = s.ReadUInt();
            map.ShadowBonusOnEntities = s.ReadUInt();

            if (map.Version >= 9)
            {
                var readColor = s.ReadUInt();
                map.BackgroundColor.Alpha = (byte)((readColor & 0b11111111_00000000_00000000_00000000) >> 32);
                map.BackgroundColor.Red   = (byte)((readColor & 0b00000000_11111111_00000000_00000000) >> 16);
                map.BackgroundColor.Green = (byte)((readColor & 0b00000000_00000000_11111111_00000000) >> 8);
                map.BackgroundColor.Blue  = (byte)((readColor & 0b00000000_00000000_00000000_11111111) >> 0);

                readColor           = s.ReadUInt();
                map.GridColor.Alpha = (byte)((readColor & 0b11111111_00000000_00000000_00000000) >> 32);
                map.GridColor.Red   = (byte)((readColor & 0b00000000_11111111_00000000_00000000) >> 16);
                map.GridColor.Green = (byte)((readColor & 0b00000000_00000000_11111111_00000000) >> 8);
                map.GridColor.Blue  = (byte)((readColor & 0b00000000_00000000_00000000_11111111) >> 0);
            }
            else if (map.Version >= 3)
            {
                map.BackgroundColor.Red   = (byte)s.ReadByte();
                map.BackgroundColor.Green = (byte)s.ReadByte();
                map.BackgroundColor.Blue  = (byte)s.ReadByte();
            }

            if (map.Version >= 4)
            {
                map.ZoomScale   = s.ReadUShort() / 100f;
                map.ZoomOffsetX = s.ReadShort();
                map.ZoomOffsetY = s.ReadShort();
                if (map.ZoomScale < 1)
                {
                    map.ZoomScale   = 1;
                    map.ZoomOffsetX = 0;
                    map.ZoomOffsetY = 0;
                }
            }

            if (map.Version > 10)
            {
                map.TacticalModeTemplateId = s.ReadInt();
            }

            map.UseLowPassFilter = s.ReadByte() == 1;
            map.UseReverb        = s.ReadByte() == 1;
            if (map.UseReverb)
            {
                map.PresetId = s.ReadInt();
            }
            else
            {
                map.PresetId = -1;
            }

            var backgroundCount = s.ReadByte();

            for (int i = 0; i < backgroundCount; i++)
            {
                map.BackgroundFixtures.Add(Fixture.FromRaw(s));
            }

            var foregroundCount = s.ReadByte();

            for (int i = 0; i < foregroundCount; i++)
            {
                map.ForegroundFixtures.Add(Fixture.FromRaw(s));
            }

            s.ReadInt(); // ???

            map.GroundCRC = s.ReadInt();

            var layerCount = s.ReadByte();

            for (int i = 0; i < layerCount; i++)
            {
                map.Layers.Add(Layer.FromRaw(s, map.Version));
            }

            var cellCount = AtouinConstants.MapCellsCount;

            for (int i = 0; i < cellCount; i++)
            {
                map.Cells.Add(CellData.FromRaw(s, map, i));
            }

            s.Close();
        }
Example #22
0
        private void load(Stream stream)
        {
            // Clear state
            if (Root != null)
            {
                Root.Dispose();
                Root = null;
            }

            // Header
            if (stream.ReadInt() != 1032)
            {
                throw new FileLoadException("Invalid Code Frame file.");
            }

            // Version
            int version = stream.ReadInt();

            // Switch version
            switch (version)
            {
            case 1:
            {
                // Read root node
                Root = loadNode1(stream);

                break;
            }

            case 2:
            {
                // Read date
                Date = stream.ReadDateTime();

                // Read root node
                Root = loadNode1(stream);

                break;
            }

            case 3:
            {
                // Read date
                Date = stream.ReadDateTime();

                // Read root node
                Root = loadNode3(stream);

                break;
            }

            case 4:
            {
                // Read date
                Date = stream.ReadDateTime();

                // Read root node
                Root = loadNode4(stream);

                break;
            }

            default:
                throw new FileLoadException("Unknown Code Frame file version.");
            }

            // Ending char
            if (stream.ReadByte() != 99)
            {
                throw new FileLoadException("Code Frame file. is corrupted");
            }
        }
Example #23
0
        public override void CreateFromStream(Stream stream)
        {
            Album.IndexLength = stream.ReadInt();
            stream.Seek(2);
            Album.Version = (ImgVersion)stream.ReadInt();
            Album.Count   = stream.ReadInt();
            var dic = new Dictionary <Sprite, int>();

            for (var i = 0; i < Album.Count; i++)
            {
                var image = new Sprite(Album)
                {
                    Index = Album.List.Count,
                    Type  = (ColorBits)stream.ReadInt()
                };
                Album.List.Add(image);
                if (image.Type == ColorBits.LINK)
                {
                    dic.Add(image, stream.ReadInt());
                    continue;
                }
                image.CompressMode = (CompressMode)stream.ReadInt();
                image.Width        = stream.ReadInt();
                image.Height       = stream.ReadInt();
                image.Length       = stream.ReadInt();
                image.X            = stream.ReadInt();
                image.Y            = stream.ReadInt();
                image.FrameWidth   = stream.ReadInt();
                image.FrameHeight  = stream.ReadInt();
                if (image.CompressMode == CompressMode.NONE)
                {
                    image.Length = image.Size.Width * image.Size.Height * (image.Type == ColorBits.ARGB_8888 ? 4 : 2);
                }
                var data = new byte[image.Length];
                stream.Read(data);
                image.Data = data;
            }
            foreach (var image in Album.List)
            {
                if (image.Type == ColorBits.LINK)
                {
                    if (dic.ContainsKey(image) && dic[image] > -1 && dic[image] < Album.List.Count &&
                        dic[image] != image.Index)
                    {
                        image.Target    = Album.List[dic[image]];
                        image.Size      = image.Target.Size;
                        image.FrameSize = image.Target.FrameSize;
                        image.Location  = image.Target.Location;
                    }
                    else
                    {
                        Album.List.Clear();
                        return;
                    }
                }
            }
        }
Example #24
0
 private static object ReadTDS_INT4(Stream stream, FormatItem format, DbEnvironment env)
 {
     return(stream.ReadInt());
 }
Example #25
0
        public override void CreateFromStream(Stream stream)
        {
            var indexCount = stream.ReadInt();

            Album.Length = stream.ReadInt();
            var count = stream.ReadInt();
            var table = new List <Color>(Colors.ReadPalette(stream, count));

            Album.Tables = new List <List <Color> > {
                table
            };
            var list = new List <Texture>();

            for (var i = 0; i < indexCount; i++)
            {
                var dds = new Texture {
                    Version    = (TextureVersion)stream.ReadInt(),
                    Type       = (ColorBits)stream.ReadInt(),
                    Index      = stream.ReadInt(),
                    Length     = stream.ReadInt(),
                    FullLength = stream.ReadInt(),
                    Width      = stream.ReadInt(),
                    Height     = stream.ReadInt()
                };
                list.Add(dds);
            }
            var dic      = new Dictionary <Sprite, int>();
            var ver2List = new List <Sprite>();

            for (var i = 0; i < Album.Count; i++)
            {
                var entity = new Sprite(Album);
                entity.Index = Album.List.Count;
                entity.Type  = (ColorBits)stream.ReadInt();
                Album.List.Add(entity);
                if (entity.Type == ColorBits.LINK)
                {
                    dic.Add(entity, stream.ReadInt());
                    continue;
                }
                entity.CompressMode = (CompressMode)stream.ReadInt();
                entity.Width        = stream.ReadInt();
                entity.Height       = stream.ReadInt();
                entity.Length       = stream.ReadInt(); //保留,固定为0
                entity.X            = stream.ReadInt();
                entity.Y            = stream.ReadInt();
                entity.FrameWidth   = stream.ReadInt();
                entity.FrameHeight  = stream.ReadInt();
                if (entity.Type < ColorBits.LINK && entity.Length != 0)
                {
                    ver2List.Add(entity);
                    continue;
                }
                var j         = stream.ReadInt();
                var k         = stream.ReadInt();
                var dds       = list[k];
                var leftup    = new Point(stream.ReadInt(), stream.ReadInt());
                var rightdown = new Point(stream.ReadInt(), stream.ReadInt());
                var top       = stream.ReadInt();
                var info      = new TextureInfo {
                    Unknown   = j,
                    Texture   = dds,
                    LeftUp    = leftup,
                    RightDown = rightdown,
                    Top       = top
                };
                _map.Add(entity.Index, info);
            }

            foreach (var entity in dic.Keys)
            {
                entity.Target = Album.List[dic[entity]];
            }
            foreach (var dds in list)
            {
                var data = new byte[dds.Length];
                stream.Read(data);
                dds.Data = data;
            }
            foreach (var entity in ver2List)
            {
                var data = new byte[entity.Length];
                stream.Read(data);
                entity.Data = data;
            }
        }
Example #26
0
 /** <inheritdoc /> */
 public int ReadInt()
 {
     return(Stream.ReadInt());
 }
Example #27
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     InBed = aStream.ReadByte2 ();
     X = aStream.ReadInt ();
     Y = aStream.ReadByte2 ();
     Z = aStream.ReadInt ();
 }
Example #28
0
        private T ReadFullObject <T>(int pos)
        {
            // Read header.
            bool userType = Stream.ReadBool();
            int  typeId   = Stream.ReadInt();
            // ReSharper disable once UnusedVariable
            int hashCode  = Stream.ReadInt();
            int len       = Stream.ReadInt();
            int rawOffset = Stream.ReadInt();

            try
            {
                // Already read this object?
                object hndObj;

                if (_hnds != null && _hnds.TryGetValue(pos, out hndObj))
                {
                    return((T)hndObj);
                }

                if (userType && _mode == PortableMode.ForcePortable)
                {
                    PortableUserObject portObj;

                    if (_detach)
                    {
                        Stream.Seek(pos, SeekOrigin.Begin);

                        portObj = GetPortableUserObject(pos, 0, Stream.ReadByteArray(len));
                    }
                    else
                    {
                        portObj = GetPortableUserObject(pos, pos, Stream.Array());
                    }

                    T obj = _builder == null ? TypeCaster <T> .Cast(portObj) : TypeCaster <T> .Cast(_builder.Child(portObj));

                    AddHandle(pos, obj);

                    return(obj);
                }
                else
                {
                    // Find descriptor.
                    IPortableTypeDescriptor desc;

                    if (!_descs.TryGetValue(PortableUtils.TypeKey(userType, typeId), out desc))
                    {
                        throw new PortableException("Unknown type ID: " + typeId);
                    }

                    // Instantiate object.
                    if (desc.Type == null)
                    {
                        throw new PortableException("No matching type found for object [typeId=" +
                                                    desc.TypeId + ", typeName=" + desc.TypeName + ']');
                    }

                    // Preserve old frame.
                    int oldTypeId    = _curTypeId;
                    int oldPos       = _curPos;
                    int oldRawOffset = _curRawOffset;
                    IPortableNameMapper oldConverter = _curConverter;
                    IPortableIdMapper   oldMapper    = _curMapper;
                    bool oldRaw = _curRaw;

                    // Set new frame.
                    _curTypeId    = typeId;
                    _curPos       = pos;
                    _curRawOffset = rawOffset;
                    _curConverter = desc.NameConverter;
                    _curMapper    = desc.Mapper;
                    _curRaw       = false;

                    // Read object.
                    object obj;

                    var sysSerializer = desc.Serializer as IPortableSystemTypeSerializer;

                    if (sysSerializer != null)
                    {
                        obj = sysSerializer.ReadInstance(this);
                    }
                    else
                    {
                        try
                        {
                            obj = FormatterServices.GetUninitializedObject(desc.Type);

                            // Save handle.
                            AddHandle(pos, obj);
                        }
                        catch (Exception e)
                        {
                            throw new PortableException("Failed to create type instance: " +
                                                        desc.Type.AssemblyQualifiedName, e);
                        }

                        desc.Serializer.ReadPortable(obj, this);
                    }

                    // Restore old frame.
                    _curTypeId    = oldTypeId;
                    _curPos       = oldPos;
                    _curRawOffset = oldRawOffset;
                    _curConverter = oldConverter;
                    _curMapper    = oldMapper;
                    _curRaw       = oldRaw;

                    var wrappedSerializable = obj as SerializableObjectHolder;

                    return(wrappedSerializable != null ? (T)wrappedSerializable.Item : (T)obj);
                }
            }
            finally
            {
                // Advance stream pointer.
                Stream.Seek(pos + len, SeekOrigin.Begin);
            }
        }
Example #29
0
 public override void ReadFromStream(Stream aStream)
 {
     CollectedEID = aStream.ReadInt ();
     CollectorEID = aStream.ReadInt ();
 }
        private static Exception CreateExceptionFromError(Stream stream)
        {
            ErrorCodes code = (ErrorCodes) stream.ReadInt();
            string msg = stream.ReadString();

            switch (code)
            {
                case ErrorCodes.Unavailable:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int required = stream.ReadInt();
                        int alive = stream.ReadInt();
                        return new UnavailableException(msg, cl, required, alive);
                    }

                case ErrorCodes.WriteTimeout:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int received = stream.ReadInt();
                        int blockFor = stream.ReadInt();
                        string writeType = stream.ReadString();
                        return new WriteTimeOutException(msg, cl, received, blockFor, writeType);
                    }

                case ErrorCodes.ReadTimeout:
                    {
                        ConsistencyLevel cl = (ConsistencyLevel) stream.ReadUShort();
                        int received = stream.ReadInt();
                        int blockFor = stream.ReadInt();
                        bool dataPresent = 0 != stream.ReadByte();
                        return new ReadTimeOutException(msg, cl, received, blockFor, dataPresent);
                    }

                case ErrorCodes.Syntax:
                    return new SyntaxException(msg);

                case ErrorCodes.Unauthorized:
                    return new UnauthorizedException(msg);

                case ErrorCodes.Invalid:
                    return new InvalidException(msg);

                case ErrorCodes.AlreadyExists:
                    {
                        string keyspace = stream.ReadString();
                        string table = stream.ReadString();
                        return new AlreadyExistsException(msg, keyspace, table);
                    }

                case ErrorCodes.Unprepared:
                    {
                        byte[] unknownId = stream.ReadShortBytes();
                        return new UnpreparedException(msg, unknownId);
                    }

                default:
                    return new CassandraException(code, msg);
            }
        }
Example #31
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     Slot = aStream.ReadShort ();
     ItemID = aStream.ReadShort ();
     Damage = aStream.ReadShort ();
 }
Example #32
0
        public static DateTime ReadTime(this Stream stream)
        {
            var sqlTicks = stream.ReadInt();

            return(Constants.Sql.RegularDateTime.Epoch.AddMilliseconds((int)(sqlTicks / Constants.Sql.RegularDateTime.TicksPerMillisecond)));
        }
Example #33
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     Title = aStream.ReadString16 ();
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
     Direction = aStream.ReadInt ();
 }
Example #34
0
 public override void ReadFromStream(Stream aStream)
 {
     X = aStream.ReadInt ();
     Y = aStream.ReadByte2 ();
     Z = aStream.ReadInt ();
     Direction = aStream.ReadFace ();
     ItemID = aStream.ReadShort ();
     if (ItemID >= 0) {
         Amount = aStream.ReadByte2 ();
         Damage = aStream.ReadShort ();
     }
 }
Example #35
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     VelX = aStream.ReadShort ();
     VelY = aStream.ReadShort ();
     VelZ = aStream.ReadShort ();
 }
Example #36
0
 public override void ReadFromStream(Stream aStream)
 {
     Status = (DigStatus)aStream.ReadByte ();
     X = aStream.ReadInt ();
     Y = aStream.ReadByte2 ();
     Z = aStream.ReadInt ();
     Face = aStream.ReadFace ();
 }
Example #37
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     UserName = aStream.ReadString16 ();
     MapSeed = aStream.ReadLong ();
     Dimension = aStream.ReadByte2 ();
 }
Example #38
0
 public override void ReadFromStream(Stream aStream)
 {
     X = aStream.ReadInt ();
     Z = aStream.ReadInt ();
     Mode = aStream.ReadBoolean ();
 }
Example #39
0
        public static Texture Decode(Stream stream)
        {
            Texture texture = new Texture();
            var     magic   = stream.ReadInt();

            if (magic != DDS_MAGIC)
            {
                throw new Exception("Invalid magic number in DDS header");
            }
            texture.Length = stream.ReadInt();
            texture.Flags  = stream.ReadInt();
            texture.Width  = stream.ReadInt();
            texture.Height = stream.ReadInt();
            texture.Pitch  = stream.ReadInt();
            texture.Depth  = stream.ReadInt();
            var count = stream.ReadInt();

            texture.Reverse = stream.Read(11);
            stream.Seek(37);
            var pfFlags = stream.ReadInt();

            if ((pfFlags & DDS_MIPMAP_COUNT) != 0)
            {
                texture.Count = Math.Max(1, count);
            }
            var format     = stream.ReadInt();
            var blockBytes = 0;

            switch (format)
            {
            case DXT_1:
                blockBytes     = 8;
                texture.Format = TextureFormat.RGB_S3TC_DXT1_Format;
                break;

            case DXT_3:
                blockBytes     = 16;
                texture.Format = TextureFormat.RGBA_S3TC_DXT3_Format;
                break;

            case DXT_5:
                blockBytes     = 16;
                texture.Format = TextureFormat.RGBA_S3TC_DXT5_Format;
                break;
            }
            var offset = texture.Length + 4;

            stream.Seek(offset, SeekOrigin.Begin);
            var width  = texture.Width;
            var height = texture.Height;
            var len    = width * height / 16 * blockBytes;

            texture.Mipmaps = new Mipmap[texture.Count];
            for (var i = 0; i < texture.Count; i++)
            {
                stream.Read(len, out byte[] data);
                switch (format)
                {
                case DXT_1:
                    data = DecodeDXT1(data, width, height);
                    break;

                case DXT_3:
                    data = DecodeDXT3(data, width, height);
                    break;

                case DXT_5:
                    data = DecodeDXT5(data, width, height);
                    break;
                }
                Mipmap mip = new Mipmap()
                {
                    Width  = width,
                    Height = height,
                    Data   = data
                };
                texture.Mipmaps[i] = mip;
                width  = Math.Max(width >> 1, 1);
                height = Math.Max(height >> 1, 1);
            }
            return(texture);
        }
Example #40
0
 public override void ReadFromStream(Stream aStream)
 {
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
 }
Example #41
0
 public override void ReadFromStream(Stream aStream)
 {
     base.ReadFromStream (aStream);
     VehicleID = aStream.ReadInt ();
 }
Example #42
0
        public override object Deserialize(Stream stream, Type type)
        {
            stream.AssertNotNull();
            type.AssertNotNull();

            if (!CanHandle(type))
            {
                Warning($"{nameof(DelegateSerializer)} cannot handle type {type}!");
                return(null);
            }

            long?referenceID = stream.ReadLong();

            if (referenceID == null)
            {
                Warning($"Could not read {type} reference ID!");
                return(null);
            }

            MulticastDelegate instance = references.GetValueOrDefault(referenceID.Value);

            bool?hasPayload = stream.ReadBool();

            if (hasPayload == null)
            {
                Warning($"Could not read {type} payload indicator!");
                return(null);
            }
            if (hasPayload == false)
            {
                if (instance == null)
                {
                    Warning($"Neither payload nor already restored reference found for {type} ({referenceID})!");
                }

                return(instance);
            }

            int?methodCount = stream.ReadInt();

            if (methodCount == null)
            {
                Warning("Could not read multicast delegate method count!");
                return(null);
            }

            Delegate[] dels = new Delegate[methodCount.Value];
            for (int i = 0; i < methodCount.Value; i++)
            {
                string name = stream.ReadString(Marshaller.Encoding);
                if (name == null)
                {
                    Warning("Could not read multicast delegate method name!");
                    return(null);
                }

                string declaringTypeName = stream.ReadString(Marshaller.Encoding);
                if (declaringTypeName == null)
                {
                    Warning("Could not read multicast delegate method declaring type!");
                    return(null);
                }

                Type declaringType = Cache.GetTypeFrom(declaringTypeName, Marshaller.AssemblyResolver, Marshaller.TypeResolver);
                if (declaringType == null)
                {
                    Warning($"Could not retrieve type for {declaringTypeName} from cache!");
                    return(null);
                }

                int?paramTypeNameCount = stream.ReadInt();
                if (paramTypeNameCount == null)
                {
                    Warning("Could not read multicast delegate method parameter type name count!");
                    return(null);
                }

                Type[] paramTypes = new Type[paramTypeNameCount.Value];
                for (int j = 0; j < paramTypeNameCount.Value; j++)
                {
                    string paramTypeName = stream.ReadString(Marshaller.Encoding);
                    if (paramTypeName == null)
                    {
                        Warning("Could not read multicast delegate method parameter type name!");
                        return(null);
                    }

                    Type paramType = Cache.GetTypeFrom(paramTypeName, Marshaller.AssemblyResolver, Marshaller.TypeResolver);
                    if (paramType == null)
                    {
                        Warning($"Could not retrieve type for {paramTypeName} from cache!");
                        return(null);
                    }

                    paramTypes[j] = paramType;
                }

                const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
                MethodInfo         method       = declaringType.GetMethod(name, bindingFlags, null, paramTypes, null);
                if (method == null)
                {
                    Warning($"Could not find method {name} on type {declaringType}!");
                    return(null);
                }

                dels[i] = Delegate.CreateDelegate(type, method);
            }

            if (instance == null)
            {
                instance = (MulticastDelegate)Delegate.Combine(dels);
                references[referenceID.Value] = instance;
            }

            return(instance);
        }
Example #43
0
 public override void ReadFromStream(Stream aStream)
 {
     EntityID = aStream.ReadInt ();
     ItemID = aStream.ReadShort ();
     Count = aStream.ReadByte2 ();
     DamageData = aStream.ReadShort ();
     X = aStream.ReadInt ();
     Y = aStream.ReadInt ();
     Z = aStream.ReadInt ();
     Rotation = aStream.ReadByte2 ();
     Pitch = aStream.ReadByte2 ();
     Roll = aStream.ReadByte2 ();
 }
Example #44
0
        public static DateTime ReadDate(this Stream stream)
        {
            var p1 = stream.ReadInt();

            return(Constants.Sql.RegularDateTime.Epoch.AddDays(p1));
        }