コード例 #1
0
ファイル: MultipartStreamer.cs プロジェクト: klkucan/EasyHttp
        public void StreamMultiPart(Stream stream)
        {
            stream.WriteString(_boundary);

            if (_multipartFormData != null)
            {
                foreach (var entry in _multipartFormData)
                {
                    stream.WriteString(CreateFormBoundaryHeader(entry.Key, entry.Value));
                    stream.WriteString(_boundary);
                }
            }

            if (_multipartFileData != null)
            {
                foreach (var fileData in _multipartFileData)
                {
                    using (var file = new FileStream(fileData.Filename, FileMode.Open))
                    {
                        stream.WriteString(CreateFileBoundaryHeader(fileData));

                        StreamFileContents(file, fileData, stream);

                        stream.WriteString(_boundary);
                    }
                }
            }
            stream.WriteString("--");
        }
コード例 #2
0
ファイル: BaseSirenAttribute.cs プロジェクト: fjz13/Medusa
        public virtual bool SaveTo(Stream stream)
        {
            stream.Write((uint)KeyValues.Count);
            foreach (var keyValue in KeyValues)
            {
                stream.WriteString(keyValue.Key);
                stream.WriteString(keyValue.Value);
            }

            return true;
        }
コード例 #3
0
 public override void RenderCommand(Stream stream)
 {
     if (Blob != null)
     {
         stream.WriteString("M 644 ");
         Blob.RenderMarkReference(stream);
         stream.WriteString(string.Format(" \"{0}\"", Path));
         stream.WriteLineFeed();
     }
     else
     {
         stream.WriteLine(string.Format("M 644 inline \"{0}\"", Path));
         stream.RenderCommand(Data);
     }
 }
コード例 #4
0
ファイル: BlobFile.cs プロジェクト: gibbed/Gibbed.Infantry
        public void Serialize(Stream output)
        {
            if (this.Version < 1 || this.Version > 2)
            {
                throw new InvalidOperationException("unsupported blob version");
            }

            output.WriteValueU32(this.Version);
            output.WriteValueS32(this.Entries.Count);

            var nameLength = this.Version == 2 ? 32 : 14;

            foreach (var entry in this.Entries)
            {
                var name = entry.Name;

                if (name.Length + 1 > nameLength)
                {
                    throw new InvalidOperationException();
                }

                output.WriteString(name.PadRight(nameLength, '\0'));
                output.WriteValueU32((uint)entry.Offset);
                output.WriteValueU32(entry.Size);
            }
        }
コード例 #5
0
        public void Serialize(Stream dest, Exception value)
        {
            if (dest == null)
                throw new ArgumentNullException("dest");
            if (value == null)
                throw new ArgumentNullException("value");

            var type = value.GetType();
            int typeAlias = _data.TypeTable.GetAlias(type);
            var typeSerializable = _data.MessageSerializer.CanSerialize(type);

            dest.WriteByte((byte)((typeAlias != 0 ? 1 : 0) | (typeSerializable ? 2 : 0)));

            if (typeAlias != 0)
                dest.Write32BitEncodedInt(typeAlias);
            else
                dest.WriteString(type.FullName);

            if (typeSerializable)
            {
                var lengthMarker = new StreamLengthMarker(dest, true);
                _data.MessageSerializer.Serialize(dest, value);
                lengthMarker.WriteLength(true);
            }
        }
コード例 #6
0
        public void RenderMarkReference(Stream stream)
        {
            if (!_HasBeenRendered)
                throw new InvalidOperationException("A MarkCommand cannot be referenced if it has not been rendered.");

            var reference = string.Format(":{0}", MarkId);
            stream.WriteString(reference);
        }
コード例 #7
0
 public override void RenderCommand(Stream stream)
 {
     stream.WriteLine(string.Format("reset {0}", Reference));
     if (From != null)
     {
         stream.WriteString("from ");
         From.RenderMarkReference(stream);
         stream.WriteLineFeed();
     }
 }
コード例 #8
0
ファイル: MultipartStreamer.cs プロジェクト: bangq/EasyHttp
	    static void StreamFileContents(Stream file, FileData fileData, Stream requestStream)
        {
            var buffer = new byte[8192];

            int count;

            while ((count = file.Read(buffer, 0, buffer.Length)) > 0)
            {
                if (fileData.ContentTransferEncoding == HttpContentTransferEncoding.Base64)
                {
                    string str = Convert.ToBase64String(buffer, 0, count);

                    requestStream.WriteString(str);
                }
                else if (fileData.ContentTransferEncoding == HttpContentTransferEncoding.Binary)
                {
                    requestStream.Write(buffer, 0, count);
                }
            }
        }
コード例 #9
0
		public static void Encode(Image image, Stream stream)
		{
			stream.WriteString(image.Header);
			stream.WriteBytes(image.LogicalScreenDescriptor.ToBytes());

			if (image.LogicalScreenDescriptor.GlobalColorTableFlag)
			{
				stream.WriteBytes(image.GlobalColorTable);
			}

			foreach (var applicationExtension in image.ApplictionExtensions)
			{
				stream.WriteBytes(applicationExtension.ToBytes());
			}

			foreach (var commentExtension in image.CommentExtensions)
			{
				stream.WriteBytes(commentExtension.ToBytes());
			}

			WriteFrames(image.Frames, stream);
		}
コード例 #10
0
ファイル: SirenType.cs プロジェクト: fjz13/Medusa
 public virtual bool SaveTo(Stream stream)
 {
     stream.WriteString(Name);
     return true;
 }
コード例 #11
0
ファイル: SirenCustomClass.cs プロジェクト: fjz13/Medusa
        public override bool SaveTo(Stream stream)
        {
            base.SaveTo(stream);
            Attribute.SaveTo(stream);
            stream.WriteString(BaseTypeName);

            //types
            uint typeCount = (uint)Types.Count;
            stream.Write(typeCount);
            foreach (var baseSirenCustomType in Types)
            {
                byte isClass = baseSirenCustomType.Value.IsCustomClass ? (byte)1 : (byte)0;
                stream.WriteByte(isClass);
                baseSirenCustomType.Value.SaveTo(stream);
            }

            //fields
            uint filedCount = (uint)FieldNameDict.Count;
            stream.Write(filedCount);
            foreach (var sirenField in FieldNameDict)
            {
                sirenField.Value.SaveTo(stream);
            }

            return true;
        }
コード例 #12
0
        // +--------+--------+--+----------+-----------+-------------+-----------+------------+-------+
        // | LEN(4) | CRC(4) |H1| ID (1~6) | AID (1~6) | M_SIG (1~6) | M_LEN (4) | M_DATA (~) | E (~) |
        // +--------+--------+--+----------+-----------+-------------+-----------+------------+-------+
        // H=[ME....TT] T=Type, M=Message?, E=Exception?
        // ID=RequestId, AID=ActorId, M=Message, E=Exception

        public void Serialize(Stream stream, object packet)
        {
            var p = (Packet)packet;

            // Jump 8 Bytes for writing Length | Checksum
            var packetLengthMarker = new StreamLengthMarker(stream, false);
            stream.Seek(8, SeekOrigin.Current);

            // Write Packet Header
            var header = (byte)((byte)(p.Type) |
                                (byte)(p.Message != null ? 0x80 : 0) |
                                (byte)(p.Exception != null ? 0x40 : 0));
            stream.WriteByte(header);
            stream.Write7BitEncodedInt(p.ActorId);
            stream.Write7BitEncodedInt(p.RequestId);

            // Write Message
            if (p.Message != null)
            {
                if (p.Type == PacketType.System)
                {
                    // System message: Always string.
                    stream.WriteString((string)p.Message);
                }
                else
                {
                    // User message: Length, Signature, and Data
                    var messageTypeAlias = _data.TypeTable.GetAlias(p.Message.GetType());
                    stream.Write7BitEncodedInt(messageTypeAlias);
                    var messageLengthMarker = new StreamLengthMarker(stream, true);
                    _data.MessageSerializer.Serialize(stream, p.Message);
                    messageLengthMarker.WriteLength(true);
                }
            }

            // Write Exception
            if (p.Exception != null)
            {
                _exceptionSerializer.Serialize(stream, p.Exception);
            }

            // Write Length
            packetLengthMarker.WriteLength(false);

            // Encrypt and Calc Checksum
            ArraySegment<byte> s0, s1;
            GetBuffers(stream, (int)packetLengthMarker.StartPosition + 8, packetLengthMarker.Length - 4,
                       out s0, out s1);
            var ctx = new EncryptContext { Key = _serializeWrapKey };
            Encrypt(s0.Array, s0.Offset, s0.Array, s0.Offset, s0.Count, ref ctx);
            Encrypt(s1.Array, s1.Offset, s1.Array, s1.Offset, s1.Count, ref ctx);
            if (_serializeWrapKey != 0)
            {
                _serializeWrapKey += 1;
                if (_serializeWrapKey == 0)
                    _serializeWrapKey = 1;
            }

            // Write Checksum
            var hashBytes = BitConverter.GetBytes(ctx.Hash);
            stream.Write(hashBytes, 0, hashBytes.Length);

            // End of stream, again.
            stream.Seek(packetLengthMarker.EndPosition, SeekOrigin.Begin);

            // Pending WrapKey
            if (_serializeWrapPendingKey != 0)
            {
                _serializeWrapKey = _serializeWrapPendingKey;
                _serializeWrapPendingKey = 0;
            }
        }
コード例 #13
0
ファイル: SirenClassAttribute.cs プロジェクト: ylyking/Medusa
 public override bool SaveTo(Stream stream)
 {
     stream.Write((uint)Mode);
     stream.WriteString(Dir);
     return(true);
 }
コード例 #14
0
 public override async Task Encode()
 {
     await Stream.WriteString(AvatarName);
 }
コード例 #15
0
ファイル: Request.cs プロジェクト: SlaynationCoder/CoreTweet
        private static void WriteMultipartFormData(Stream stream, string boundary, IEnumerable <KeyValuePair <string, object> > prm)
        {
            const int bufferSize = 81920;

            foreach (var x in prm)
            {
                var valueStream       = x.Value as Stream;
                var valueArraySegment = x.Value as ArraySegment <byte>?;
                var valueBytes        = x.Value as IEnumerable <byte>;
#if !PCL
                var valueFile = x.Value as FileInfo;
#endif
                var valueString = x.Value.ToString();
#if WP
                var valueInputStream = x.Value as Windows.Storage.Streams.IInputStream;
                if (valueInputStream != null)
                {
                    valueStream = valueInputStream.AsStreamForRead();
                }
#endif

                stream.WriteString("--" + boundary + "\r\n");
                if (valueStream != null || valueBytes != null || valueArraySegment != null
#if !PCL
                    || valueFile != null
#endif
                    )
                {
                    stream.WriteString("Content-Type: application/octet-stream\r\n");
                }
                stream.WriteString(string.Format(@"Content-Disposition: form-data; name=""{0}""", x.Key));
#if !PCL
                if (valueFile != null)
                {
                    stream.WriteString(string.Format(@"; filename=""{0}""",
                                                     valueFile.Name.Replace("\n", "%0A").Replace("\r", "%0D").Replace("\"", "%22")));
                }
                else
#endif
                if (valueStream != null || valueBytes != null || valueArraySegment != null)
                {
                    stream.WriteString(@"; filename=""file""");
                }
                stream.WriteString("\r\n\r\n");

#if !PCL
                if (valueFile != null)
                {
                    valueStream = valueFile.OpenRead();
                }
#endif
                if (valueStream != null)
                {
                    var buffer = new byte[bufferSize];
                    int count;
                    while ((count = valueStream.Read(buffer, 0, bufferSize)) > 0)
                    {
                        stream.Write(buffer, 0, count);
                    }
                }
                else if (valueArraySegment != null)
                {
                    stream.Write(valueArraySegment.Value.Array, valueArraySegment.Value.Offset, valueArraySegment.Value.Count);
                }
                else if (valueBytes != null)
                {
                    var buffer = valueBytes as byte[];
                    if (buffer != null)
                    {
                        stream.Write(buffer, 0, buffer.Length);
                    }
                    else
                    {
                        buffer = new byte[bufferSize];
                        var i = 0;
                        foreach (var b in valueBytes)
                        {
                            buffer[i++] = b;
                            if (i == bufferSize)
                            {
                                stream.Write(buffer, 0, bufferSize);
                                i = 0;
                            }
                        }
                        if (i > 0)
                        {
                            stream.Write(buffer, 0, i);
                        }
                    }
                }
                else
                {
                    stream.WriteString(valueString);
                }

#if !PCL
                if (valueFile != null)
                {
                    valueStream.Close();
                }
#endif

                stream.WriteString("\r\n");
            }
            stream.WriteString("--" + boundary + "--");
        }
コード例 #16
0
 public static void WriteLine(this Stream stream, string s)
 {
     stream.WriteString(s);
     stream.WriteLineFeed();
 }
コード例 #17
0
        private static void WriteMultipartFormData(Stream stream, string boundary, IEnumerable <KeyValuePair <string, object> > prm)
        {
            prm.ForEach(x =>
            {
                var valueStream = x.Value as Stream;
                var valueBytes  = x.Value as IEnumerable <byte>;
#if !PCL
                var valueFile = x.Value as FileInfo;
#endif
                var valueString = x.Value.ToString();
#if WP
                var valueInputStream = x.Value as Windows.Storage.Streams.IInputStream;
                if (valueInputStream != null)
                {
                    valueStream = valueInputStream.AsStreamForRead();
                }
#endif

                stream.WriteString("--" + boundary + "\r\n");
                if (valueStream != null || valueBytes != null
#if !PCL
                    || valueFile != null
#endif
                    )
                {
                    stream.WriteString("Content-Type: application/octet-stream\r\n");
                }
                stream.WriteString(String.Format(@"Content-Disposition: form-data; name=""{0}""", x.Key));
#if !PCL
                if (valueFile != null)
                {
                    stream.WriteString(String.Format(@"; filename=""{0}""", valueFile.Name));
                }
                else
#endif
                if (valueStream != null || valueBytes != null)
                {
                    stream.WriteString(@"; filename=""file""");
                }
                stream.WriteString("\r\n\r\n");

#if !PCL
                if (valueFile != null)
                {
                    valueStream = valueFile.OpenRead();
                }
#endif
                if (valueStream != null)
                {
                    while (true)
                    {
                        var buffer = new byte[4096];
                        var count  = valueStream.Read(buffer, 0, buffer.Length);
                        if (count == 0)
                        {
                            break;
                        }
                        stream.Write(buffer, 0, count);
                    }
                }
                else if (valueBytes != null)
                {
                    valueBytes.ForEach(b => stream.WriteByte(b));
                }
                else
                {
                    stream.WriteString(valueString);
                }

#if !PCL
                if (valueFile != null)
                {
                    valueStream.Close();
                }
#endif

                stream.WriteString("\r\n");
            });
            stream.WriteString("--" + boundary + "--");
        }
コード例 #18
0
ファイル: FastPacker.cs プロジェクト: FPCollab/General
 public static void Write(object obj, Stream stream)
 {
     stream.WriteString((string)obj);
 }
コード例 #19
0
 public void Write(Stream destination)
 {
     destination.WriteInt32(this.Id);
     destination.WriteInt64(this.Offset);
     destination.WriteString(this.Metadata);
 }
コード例 #20
0
 public void Write(Stream destination)
 {
     destination.WriteString(this.Name);
     destination.WriteArray(this.Partitions);
 }
コード例 #21
0
 public override void ToStream(Stream s)
 {
     s.WriteString(this.ZeroTerminatedStrings, this.Name);
 }
コード例 #22
0
        private void Write(Stream BTKFile)
        {
            string Padding = "Hack.io.BTK © Super Hackio Incorporated 2020";

            BTKFile.WriteString(Magic);
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            BTKFile.Write(new byte[4] {
                0x00, 0x00, 0x00, 0x01
            }, 0, 4);
            BTKFile.Write(new byte[16] {
                0x53, 0x56, 0x52, 0x31, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
            }, 0, 16);
            BTKFile.WriteString(Magic2);
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            BTKFile.WriteByte((byte)Loop);
            BTKFile.WriteByte((byte)RotationMultiplier);
            BTKFile.WriteReverse(BitConverter.GetBytes(Time), 0, 2);
            BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations.Count * 3)), 0, 2);
            BTKFile.Write(new byte[2] {
                0xDD, 0xDD
            }, 0, 2);
            BTKFile.Write(new byte[2] {
                0xEE, 0xEE
            }, 0, 2);
            BTKFile.Write(new byte[2] {
                0xFF, 0xFF
            }, 0, 2);
            //Animation Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Remap Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Material ST Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //TexMtxTable Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Center Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Scale Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Rotation Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            //Translation Table Offset
            BTKFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);

            #region Padding
            //int PadCount = 0;
            while (BTKFile.Position < 0x80)
            {
                BTKFile.WriteByte(0x00);
            }
            #endregion

            long AnimationTableOffset = BTKFile.Position;
            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].ScaleUFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].ScaleUFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].RotationUFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].RotationUFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].TranslationUFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].TranslationUFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);

                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].ScaleVFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].ScaleVFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].RotationVFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].RotationVFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].TranslationVFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].TranslationVFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);

                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].ScaleWFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].ScaleWFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].RotationWFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].RotationWFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TextureAnimations[i].TranslationWFrames.Count), 0, 2);
                BTKFile.WriteReverse(new byte[2], 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes((ushort)(TextureAnimations[i].TranslationWFrames.Any(S => S.IngoingTangent != S.OutgoingTangent) ? 1 : 1)), 0, 2);
            }
            #region Padding
            int PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long          RemapTableOffset = BTKFile.Position;
            List <string> strings          = new List <string>();
            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(TextureAnimations[i].RemapIndex), 0, 2);
                strings.Add(TextureAnimations[i].MaterialName);
            }

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long StringTableOffset = BTKFile.Position;
            BTKFile.WriteReverse(BitConverter.GetBytes((ushort)strings.Count), 0, 2);
            BTKFile.Write(new byte[2] {
                0xFF, 0xFF
            }, 0, 2);
            ushort      stringofffset = (ushort)(4 + (4 * strings.Count));
            List <byte> bytestrings   = new List <byte>();
            byte[]      TexMapID      = new byte[TextureAnimations.Count];
            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(StringToHash(strings[i])), 0, 2);
                BTKFile.WriteReverse(BitConverter.GetBytes(stringofffset), 0, 2);
                byte[] currentstring = Encoding.GetEncoding(932).GetBytes(strings[i]);
                stringofffset += (ushort)(currentstring.Length + 1);
                bytestrings.AddRange(currentstring);
                bytestrings.Add(0x00);
                TexMapID[i] = TextureAnimations[i].MaterialTextureID;
            }
            BTKFile.Write(bytestrings.ToArray(), 0, bytestrings.Count);

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long TexMapIDTableOffset = BTKFile.Position;
            BTKFile.Write(TexMapID, 0, TexMapID.Length);

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long CenterTableOffset = BTKFile.Position;
            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(TextureAnimations[i].Center[0]), 0, 4);
                BTKFile.WriteReverse(BitConverter.GetBytes(TextureAnimations[i].Center[1]), 0, 4);
                BTKFile.WriteReverse(BitConverter.GetBytes(TextureAnimations[i].Center[2]), 0, 4);
            }

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            List <float> ScaleTable       = new List <float>();
            List <short> RotationTable    = new List <short>();
            List <float> TranslationTable = new List <float>();

            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                FindMatch(ref ScaleTable, TextureAnimations[i].ScaleUFrames, 1);
                FindMatch(ref ScaleTable, TextureAnimations[i].ScaleVFrames, 1);
                FindMatch(ref ScaleTable, TextureAnimations[i].ScaleWFrames, 1);
                FindMatch(ref RotationTable, TextureAnimations[i].RotationUFrames, RotationMultiplier);
                FindMatch(ref RotationTable, TextureAnimations[i].RotationVFrames, RotationMultiplier);
                FindMatch(ref RotationTable, TextureAnimations[i].RotationWFrames, RotationMultiplier);
                FindMatch(ref TranslationTable, TextureAnimations[i].TranslationUFrames, 1);
                FindMatch(ref TranslationTable, TextureAnimations[i].TranslationVFrames, 1);
                FindMatch(ref TranslationTable, TextureAnimations[i].TranslationWFrames, 1);
            }
            long ScaleTableOffset = BTKFile.Position;
            for (int i = 0; i < ScaleTable.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(ScaleTable[i]), 0, 4);
            }

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long RotationTableOffset = BTKFile.Position;
            for (int i = 0; i < RotationTable.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(RotationTable[i]), 0, 2);
            }

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 4 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            long TranslationTableOffset = BTKFile.Position;
            for (int i = 0; i < TranslationTable.Count; i++)
            {
                BTKFile.WriteReverse(BitConverter.GetBytes(TranslationTable[i]), 0, 4);
            }

            #region Padding
            PadCount = 0;
            while (BTKFile.Position % 32 != 0)
            {
                BTKFile.WriteByte((byte)Padding[PadCount++]);
            }
            #endregion

            BTKFile.Position = 0x08;
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)BTKFile.Length), 0, 4);
            BTKFile.Position = 0x24;
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(BTKFile.Length - 0x20)), 0, 4);
            BTKFile.Position = 0x2E;
            BTKFile.WriteReverse(BitConverter.GetBytes((ushort)ScaleTable.Count), 0, 2);
            BTKFile.WriteReverse(BitConverter.GetBytes((ushort)RotationTable.Count), 0, 2);
            BTKFile.WriteReverse(BitConverter.GetBytes((ushort)TranslationTable.Count), 0, 2);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(AnimationTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(RemapTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(StringTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(TexMapIDTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(CenterTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(ScaleTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(RotationTableOffset - 0x20)), 0, 4);
            BTKFile.WriteReverse(BitConverter.GetBytes((uint)(TranslationTableOffset - 0x20)), 0, 4);

            BTKFile.Seek(AnimationTableOffset, SeekOrigin.Begin);
            for (int i = 0; i < TextureAnimations.Count; i++)
            {
                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref ScaleTable, TextureAnimations[i].ScaleUFrames, 1)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref RotationTable, TextureAnimations[i].RotationUFrames, RotationMultiplier)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref TranslationTable, TextureAnimations[i].TranslationUFrames, 1)), 0, 2);
                BTKFile.Position += 2;


                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref ScaleTable, TextureAnimations[i].ScaleVFrames, 1)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref RotationTable, TextureAnimations[i].RotationVFrames, RotationMultiplier)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref TranslationTable, TextureAnimations[i].TranslationVFrames, 1)), 0, 2);
                BTKFile.Position += 2;


                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref ScaleTable, TextureAnimations[i].ScaleWFrames, 1)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref RotationTable, TextureAnimations[i].RotationWFrames, RotationMultiplier)), 0, 2);
                BTKFile.Position += 2;

                BTKFile.Position += 2;
                BTKFile.WriteReverse(BitConverter.GetBytes(FindMatch(ref TranslationTable, TextureAnimations[i].TranslationWFrames, 1)), 0, 2);
                BTKFile.Position += 2;
            }
        }
コード例 #23
0
 public void Write(Stream s)
 {
     s.WriteString(Version);
 }
コード例 #24
0
 public virtual bool SaveTo(Stream stream)
 {
     stream.WriteString(Name);
     return(true);
 }
コード例 #25
0
ファイル: NpgsqlCommand.cs プロジェクト: Tradioyes/Npgsql
        void AppendParameterValues(Stream dest)
        {
            var first = true;

            for (var i = 0; i < _parameters.Count; i++)
            {
                var parameter = _parameters[i];

                if (parameter.IsInputDirection)
                {
                    if (first)
                    {
                        first = false;
                    }
                    else
                    {
                        dest.WriteString(", ");
                    }

                    AppendParameterValue(dest, parameter);
                }
            }
        }
コード例 #26
0
ファイル: TableData.cs プロジェクト: RoadTrain/Mafia2Toolkit
        public void Serialize(ushort version, Stream input, Endian endian)
        {
            input.WriteValueU64(NameHash, endian);
            input.WriteStringU16(Name, endian);

            if (version >= 2)
            {
                input.WriteBytes(new byte[10]);
                input.WriteValueS32(-1);
                input.WriteValueS32(0);
            }

            input.WriteValueU16((ushort)Columns.Count, endian);
            input.WriteValueU32(Unk1, endian);
            input.WriteValueU32(Unk2, endian);
            input.WriteValueU32((uint)(Data.Length / Rows.Count));
            input.WriteValueU32((uint)Rows.Count);

            for (int i = 0; i < Rows.Count; i++)
            {
                for (int x = 0; x < Columns.Count; x++)
                {
                    Column column = Columns[x];
                    switch (column.Type)
                    {
                    case ColumnType.Boolean:
                        uint value = Convert.ToUInt32(Rows[i].Values[x]);
                        input.WriteValueU32(value);
                        break;

                    case ColumnType.Float32:
                        input.WriteValueF32((float)Rows[i].Values[x]);
                        break;

                    case ColumnType.Signed32:
                        input.WriteValueS32((int)Rows[i].Values[x]);
                        break;

                    case ColumnType.Unsigned32:
                        input.WriteValueU32((uint)Rows[i].Values[x]);
                        break;

                    case ColumnType.Flags32:
                        input.WriteValueU32((uint)Rows[i].Values[x]);
                        break;

                    case ColumnType.Hash64:
                        input.WriteValueU64((ulong)Rows[i].Values[x]);
                        break;

                    case ColumnType.String8:
                        input.WriteString(Rows[i].Values[x].ToString(), 8);
                        break;

                    case ColumnType.String16:
                        input.WriteString(Rows[i].Values[x].ToString(), 16);
                        break;

                    case ColumnType.String32:
                        input.WriteString(Rows[i].Values[x].ToString(), 32, System.Text.Encoding.GetEncoding(1250));
                        break;

                    case ColumnType.String64:
                        input.WriteString(Rows[i].Values[x].ToString(), 64);
                        break;

                    case ColumnType.Color:
                        string[] colors = (Rows[i].Values[x] as string).Split(new char[1] {
                            ' '
                        }, StringSplitOptions.RemoveEmptyEntries);
                        input.WriteValueF32(float.Parse(colors[0]));
                        input.WriteValueF32(float.Parse(colors[1]));
                        input.WriteValueF32(float.Parse(colors[2]));
                        break;

                    case ColumnType.Hash64AndString32:
                        string name = (string)Rows[i].Values[x];
                        ulong  hash = FNV64.Hash(name);
                        input.WriteValueU64(hash);
                        input.WriteString(Rows[i].Values[x].ToString(), 32);
                        break;

                    default:
                        throw new FormatException();
                        break;
                    }
                }
            }

            for (int i = 0; i < Columns.Count; i++)
            {
                Columns[i].Serialize(input, endian);
            }
        }
コード例 #27
0
ファイル: Request.cs プロジェクト: CoreTweet/CoreTweet
        private static void WriteMultipartFormData(Stream stream, string boundary, KeyValuePair<string, object>[] prm)
        {
            var items = prm.ConvertAll(x => MultipartItem.Create(x.Key, x.Value));

            // Start writing
            foreach(var x in items)
            {
                stream.WriteString("--" + boundary + "\r\n");
                x.WriteTo(stream);
                stream.WriteString("\r\n");
            }
            stream.WriteString("--" + boundary + "--");
        }
コード例 #28
0
        private void ListenWorker_DoWork(object sender, DoWorkEventArgs e)
        {
            // setup http listener.
            if (!HttpListener.IsSupported)
            {
                e.Result = "HttpListener is not supported on your OS.";
                return;
            }

            HttpListener http = new HttpListener();

            try
            {
                http.Prefixes.Add($"http://localhost:{SERVER_PORT}/");
                http.Start();
            }
            catch (Exception exc)
            {
                e.Result = exc.Message;
                return;
            }

            // make a pseudo random generator.
            Random rnd = new Random();

            rnd.Next();

            BackgroundWorker self = sender as BackgroundWorker;
            int counter           = 1;

            List <IPAddress> blocked   = new List <IPAddress>();
            List <string>    allIPs    = new List <string>();
            List <int>       gennedIDs = new List <int>();

            while (true)
            {
                // obtain responses and stuff.
                HttpListenerContext  context  = http.GetContext();
                HttpListenerRequest  request  = context.Request;
                HttpListenerResponse response = context.Response;
                Stream output = response.OutputStream;
                Stream input  = request.InputStream;

                response.ContentType     = "application/x-www-form-urlencoded";
                response.ContentEncoding = Encoding.UTF8;
                response.StatusCode      = (int)HttpStatusCode.OK;

                // if blocked ip is trying again...
                bool cont = false;
                foreach (var endpoint in blocked)
                {
                    if (endpoint.Equals(request.RemoteEndPoint.Address))
                    {
                        // update the RNG so it gets stronger.
                        rnd.Next();

                        Console.WriteLine("Blocked IP trying again huh... " + endpoint.ToString());
                        output.WriteString("status=success&reason=ok");
                        output.Close();
                        cont = true;
                        break;
                    }
                }
                if (cont)
                {
                    continue;
                }

                switch (request.Url.AbsolutePath)
                {
                case "/register":
                {
                    // get values.
                    var    nvc          = HttpUtility.ParseQueryString(input.ReadToEnd());
                    string employeename = nvc["username"];
                    string ipport       = nvc["ipport"];
                    string iponly       = ipport.Substring(0, ipport.IndexOf(':'));

                    bool stop = false;
                    foreach (string ip in allIPs)
                    {
                        if (iponly == ip)
                        {
                            // oh.
                            output.WriteString("status=denied&id=0");
                            output.Close();
                            stop = true;
                            Console.WriteLine("Access denied for " + ipport);
                            break;
                        }
                    }
                    if (stop)
                    {
                        continue;
                    }

                    Console.WriteLine("Adding " + iponly);
                    allIPs.Add(iponly);

                    // generate a totally unique random emp id.
                    int id  = 0;
                    int bob = 100;
                    do
                    {
                        Console.WriteLine("Generating employee id...");
                        id = bob + rnd.Next(bob, int.MaxValue / bob);
                    }while (gennedIDs.IndexOf(id) != -1);

                    gennedIDs.Add(id);

                    // construct info struct
                    EmployeeInfo info = new EmployeeInfo(counter, id, employeename, ipport);

                    // return response
                    output.WriteString("status=success&id=" + id.ToString());

                    // send it to the ProgressChanged method.
                    self.ReportProgress(0, info);
                    counter++;

                    break;
                }

                case "/updatetime":
                {
                    // update the RNG so it gets stronger.
                    rnd.Next();

                    // lol.
                    Console.WriteLine("Updating time...");

                    // parse client.
                    string query = input.ReadToEnd();
                    var    nvc   = HttpUtility.ParseQueryString(query);
                    if (nvc["time"] == "ABUSE")         // abuse detection worked.
                    {
                        blocked.Add(request.RemoteEndPoint.Address);
                        Console.WriteLine("ABUSE DETECTED! " + request.RemoteEndPoint.ToString());
                    }
                    else
                    {
                        int _newtime = -1, _empid = -1;
                        if (!int.TryParse(nvc["time"], out _newtime))
                        {
                            output.WriteString("status=failure&reason=InvalidTime");
                            output.Close();
                            continue;
                        }
                        else if (!int.TryParse(nvc["employeeid"], out _empid))
                        {
                            output.WriteString("status=failure&reason=InvalidEmployeeId");
                            output.Close();
                            continue;
                        }

                        output.WriteString("status=success&reason=ok");

                        // construct update struct.
                        UpdateInfo uinfo = new UpdateInfo(_newtime, _empid);

                        // report to UI
                        self.ReportProgress(1, uinfo);
                    }

                    // we're done.
                    output.WriteString("status=success&reason=ok");
                    break;
                }

                case "/leaderboard":
                {
                    Leaderboard lbret = (Leaderboard)MainListView.Invoke((Func <Leaderboard>) delegate
                        {
                            Leaderboard lb = new Leaderboard
                            {
                                employees = new Employee[MainListView.Items.Count]
                            };

                            int i = 0;
                            foreach (ListViewItem lvi in MainListView.Items)
                            {
                                if (lvi.SubItems[2].Text == "-1")
                                {
                                    continue;
                                }

                                lb.employees[i] = new Employee
                                {
                                    id        = lvi.Text,
                                    best_time = lvi.SubItems[2].Text
                                };
                                i++;
                            }

                            return(lb);
                        });

                    string lbstring    = JsonConvert.SerializeObject(lbret);
                    byte[] lbrawstring = Encoding.UTF8.GetBytes(lbstring);

                    response.ContentType     = "application/json";
                    response.ContentLength64 = lbrawstring.LongLength;
                    output.WriteString(lbstring);
                    break;
                }

                default:
                {
                    Console.WriteLine("Unsupported method, ignoring...");
                    break;
                }
                }

                output.Close();
            }
        }
コード例 #29
0
        private void WriteDataItems(Stream s, IList <TFString> strings, ExportOptions options)
        {
            var written = new Dictionary <int, long>();

            var stringOffset = 0x0E03E800;

            foreach (var tfString in strings)
            {
                var indexOffset = Convert.ToInt32(tfString.Section, 16);

                s.Seek(indexOffset, SeekOrigin.Begin);

                if (written.ContainsKey(tfString.Offset))
                {
                    s.WriteValueS64(written[tfString.Offset], Endianness);
                }
                else
                {
                    var correctedOffset = stringOffset + OUTPUT_BASE;

                    s.WriteValueS64(correctedOffset, Endianness);

                    s.Seek(stringOffset, SeekOrigin.Begin);

                    string   str;
                    Encoding enc;
                    bool     replaceChars;

                    if (tfString.Original == tfString.Translation)
                    {
                        str          = tfString.Original;
                        enc          = Encoding;
                        replaceChars = false;
                    }
                    else
                    {
                        str          = tfString.Translation;
                        enc          = options.SelectedEncoding;
                        replaceChars = options.CharReplacement != 0;
                    }

                    if (!string.IsNullOrEmpty(str))
                    {
                        if (replaceChars)
                        {
                            str = Utils.ReplaceChars(str, options.CharReplacementList);
                        }

                        str = Yakuza0Project.WritingReplacements(str);

                        s.WriteStringZ(str, enc);

                        stringOffset += str.GetLength(enc) + 1;
                    }
                    else
                    {
                        // Hay que escribir solo el 0 del final
                        s.WriteString("\0");
                        stringOffset++;
                    }

                    written.Add(tfString.Offset, correctedOffset);
                }
            }
        }
コード例 #30
0
        /// <summary>
        /// Append a region of a source command text to an output command, performing parameter token
        /// substitutions.
        /// </summary>
        /// <param name="dest">Stream to which to append output.</param>
        /// <param name="src">Command text.</param>
        /// <param name="begin">Starting index within src.</param>
        /// <param name="length">Length of region to be processed.</param>
        /// <param name="prepare"></param>
        /// <param name="forExtendedQuery"></param>
        private void AppendCommandReplacingParameterValues(Stream dest, string src, int begin, int length, bool prepare, bool forExtendedQuery)
        {
            char      lastChar      = '\0';
            TokenType currTokenType = TokenType.None;
            char      paramMarker   = '\0';
            int       currTokenBeg  = begin;
            int       currTokenLen  = 0;
            Dictionary <NpgsqlParameter, int> paramOrdinalMap = null;
            int end = begin + length;

            if (prepare)
            {
                paramOrdinalMap = new Dictionary <NpgsqlParameter, int>();

                for (int i = 0; i < parameters.Count; i++)
                {
                    paramOrdinalMap[parameters[i]] = i + 1;
                }
            }

            for (int currCharOfs = begin; currCharOfs < end; currCharOfs++)
            {
                char ch = src[currCharOfs];

                // goto label for character re-evaluation:
ProcessCharacter:

                switch (currTokenType)
                {
                case TokenType.None:
                    switch (ch)
                    {
                    case '\'':
                        if (currTokenLen > 0)
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                        }

                        currTokenType = TokenType.Quoted;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;

                        break;

                    case ':':
                        if (currTokenLen > 0)
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                        }

                        currTokenType = TokenType.Colon;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;

                        break;

                    case '<':
                    case '@':
                        if (currTokenLen > 0)
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                        }

                        currTokenType = TokenType.FullTextMatchOp;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;

                        break;

                    case '-':
                        if (currTokenLen > 0)
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                        }

                        currTokenType = TokenType.LineCommentBegin;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;

                        break;

                    case '/':
                        if (currTokenLen > 0)
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                        }

                        currTokenType = TokenType.BlockCommentBegin;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;

                        break;

                    default:
                        currTokenLen++;

                        break;
                    }

                    break;

                case TokenType.Param:
                    if (IsParamNameChar(ch))
                    {
                        currTokenLen++;
                    }
                    else
                    {
                        string          paramName = src.Substring(currTokenBeg, currTokenLen);
                        NpgsqlParameter parameter;
                        bool            wroteParam = false;

                        if (parameters.TryGetValue(paramName, out parameter))
                        {
                            if (
                                (parameter.Direction == ParameterDirection.Input) ||
                                (parameter.Direction == ParameterDirection.InputOutput)
                                )
                            {
                                if (prepare)
                                {
                                    AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                                }
                                else
                                {
                                    AppendParameterValue(dest, parameter);
                                }
                            }

                            wroteParam = true;
                        }

                        if (!wroteParam)
                        {
                            dest.WriteString("{0}{1}", paramMarker, paramName);
                        }

                        currTokenType = TokenType.None;
                        currTokenBeg  = currCharOfs;
                        currTokenLen  = 0;

                        // Re-evaluate this character
                        goto ProcessCharacter;
                    }

                    break;

                case TokenType.Quoted:
                    switch (ch)
                    {
                    case '\'':
                        currTokenLen++;

                        break;

                    default:
                        if (currTokenLen > 1 && lastChar == '\'')
                        {
                            dest.WriteString(src.Substring(currTokenBeg, currTokenLen));

                            currTokenType = TokenType.None;
                            currTokenBeg  = currCharOfs;
                            currTokenLen  = 0;

                            // Re-evaluate this character
                            goto ProcessCharacter;
                        }
                        else
                        {
                            currTokenLen++;
                        }

                        break;
                    }

                    break;

                case TokenType.LineComment:
                    if (ch == '\n')
                    {
                        currTokenType = TokenType.None;
                    }

                    currTokenLen++;

                    break;

                case TokenType.BlockComment:
                    if (ch == '*')
                    {
                        currTokenType = TokenType.BlockCommentEnd;
                    }

                    currTokenLen++;

                    break;

                case TokenType.Colon:
                    if (IsParamNameChar(ch))
                    {
                        // Switch to parameter name token, include this character.
                        currTokenType = TokenType.Param;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;
                        paramMarker  = ':';
                    }
                    else
                    {
                        // Demote to the unknown token type and continue.
                        currTokenType = TokenType.None;
                        currTokenLen++;
                    }

                    break;

                case TokenType.FullTextMatchOp:
                    if (lastChar == '@' && IsParamNameChar(ch))
                    {
                        // Switch to parameter name token, include this character.
                        currTokenType = TokenType.Param;

                        currTokenBeg = currCharOfs;
                        currTokenLen = 1;
                        paramMarker  = '@';
                    }
                    else
                    {
                        // Demote to the unknown token type.
                        currTokenType = TokenType.None;

                        // Re-evaluate this character
                        goto ProcessCharacter;
                    }

                    break;

                case TokenType.LineCommentBegin:
                    if (ch == '-')
                    {
                        currTokenType = TokenType.LineComment;
                        currTokenLen++;
                    }
                    else
                    {
                        // Demote to the unknown token type.
                        currTokenType = TokenType.None;

                        // Re-evaluate this character
                        goto ProcessCharacter;
                    }

                    break;

                case TokenType.BlockCommentBegin:
                    if (ch == '*')
                    {
                        currTokenType = TokenType.BlockComment;
                        currTokenLen++;
                    }
                    else
                    {
                        // Demote to the unknown token type.
                        currTokenType = TokenType.None;

                        // Re-evaluate this character
                        goto ProcessCharacter;
                    }

                    break;

                case TokenType.BlockCommentEnd:
                    if (ch == '/')
                    {
                        currTokenType = TokenType.None;
                        currTokenLen++;
                    }
                    else
                    {
                        currTokenType = TokenType.BlockComment;
                        currTokenLen++;
                    }

                    break;
                }

                lastChar = ch;
            }

            switch (currTokenType)
            {
            case TokenType.Param:
                string          paramName = src.Substring(currTokenBeg, currTokenLen);
                NpgsqlParameter parameter;
                bool            wroteParam = false;

                if (parameters.TryGetValue(paramName, out parameter))
                {
                    if (
                        (parameter.Direction == ParameterDirection.Input) ||
                        (parameter.Direction == ParameterDirection.InputOutput)
                        )
                    {
                        if (prepare)
                        {
                            AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                        }
                        else
                        {
                            AppendParameterValue(dest, parameter);
                        }
                    }

                    wroteParam = true;
                }

                if (!wroteParam)
                {
                    dest.WriteString("{0}{1}", paramMarker, paramName);
                }

                break;

            default:
                if (currTokenLen > 0)
                {
                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                }

                break;
            }
        }
コード例 #31
0
 internal override void Write(Stream writer)
 {
     writer.WriteString((String)_val);
 }
コード例 #32
0
ファイル: DisconnectMsg.cs プロジェクト: znova/TShock
 public override void Pack(Stream stream)
 {
     stream.WriteString(Reason);
 }
コード例 #33
0
 public override async Task Encode()
 {
     await Stream.WriteString(Reason);
 }
コード例 #34
0
        /// <summary>
        /// Append a region of a source command text to an output command, performing parameter token
        /// substitutions.
        /// </summary>
        /// <param name="dest">Stream to which to append output.</param>
        /// <param name="src">Command text.</param>
        /// <param name="prepare"></param>
        /// <param name="allowMultipleStatements"></param>
        /// <returns>false if the query has multiple statements which are not allowed</returns>
        private bool AppendCommandReplacingParameterValues(Stream dest, string src, bool prepare, bool allowMultipleStatements)
        {
            bool standardConformantStrings = connection != null && connection.Connector != null && connection.Connector.IsInitialized ? connection.UseConformantStrings : true;

            int  currCharOfs       = 0;
            int  end               = src.Length;
            char ch                = '\0';
            char lastChar          = '\0';
            int  dollarTagStart    = 0;
            int  dollarTagEnd      = 0;
            int  currTokenBeg      = 0;
            int  blockCommentLevel = 0;

            Dictionary <NpgsqlParameter, int> paramOrdinalMap = null;

            if (prepare)
            {
                paramOrdinalMap = new Dictionary <NpgsqlParameter, int>();

                for (int i = 0; i < parameters.Count; i++)
                {
                    paramOrdinalMap[parameters[i]] = i + 1;
                }
            }

            if (allowMultipleStatements && parameters.Count == 0)
            {
                dest.WriteString(src);
                return(true);
            }

None:
            if (currCharOfs >= end)
            {
                goto Finish;
            }
            lastChar = ch;
            ch       = src[currCharOfs++];
NoneContinue:
            for (; ; lastChar = ch, ch = src[currCharOfs++])
            {
                switch (ch)
                {
                case '/':                                           goto BlockCommentBegin;

                case '-':                                           goto LineCommentBegin;

                case '\'': if (standardConformantStrings)
                    {
                        goto Quoted;
                    }
                    else
                    {
                        goto Escaped;
                    }

                case '$':  if (!IsIdentifier(lastChar))
                    {
                        goto DollarQuotedStart;
                    }
                    else
                    {
                        break;
                    }

                case '"':                                           goto DoubleQuoted;

                case ':':  if (lastChar != ':')
                    {
                        goto ParamStart;
                    }
                    else
                    {
                        break;
                    }

                case '@':  if (lastChar != '@')
                    {
                        goto ParamStart;
                    }
                    else
                    {
                        break;
                    }

                case ';':  if (!allowMultipleStatements)
                    {
                        goto SemiColon;
                    }
                    else
                    {
                        break;
                    }

                case 'e':
                case 'E':  if (!IsLetter(lastChar))
                    {
                        goto EscapedStart;
                    }
                    else
                    {
                        break;
                    }
                }

                if (currCharOfs >= end)
                {
                    goto Finish;
                }
            }

ParamStart:
            if (currCharOfs < end)
            {
                lastChar = ch;
                ch       = src[currCharOfs];
                if (IsParamNameChar(ch))
                {
                    if (currCharOfs - 1 > currTokenBeg)
                    {
                        dest.WriteString(src.Substring(currTokenBeg, currCharOfs - 1 - currTokenBeg));
                    }
                    currTokenBeg = currCharOfs++ - 1;
                    goto Param;
                }
                else
                {
                    currCharOfs++;
                    goto NoneContinue;
                }
            }
            goto Finish;

Param:
            // We have already at least one character of the param name
            for (; ;)
            {
                lastChar = ch;
                if (currCharOfs >= end || !IsParamNameChar(ch = src[currCharOfs]))
                {
                    string          paramName = src.Substring(currTokenBeg, currCharOfs - currTokenBeg);
                    NpgsqlParameter parameter;

                    if (parameters.TryGetValue(paramName, out parameter))
                    {
                        if (parameter.Direction == ParameterDirection.Input || parameter.Direction == ParameterDirection.InputOutput)
                        {
                            if (prepare)
                            {
                                AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                            }
                            else
                            {
                                AppendParameterValue(dest, parameter);
                            }
                            currTokenBeg = currCharOfs;
                        }
                    }

                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }

                    currCharOfs++;
                    goto NoneContinue;
                }
                else
                {
                    currCharOfs++;
                }
            }

Quoted:
            while (currCharOfs < end)
            {
                if (src[currCharOfs++] == '\'')
                {
                    ch = '\0';
                    goto None;
                }
            }
            goto Finish;

DoubleQuoted:
            while (currCharOfs < end)
            {
                if (src[currCharOfs++] == '"')
                {
                    ch = '\0';
                    goto None;
                }
            }
            goto Finish;

EscapedStart:
            if (currCharOfs < end)
            {
                lastChar = ch;
                ch       = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto Escaped;
                }
                goto NoneContinue;
            }
            goto Finish;

Escaped:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto MaybeConcatenatedEscaped;
                }
                if (ch == '\\')
                {
                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }
                    currCharOfs++;
                }
            }
            goto Finish;

MaybeConcatenatedEscaped:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto MaybeConcatenatedEscaped2;
                }
                if (ch != ' ' && ch != '\t' && ch != '\f')
                {
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

MaybeConcatenatedEscaped2:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto Escaped;
                }
                if (ch == '-')
                {
                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }
                    ch = src[currCharOfs++];
                    if (ch == '-')
                    {
                        goto MaybeConcatenatedEscapeAfterComment;
                    }
                    lastChar = '\0';
                    goto NoneContinue;
                }
                if (ch != ' ' && ch != '\t' && ch != '\n' & ch != '\r' && ch != '\f')
                {
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

MaybeConcatenatedEscapeAfterComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto MaybeConcatenatedEscaped2;
                }
            }
            goto Finish;

DollarQuotedStart:
            if (currCharOfs < end)
            {
                ch = src[currCharOfs];
                if (ch == '$')
                {
                    // Empty tag
                    dollarTagStart = dollarTagEnd = currCharOfs;
                    currCharOfs++;
                    goto DollarQuoted;
                }
                if (IsIdentifierStart(ch))
                {
                    dollarTagStart = currCharOfs;
                    currCharOfs++;
                    goto DollarQuotedInFirstDelim;
                }
                lastChar = '$';
                currCharOfs++;
                goto NoneContinue;
            }
            goto Finish;

DollarQuotedInFirstDelim:
            while (currCharOfs < end)
            {
                lastChar = ch;
                ch       = src[currCharOfs++];
                if (ch == '$')
                {
                    dollarTagEnd = currCharOfs - 1;
                    goto DollarQuoted;
                }
                if (!IsDollarTagIdentifier(ch))
                {
                    goto NoneContinue;
                }
            }
            goto Finish;

DollarQuoted:
            {
                string tag = src.Substring(dollarTagStart - 1, dollarTagEnd - dollarTagStart + 2);
                int    pos = src.IndexOf(tag, dollarTagEnd + 1); // Not linear time complexity, but that's probably not a problem, since PostgreSQL backend's isn't either
                if (pos == -1)
                {
                    currCharOfs = end;
                    goto Finish;
                }
                currCharOfs = pos + dollarTagEnd - dollarTagStart + 2;
                ch          = '\0';
                goto None;
            }

LineCommentBegin:
            if (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '-')
                {
                    goto LineComment;
                }
                lastChar = '\0';
                goto NoneContinue;
            }
            goto Finish;

LineComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto None;
                }
            }
            goto Finish;

BlockCommentBegin:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '*')
                {
                    blockCommentLevel++;
                    goto BlockComment;
                }
                if (ch != '/')
                {
                    if (blockCommentLevel > 0)
                    {
                        goto BlockComment;
                    }
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

BlockComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '*')
                {
                    goto BlockCommentEnd;
                }
                if (ch == '/')
                {
                    goto BlockCommentBegin;
                }
            }
            goto Finish;

BlockCommentEnd:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '/')
                {
                    if (--blockCommentLevel > 0)
                    {
                        goto BlockComment;
                    }
                    goto None;
                }
                if (ch != '*')
                {
                    goto BlockComment;
                }
            }
            goto Finish;

SemiColon:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch != ' ' && ch != '\t' && ch != '\n' & ch != '\r' && ch != '\f') // We don't check for comments after the last ; yet
                {
                    return(false);
                }
            }
            // implicit goto Finish

Finish:
            dest.WriteString(src.Substring(currTokenBeg, end - currTokenBeg));
            return(true);
        }
コード例 #35
0
ファイル: CementFile.cs プロジェクト: Zcor3x/Edit3D
        public void Serialize(Stream output)
        {
            var endian = this.Endian;

            output.WriteString("ATG CORE CEMENT LIBRARY", 24, Encoding.ASCII);
            output.Seek(8, SeekOrigin.Current);

            output.WriteValueU8(2); // majorVersion
            output.WriteValueU8(1); // minorVersion

            switch (endian)
            {
            case Endian.Little:
            {
                output.WriteValueB8(false);
                break;
            }

            case Endian.Big:
            {
                output.WriteValueB8(true);
                break;
            }

            default:
            {
                throw new InvalidOperationException("unsupported endian");
            }
            }

            output.WriteValueU8(1); // unknown1

            var offset = 0x3C;

            var indexSize = this.EstimateEntryTableSize();

            output.WriteValueS32(offset, endian);    // indexOffset
            output.WriteValueS32(indexSize, endian); // indexSize
            offset += indexSize;
            offset  = offset.Align(2048);

            var metadataSize = this.EstimateMetadataTableSize();

            output.WriteValueS32(offset, endian);       // metadataOffset
            output.WriteValueS32(metadataSize, endian); // metadataSize
            //offset += metadataSize;

            output.WriteValueU32(0, endian);                  // unknown2
            output.WriteValueS32(this.Entries.Count, endian); // entryCount

            foreach (var entry in this.Entries)
            {
                entry.Serialize(output, endian);
            }

            output.Seek(output.Position.Align(2048), SeekOrigin.Begin);

            output.WriteValueU32(2048, Endian.Little);
            output.WriteValueU32(0, Endian.Little);
            foreach (var metadata in this.Metadatas)
            {
                metadata.Serialize(output, endian);
            }

            output.Seek(output.Position.Align(2048), SeekOrigin.Begin);
        }
コード例 #36
0
 public void Write(Stream writer)
 {
     writer.WriteString(FilePath);
 }
コード例 #37
0
ファイル: FastPacker.cs プロジェクト: FPCollab/General
 public static void Write(object obj, Stream stream)
 {
     stream.WriteString((string)obj);
 }
コード例 #38
0
 public override void OnString(string obj)
 {
     Stream.WriteVarUInt32((uint)obj.Length + 1);//include '\0'
     Stream.WriteString(obj);
 }
コード例 #39
0
        public override void RenderCommand(Stream stream)
        {
            foreach (var fc in FileCommands.OfType<FileModifyCommand>())
            {
                if (fc.Blob != null)
                    stream.RenderCommand(fc.Blob);
            }

            stream.WriteLine(string.Format("commit {0}", Reference));
            base.RenderMarkCommand(stream);

            if (Author != null)
                stream.RenderCommand(Author);
            stream.RenderCommand(Committer);
            stream.RenderCommand(CommitInfo);

            if (FromCommit != null)
            {
                stream.WriteString("from ");
                FromCommit.RenderMarkReference(stream);
                stream.WriteLineFeed();
            }

            foreach (var mc in MergeCommits)
            {
                stream.WriteString("merge ");
                mc.RenderMarkReference(stream);
                stream.WriteLineFeed();
            }

            foreach (var fc in FileCommands)
                stream.RenderCommand(fc);
            stream.WriteLineFeed();
        }
コード例 #40
0
ファイル: MultipartItem.cs プロジェクト: CoreTweet/CoreTweet
 public override void WriteTo(Stream stream)
 {
     stream.WriteString("Content-Type: application/octet-stream\r\n");
     stream.WriteString(string.Format("Content-Disposition: form-data; name=\"{0}\"; filename=\"{1}\"\r\n\r\n",
         this.Key,
         this.FileName != null
             ? this.FileName.Replace("\n", "%0A").Replace("\r", "%0D").Replace("\"", "%22")
             : "file"
     ));
     this.WriteContent(stream);
 }
コード例 #41
0
ファイル: NpgsqlCommand.cs プロジェクト: Tradioyes/Npgsql
        void AppendParameterPlaceHolder(Stream dest, NpgsqlParameter parameter, int paramNumber)
        {
            dest.WriteByte((byte)ASCIIBytes.ParenLeft);

            if (parameter.UseCast && parameter.Size > 0)
            {
                dest.WriteString("${0}::{1}", paramNumber, parameter.TypeInfo.GetCastName(parameter.Size));
            }
            else
            {
                dest.WriteString("$" + paramNumber);
            }

            dest.WriteByte((byte)ASCIIBytes.ParenRight);
        }
コード例 #42
0
        private void AddFunctionColumnListSupport(Stream st)
        {
            bool isFirstOutputOrInputOutput = true;

            PGUtil.WriteString(st, " AS (");

            for (int i = 0 ; i < Parameters.Count ; i++)
            {
                var p = Parameters[i];

                switch(p.Direction)
                {
                    case ParameterDirection.Output: case ParameterDirection.InputOutput:
                        if (isFirstOutputOrInputOutput)
                        {
                            isFirstOutputOrInputOutput = false;
                        }
                        else
                        {
                            st.WriteString(", ");
                        }

                        st
                            .WriteString(p.CleanName)
                            .WriteBytes((byte)ASCIIBytes.Space)
                            .WriteString(p.TypeInfo.Name);

                        break;
                }
            }

            st.WriteByte((byte)ASCIIBytes.ParenRight);
        }
コード例 #43
0
        /// <summary>
        /// Append a region of a source command text to an output command, performing parameter token
        /// substitutions.
        /// </summary>
        /// <param name="dest">Stream to which to append output.</param>
        /// <param name="src">Command text.</param>
        /// <param name="begin">Starting index within src.</param>
        /// <param name="length">Length of region to be processed.</param>
        /// <param name="prepare"></param>
        /// <param name="forExtendedQuery"></param>
        private void AppendCommandReplacingParameterValues(Stream dest, string src, int begin, int length, bool prepare, bool forExtendedQuery)
        {
            char lastChar = '\0';
            TokenType currTokenType = TokenType.None;
            char paramMarker = '\0';
            int currTokenBeg = begin;
            int currTokenLen = 0;
            Dictionary<NpgsqlParameter, int> paramOrdinalMap = null;
            int end = begin + length;

            if (prepare)
            {
                paramOrdinalMap = new Dictionary<NpgsqlParameter, int>();

                for (int i = 0 ; i < parameters.Count ; i++)
                {
                    paramOrdinalMap[parameters[i]] = i + 1;
                }
            }

            for (int currCharOfs = begin ; currCharOfs < end ; currCharOfs++)
            {
                char ch = src[currCharOfs];

                // goto label for character re-evaluation:
                ProcessCharacter:

                switch (currTokenType)
                {
                    case TokenType.None :
                        switch (ch)
                        {
                            case '\'' :
                                if (currTokenLen > 0)
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                                }

                                currTokenType = TokenType.Quoted;

                                currTokenBeg = currCharOfs;
                                currTokenLen = 1;

                                break;

                            case ':' :
                                if (currTokenLen > 0)
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                                }

                                currTokenType = TokenType.Colon;

                                currTokenBeg = currCharOfs;
                                currTokenLen = 1;

                                break;

                            case '<' :
                            case '@' :
                                if (currTokenLen > 0)
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                                }

                                currTokenType = TokenType.FullTextMatchOp;

                                currTokenBeg = currCharOfs;
                                currTokenLen = 1;

                                break;

                            case '-' :
                                if (currTokenLen > 0)
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                                }

                                currTokenType = TokenType.LineCommentBegin;

                                currTokenBeg = currCharOfs;
                                currTokenLen = 1;

                                break;

                            case '/' :
                                if (currTokenLen > 0)
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                                }

                                currTokenType = TokenType.BlockCommentBegin;

                                currTokenBeg = currCharOfs;
                                currTokenLen = 1;

                                break;

                            default :
                                currTokenLen++;

                                break;

                        }

                        break;

                    case TokenType.Param :
                        if (IsParamNameChar(ch))
                        {
                            currTokenLen++;
                        }
                        else
                        {
                            string paramName = src.Substring(currTokenBeg, currTokenLen);
                            NpgsqlParameter parameter;
                            bool wroteParam = false;

                            if (parameters.TryGetValue(paramName, out parameter))
                            {
                                if (
                                    (parameter.Direction == ParameterDirection.Input) ||
                                    (parameter.Direction == ParameterDirection.InputOutput)
                                )
                                {
                                    if (prepare)
                                    {
                                        AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                                    }
                                    else
                                    {
                                        AppendParameterValue(dest, parameter);
                                    }
                                }

                                wroteParam = true;
                            }

                            if (! wroteParam)
                            {
                                dest.WriteString("{0}{1}", paramMarker, paramName);
                            }

                            currTokenType = TokenType.None;
                            currTokenBeg = currCharOfs;
                            currTokenLen = 0;

                            // Re-evaluate this character
                            goto ProcessCharacter;
                        }

                        break;

                    case TokenType.Quoted :
                        switch (ch)
                        {
                            case '\'' :
                                currTokenLen++;

                                break;

                            default :
                                if (currTokenLen > 1 && lastChar == '\'')
                                {
                                    dest.WriteString(src.Substring(currTokenBeg, currTokenLen));

                                    currTokenType = TokenType.None;
                                    currTokenBeg = currCharOfs;
                                    currTokenLen = 0;

                                    // Re-evaluate this character
                                    goto ProcessCharacter;
                                }
                                else
                                {
                                    currTokenLen++;
                                }

                                break;

                        }

                        break;

                    case TokenType.LineComment :
                        if (ch == '\n')
                        {
                            currTokenType = TokenType.None;
                        }

                        currTokenLen++;

                        break;

                    case TokenType.BlockComment :
                        if (ch == '*')
                        {
                            currTokenType = TokenType.BlockCommentEnd;
                        }

                        currTokenLen++;

                        break;

                    case TokenType.Colon :
                        if (IsParamNameChar(ch))
                        {
                            // Switch to parameter name token, include this character.
                            currTokenType = TokenType.Param;

                            currTokenBeg = currCharOfs;
                            currTokenLen = 1;
                            paramMarker = ':';
                        }
                        else
                        {
                            // Demote to the unknown token type and continue.
                            currTokenType = TokenType.None;
                            currTokenLen++;
                        }

                        break;

                    case TokenType.FullTextMatchOp :
                        if (lastChar == '@' && IsParamNameChar(ch))
                        {
                            // Switch to parameter name token, include this character.
                            currTokenType = TokenType.Param;

                            currTokenBeg = currCharOfs;
                            currTokenLen = 1;
                            paramMarker = '@';
                        }
                        else
                        {
                            // Demote to the unknown token type.
                            currTokenType = TokenType.None;

                            // Re-evaluate this character
                            goto ProcessCharacter;
                        }

                        break;

                    case TokenType.LineCommentBegin :
                        if (ch == '-')
                        {
                            currTokenType = TokenType.LineComment;
                            currTokenLen++;
                        }
                        else
                        {
                            // Demote to the unknown token type.
                            currTokenType = TokenType.None;

                            // Re-evaluate this character
                            goto ProcessCharacter;
                        }

                        break;

                    case TokenType.BlockCommentBegin :
                        if (ch == '*')
                        {
                            currTokenType = TokenType.BlockComment;
                            currTokenLen++;
                        }
                        else
                        {
                            // Demote to the unknown token type.
                            currTokenType = TokenType.None;

                            // Re-evaluate this character
                            goto ProcessCharacter;
                        }

                        break;

                    case TokenType.BlockCommentEnd :
                        if (ch == '/')
                        {
                            currTokenType = TokenType.None;
                            currTokenLen++;
                        }
                        else
                        {
                            currTokenType = TokenType.BlockComment;
                            currTokenLen++;
                        }

                        break;

                }

                lastChar = ch;
            }

            switch (currTokenType)
            {
                case TokenType.Param :
                    string paramName = src.Substring(currTokenBeg, currTokenLen);
                    NpgsqlParameter parameter;
                    bool wroteParam = false;

                    if (parameters.TryGetValue(paramName, out parameter))
                    {
                        if (
                            (parameter.Direction == ParameterDirection.Input) ||
                            (parameter.Direction == ParameterDirection.InputOutput)
                        )
                        {
                            if (prepare)
                            {
                                AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                            }
                            else
                            {
                                AppendParameterValue(dest, parameter);
                            }
                        }

                        wroteParam = true;
                    }

                    if (! wroteParam)
                    {
                        dest.WriteString("{0}{1}", paramMarker, paramName);
                    }

                    break;

                default :
                    if (currTokenLen > 0)
                    {
                        dest.WriteString(src.Substring(currTokenBeg, currTokenLen));
                    }

                    break;

            }
        }
コード例 #44
0
        private void AppendParameterValues(Stream dest)
        {
            bool first = true;

            for (int i = 0 ; i < parameters.Count ; i++)
            {
                NpgsqlParameter parameter = parameters[i];

                if (
                    (parameter.Direction == ParameterDirection.Input) ||
                    (parameter.Direction == ParameterDirection.InputOutput)
                )
                {
                    if (first)
                    {
                        first = false;
                    }
                    else
                    {
                        dest.WriteString(", ");
                    }

                    AppendParameterValue(dest, parameter);
                }
            }
        }
コード例 #45
0
ファイル: JRemoteProcess.cs プロジェクト: borota/JTVS
        /// <summary>
        /// Performs the initial handshake with the remote debugging server, verifying signature and version number and setting up SSL,
        /// and returns the opened socket and the SSL stream for that socket.
        /// </summary>
        /// <param name="hostName">Name of the host to connect to.</param>
        /// <param name="portNumber">Port number to connect to.</param>
        /// <param name="secret">Secret to authenticate with.</param>
        /// <param name="useSsl">Whether to use SSL for this connection.</param>
        /// <param name="sslErrorHandling">If using SSL, specifies how SSL certificate errors should be handled.</param>
        /// <param name="socket">Opened socket to the remote debugging server. The returned socket is owned by <paramref name="stream"/>.</param>
        /// <param name="stream">Opened SSL network stream to the remote debugging server. This stream owns the <paramref name="socket"/>, and will automatically close it.</param>
        /// <returns>Error code.</returns>
        /// <remarks><paramref name="socket"/> should not be used to send or receive data, since it is wrapped in a stream, and is owned by that stream.
        /// It is exposed solely to enable querying it for endpoint information and connectivity status.</remarks>
        public static ConnErrorMessages TryConnect(string hostName, ushort portNumber, string secret, bool useSsl, SslErrorHandling sslErrorHandling, out Socket socket, out Stream stream)
        {
            stream = null;
            socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            bool connected = false;
            try {
                socket.Connect(hostName, portNumber);
                var rawStream = new NetworkStream(socket, ownsSocket: true);
                if (useSsl) {
                    var sslStream = new SslStream(rawStream, false, (sender, cert, chain, errs) => {
                        if (errs == SslPolicyErrors.None || sslErrorHandling == SslErrorHandling.Ignore) {
                            return true;
                        } else if (sslErrorHandling == SslErrorHandling.Fail) {
                            return false;
                        }

                        string errText = string.Format("Could not establish secure connection to {0}:{1} because of the following SSL issues:\n\n", hostName, portNumber);
                        if ((errs & SslPolicyErrors.RemoteCertificateNotAvailable) != 0) {
                            errText += "- no remote certificate provided\n";
                        }
                        if ((errs & SslPolicyErrors.RemoteCertificateNameMismatch) != 0) {
                            errText += "- remote certificate name does not match hostname\n";
                        }
                        if ((errs & SslPolicyErrors.RemoteCertificateChainErrors) != 0) {
                            errText += "- remote certificate is not trusted\n";
                        }

                        errText += "\nConnect anyway?";

                        var dlgRes = MessageBox.Show(errText, null, MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                        return dlgRes == DialogResult.Yes;
                    });
                    try {
                        sslStream.AuthenticateAsClient(hostName);
                    } catch (AuthenticationException) {
                        return ConnErrorMessages.RemoteSslError;
                    }
                    stream = sslStream;
                } else {
                    stream = rawStream;
                }

                var buf = new byte[8];
                int bufLen = stream.Read(buf, 0, DebuggerSignature.Length);
                string sig = Encoding.ASCII.GetString(buf, 0, bufLen);
                if (sig != DebuggerSignature) {
                    return ConnErrorMessages.RemoteUnsupportedServer;
                }

                long ver = stream.ReadInt64();
                if (ver != DebuggerProtocolVersion) {
                    return ConnErrorMessages.RemoteUnsupportedServer;
                }

                stream.Write(DebuggerSignatureBytes);
                stream.WriteInt64(DebuggerProtocolVersion);

                stream.WriteString(secret);
                bufLen = stream.Read(buf, 0, Accepted.Length);
                string secretResp = Encoding.ASCII.GetString(buf, 0, bufLen);
                if (secretResp != Accepted) {
                    return ConnErrorMessages.RemoteSecretMismatch;
                }

                connected = true;
            } catch (IOException) {
                return ConnErrorMessages.RemoteNetworkError;
            } catch (SocketException) {
                return ConnErrorMessages.RemoteNetworkError;
            } finally {
                if (!connected) {
                    if (stream != null) {
                        stream.Close();
                    }
                    socket.Close();
                    socket = null;
                    stream = null;
                }
            }

            return ConnErrorMessages.None;
        }
コード例 #46
0
        /// <summary>
        /// Append a region of a source command text to an output command, performing parameter token
        /// substitutions.
        /// </summary>
        /// <param name="dest">Stream to which to append output.</param>
        /// <param name="src">Command text.</param>
        /// <param name="prepare"></param>
        /// <param name="allowMultipleStatements"></param>
        /// <returns>false if the query has multiple statements which are not allowed</returns>
        private bool AppendCommandReplacingParameterValues(Stream dest, string src, bool prepare, bool allowMultipleStatements)
        {
            bool standardConformantStrings = connection != null && connection.Connector != null && connection.Connector.IsInitialized ? connection.UseConformantStrings : true;

            int currCharOfs = 0;
            int end = src.Length;
            char ch = '\0';
            char lastChar = '\0';
            int dollarTagStart = 0;
            int dollarTagEnd = 0;
            int currTokenBeg = 0;
            int blockCommentLevel = 0;

            Dictionary<NpgsqlParameter, int> paramOrdinalMap = null;

            if (prepare)
            {
                paramOrdinalMap = new Dictionary<NpgsqlParameter, int>();

                for (int i = 0 ; i < parameters.Count ; i++)
                {
                    paramOrdinalMap[parameters[i]] = i + 1;
                }
            }

            if (allowMultipleStatements && parameters.Count == 0)
            {
                dest.WriteString(src);
                return true;
            }

        None:
            if (currCharOfs >= end)
            {
                goto Finish;
            }
            lastChar = ch;
            ch = src[currCharOfs++];
        NoneContinue:
            for (; ; lastChar = ch, ch = src[currCharOfs++])
            {
                switch (ch)
                {
                    case '/':                                           goto BlockCommentBegin;
                    case '-':                                           goto LineCommentBegin;
                    case '\'': if (standardConformantStrings)           goto Quoted;                else goto Escaped;
                    case '$':  if (!IsIdentifier(lastChar))             goto DollarQuotedStart;     else break;
                    case '"':                                           goto DoubleQuoted;
                    case ':':  if (lastChar != ':')                     goto ParamStart;            else break;
                    case '@':  if (lastChar != '@')                     goto ParamStart;            else break;
                    case ';':  if (!allowMultipleStatements)            goto SemiColon;             else break;

                    case 'e':
                    case 'E':  if (!IsLetter(lastChar))                 goto EscapedStart;          else break;
                }

                if (currCharOfs >= end)
                {
                    goto Finish;
                }
            }
            
        ParamStart:
            if (currCharOfs < end)
            {
                lastChar = ch;
                ch = src[currCharOfs];
                if (IsParamNameChar(ch))
                {
                    if (currCharOfs - 1 > currTokenBeg)
                    {
                        dest.WriteString(src.Substring(currTokenBeg, currCharOfs - 1 - currTokenBeg));
                    }
                    currTokenBeg = currCharOfs++ - 1;
                    goto Param;
                }
                else
                {
                    currCharOfs++;
                    goto NoneContinue;
                }
            }
            goto Finish;

        Param:
            // We have already at least one character of the param name
            for (; ; )
            {
                lastChar = ch;
                if (currCharOfs >= end || !IsParamNameChar(ch = src[currCharOfs]))
                {
                    string paramName = src.Substring(currTokenBeg, currCharOfs - currTokenBeg);
                    NpgsqlParameter parameter;

                    if (parameters.TryGetValue(paramName, out parameter))
                    {
                        if (parameter.Direction == ParameterDirection.Input || parameter.Direction == ParameterDirection.InputOutput)
                        {
                            if (prepare)
                            {
                                AppendParameterPlaceHolder(dest, parameter, paramOrdinalMap[parameter]);
                            }
                            else
                            {
                                AppendParameterValue(dest, parameter);
                            }
                            currTokenBeg = currCharOfs;
                        }
                    }

                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }

                    currCharOfs++;
                    goto NoneContinue;
                }
                else
                {
                    currCharOfs++;
                }
            }

        Quoted:
            while (currCharOfs < end)
            {
                if (src[currCharOfs++] == '\'')
                {
                    ch = '\0';
                    goto None;
                }
            }
            goto Finish;

        DoubleQuoted:
            while (currCharOfs < end)
            {
                if (src[currCharOfs++] == '"')
                {
                    ch = '\0';
                    goto None;
                }
            }
            goto Finish;

        EscapedStart:
            if (currCharOfs < end)
            {
                lastChar = ch;
                ch = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto Escaped;
                }
                goto NoneContinue;
            }
            goto Finish;

        Escaped:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto MaybeConcatenatedEscaped;
                }
                if (ch == '\\')
                {
                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }
                    currCharOfs++;
                }
            }
            goto Finish;

        MaybeConcatenatedEscaped:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto MaybeConcatenatedEscaped2;
                }
                if (ch != ' ' && ch != '\t' && ch != '\f')
                {
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

        MaybeConcatenatedEscaped2:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\'')
                {
                    goto Escaped;
                }
                if (ch == '-')
                {
                    if (currCharOfs >= end)
                    {
                        goto Finish;
                    }
                    ch = src[currCharOfs++];
                    if (ch == '-')
                    {
                        goto MaybeConcatenatedEscapeAfterComment;
                    }
                    lastChar = '\0';
                    goto NoneContinue;

                }
                if (ch != ' ' && ch != '\t' && ch != '\n' & ch != '\r' && ch != '\f')
                {
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

        MaybeConcatenatedEscapeAfterComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto MaybeConcatenatedEscaped2;
                }
            }
            goto Finish;

        DollarQuotedStart:
            if (currCharOfs < end)
            {
                ch = src[currCharOfs];
                if (ch == '$')
                {
                    // Empty tag
                    dollarTagStart = dollarTagEnd = currCharOfs;
                    currCharOfs++;
                    goto DollarQuoted;
                }
                if (IsIdentifierStart(ch))
                {
                    dollarTagStart = currCharOfs;
                    currCharOfs++;
                    goto DollarQuotedInFirstDelim;
                }
                lastChar = '$';
                currCharOfs++;
                goto NoneContinue;
            }
            goto Finish;

        DollarQuotedInFirstDelim:
            while (currCharOfs < end)
            {
                lastChar = ch;
                ch = src[currCharOfs++];
                if (ch == '$')
                {
                    dollarTagEnd = currCharOfs - 1;
                    goto DollarQuoted;
                }
                if (!IsDollarTagIdentifier(ch))
                {
                    goto NoneContinue;
                }
            }
            goto Finish;

        DollarQuoted:
            {
                string tag = src.Substring(dollarTagStart - 1, dollarTagEnd - dollarTagStart + 2);
                int pos = src.IndexOf(tag, dollarTagEnd + 1); // Not linear time complexity, but that's probably not a problem, since PostgreSQL backend's isn't either
                if (pos == -1)
                {
                    currCharOfs = end;
                    goto Finish;
                }
                currCharOfs = pos + dollarTagEnd - dollarTagStart + 2;
                ch = '\0';
                goto None;
            }

        LineCommentBegin:
            if (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '-')
                {
                    goto LineComment;
                }
                lastChar = '\0';
                goto NoneContinue;
            }
            goto Finish;

        LineComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '\r' || ch == '\n')
                {
                    goto None;
                }
            }
            goto Finish;

        BlockCommentBegin:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '*')
                {
                    blockCommentLevel++;
                    goto BlockComment;
                }
                if (ch != '/')
                {
                    if (blockCommentLevel > 0)
                    {
                        goto BlockComment;
                    }
                    lastChar = '\0';
                    goto NoneContinue;
                }
            }
            goto Finish;

        BlockComment:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '*')
                {
                    goto BlockCommentEnd;
                }
                if (ch == '/')
                {
                    goto BlockCommentBegin;
                }
            }
            goto Finish;

        BlockCommentEnd:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch == '/')
                {
                    if (--blockCommentLevel > 0)
                    {
                        goto BlockComment;
                    }
                    goto None;
                }
                if (ch != '*')
                {
                    goto BlockComment;
                }
            }
            goto Finish;

        SemiColon:
            while (currCharOfs < end)
            {
                ch = src[currCharOfs++];
                if (ch != ' ' && ch != '\t' && ch != '\n' & ch != '\r' && ch != '\f') // We don't check for comments after the last ; yet
                {
                    return false;
                }
            }
            // implicit goto Finish

        Finish:
            dest.WriteString(src.Substring(currTokenBeg, end - currTokenBeg));
            return true;
        }
コード例 #47
0
ファイル: SirenClassAttribute.cs プロジェクト: fjz13/Medusa
 public override bool SaveTo(Stream stream)
 {
     stream.Write((uint)Mode);
     stream.WriteString(Dir);
     return true;
 }
コード例 #48
0
ファイル: PythonProcess.cs プロジェクト: KevinH-MS/PTVS
        private PythonProcess(Stream stream, int pid, PythonLanguageVersion version, PythonDebugOptions debugOptions) {
            _pid = pid;
            _process = Process.GetProcessById(pid);
            _process.EnableRaisingEvents = true;
            _process.Exited += new EventHandler(_process_Exited);
            
            _delayUnregister = true;
            
            ListenForConnection();

            stream.WriteInt32(DebugConnectionListener.ListenerPort);
            stream.WriteString(_processGuid.ToString());
            stream.WriteString(debugOptions.ToString());
        }
コード例 #49
0
        public void Serialize(Stream output)
        {
            const Endian endian = Endian.Little;

            output.WriteValueS32(this._Rooms.Count, endian);
            foreach (var room in this._Rooms)
            {
                output.WriteValueU32(room.Type, endian);
                output.WriteValueU32(room.Variant, endian);
                output.WriteValueU8(room.Difficulty);
                output.WriteString(room.Name, endian);
                output.WriteValueF32(room.Weight, endian);
                output.WriteValueU8(room.Width);
                output.WriteValueU8(room.Height);

                var doorCount = room.Doors == null ? 0 : room.Doors.Length;
                if (doorCount > byte.MaxValue)
                {
                    throw new InvalidOperationException();
                }

                var spawnCount = room.Spawns == null ? 0 : room.Spawns.Length;
                if (spawnCount > ushort.MaxValue)
                {
                    throw new InvalidOperationException();
                }

                output.WriteValueU8((byte)doorCount);
                output.WriteValueU16((ushort)spawnCount, endian);

                if (room.Doors != null)
                {
                    foreach (var door in room.Doors)
                    {
                        output.WriteValueS16(door.X, endian);
                        output.WriteValueS16(door.Y, endian);
                        output.WriteValueB8(door.Exists);
                    }
                }

                if (room.Spawns != null)
                {
                    foreach (var spawn in room.Spawns)
                    {
                        output.WriteValueS16(spawn.X, endian);
                        output.WriteValueS16(spawn.Y, endian);

                        var entityCount = spawn.Entities == null ? 0 : spawn.Entities.Length;
                        if (entityCount > byte.MaxValue)
                        {
                            throw new InvalidOperationException();
                        }

                        output.WriteValueU8((byte)entityCount);

                        if (spawn.Entities != null)
                        {
                            foreach (var entity in spawn.Entities)
                            {
                                output.WriteValueU16(entity.Type, endian);
                                output.WriteValueU16(entity.Variant, endian);
                                output.WriteValueU16(entity.Subtype, endian);
                                output.WriteValueF32(entity.Weight, endian);
                            }
                        }
                    }
                }
            }
        }
コード例 #50
0
ファイル: PythonRemoteProcess.cs プロジェクト: xNUTs/PTVS
        /// <summary>
        /// Connects to and performs the initial handshake with the remote debugging server, verifying protocol signature and version number,
        /// and returns the opened stream in a state ready to receive further ptvsd commands (e.g. attach).
        /// </summary>
        public static Stream Connect(Uri uri, bool warnAboutAuthenticationErrors)
        {
            var transport = DebuggerTransportFactory.Get(uri);

            if (transport == null)
            {
                throw new ConnectionException(ConnErrorMessages.RemoteInvalidUri);
            }

            Stream stream = null;

            do
            {
                try {
                    stream = transport.Connect(uri, warnAboutAuthenticationErrors);
                } catch (AuthenticationException ex) {
                    if (!warnAboutAuthenticationErrors)
                    {
                        // This should never happen, but if it does, we don't want to keep trying.
                        throw new ConnectionException(ConnErrorMessages.RemoteSslError, ex);
                    }

                    string errText = ex.Message + "\nConnect anyway?";
                    var    dlgRes  = MessageBox.Show(errText, null, MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
                    if (dlgRes == DialogResult.Yes)
                    {
                        warnAboutAuthenticationErrors = false;
                    }
                    else
                    {
                        throw new ConnectionException(ConnErrorMessages.RemoteSslError, ex);
                    }
                }
            } while (stream == null);

            bool connected = false;

            try {
                string sig = stream.ReadAsciiString(DebuggerSignature.Length);
                if (sig != DebuggerSignature)
                {
                    throw new ConnectionException(ConnErrorMessages.RemoteUnsupportedServer);
                }

                long ver = stream.ReadInt64();

                // If we are talking the same protocol but different version, reply with signature + version before bailing out
                // so that ptvsd has a chance to gracefully close the socket on its side.
                stream.Write(DebuggerSignatureBytes);
                stream.WriteInt64(DebuggerProtocolVersion);

                if (ver != DebuggerProtocolVersion)
                {
                    throw new ConnectionException(ConnErrorMessages.RemoteUnsupportedServer);
                }

                stream.WriteString(uri.UserInfo);
                string secretResp = stream.ReadAsciiString(Accepted.Length);
                if (secretResp != Accepted)
                {
                    throw new ConnectionException(ConnErrorMessages.RemoteSecretMismatch);
                }

                connected = true;
                return(stream);
            } catch (IOException ex) {
                throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
            } catch (SocketException ex) {
                throw new ConnectionException(ConnErrorMessages.RemoteNetworkError, ex);
            } finally {
                if (!connected)
                {
                    if (stream != null)
                    {
                        stream.Close();
                    }
                }
            }
        }
コード例 #51
0
ファイル: MultipartItem.cs プロジェクト: CoreTweet/CoreTweet
 public override void WriteTo(Stream stream)
 {
     stream.WriteString($"Content-Disposition: form-data; name=\"{this.Key}\"\r\n\r\n");
     stream.WriteString(this.Value);
 }
コード例 #52
0
        private void Write(Stream CITFile)
        {
            CITFile.Write(new byte[4], 0, 4);
            CITFile.WriteString(Magic);
            CITFile.Write(new byte[4] {
                0xDD, 0xDD, 0xDD, 0xDD
            }, 0, 4);
            CITFile.WriteReverse(BitConverter.GetBytes((ushort)Chords.Count), 0, 2);
            CITFile.WriteReverse(BitConverter.GetBytes((ushort)Scales.Count), 0, 2);
            int         TableOffset = 0x10 + (Chords.Count * 4) + (Scales.Count * 4);
            List <byte> ChordBytes  = new List <byte>();

            for (int i = 0; i < Chords.Count; i++)
            {
                CITFile.WriteReverse(BitConverter.GetBytes(TableOffset), 0, 4);
                TableOffset += 0x08;
                ChordBytes.Add((byte)Chords[i].RootNote);
                ChordBytes.Add((byte)Chords[i].Triad.Note1);
                ChordBytes.Add((byte)Chords[i].Triad.Note2);
                ChordBytes.Add((byte)Chords[i].Triad.Note3);
                ChordBytes.Add((byte)Chords[i].Extension.Note1);
                ChordBytes.Add((byte)Chords[i].Extension.Note2);
                ChordBytes.Add((byte)Chords[i].Extension.Note3);
                ChordBytes.Add((byte)Chords[i].Extension.Note4);
            }
            List <byte> ScaleBytes = new List <byte>();

            for (int i = 0; i < Scales.Count; i++)
            {
                CITFile.WriteReverse(BitConverter.GetBytes(TableOffset), 0, 4);
                ScaleBytes.AddRange(BitConverter.GetBytes(TableOffset + 0x08).Reverse());
                ScaleBytes.AddRange(BitConverter.GetBytes(TableOffset + 0x08 + 0x0C).Reverse());
                ScaleBytes.Add((byte)Scales[i].Item1.Note1);
                ScaleBytes.Add((byte)Scales[i].Item1.Note2);
                ScaleBytes.Add((byte)Scales[i].Item1.Note3);
                ScaleBytes.Add((byte)Scales[i].Item1.Note4);
                ScaleBytes.Add((byte)Scales[i].Item1.Note5);
                ScaleBytes.Add((byte)Scales[i].Item1.Note6);
                ScaleBytes.Add((byte)Scales[i].Item1.Note7);
                ScaleBytes.Add((byte)Scales[i].Item1.Note8);
                ScaleBytes.Add((byte)Scales[i].Item1.Note9);
                ScaleBytes.Add((byte)Scales[i].Item1.Note10);
                ScaleBytes.Add((byte)Scales[i].Item1.Note11);
                ScaleBytes.Add((byte)Scales[i].Item1.Note12);
                ScaleBytes.Add((byte)Scales[i].Item2.Note1);
                ScaleBytes.Add((byte)Scales[i].Item2.Note2);
                ScaleBytes.Add((byte)Scales[i].Item2.Note3);
                ScaleBytes.Add((byte)Scales[i].Item2.Note4);
                ScaleBytes.Add((byte)Scales[i].Item2.Note5);
                ScaleBytes.Add((byte)Scales[i].Item2.Note6);
                ScaleBytes.Add((byte)Scales[i].Item2.Note7);
                ScaleBytes.Add((byte)Scales[i].Item2.Note8);
                ScaleBytes.Add((byte)Scales[i].Item2.Note9);
                ScaleBytes.Add((byte)Scales[i].Item2.Note10);
                ScaleBytes.Add((byte)Scales[i].Item2.Note11);
                ScaleBytes.Add((byte)Scales[i].Item2.Note12);
                TableOffset += 0x20;
            }
            CITFile.Write(ChordBytes.ToArray(), 0, ChordBytes.Count);
            CITFile.Write(ScaleBytes.ToArray(), 0, ScaleBytes.Count);
            CITFile.Position = 0x08;
            CITFile.WriteReverse(BitConverter.GetBytes((uint)CITFile.Length), 0, 4);
            CITFile.Position = CITFile.Length;
            CITFile.PadTo(32);
        }
コード例 #53
0
        private void AppendParameterPlaceHolder(Stream dest, NpgsqlParameter parameter, int paramNumber)
        {
            string parameterSize = "";

            dest.WriteBytes((byte)ASCIIBytes.ParenLeft);

            if (parameter.TypeInfo.UseSize && (parameter.Size > 0))
            {
                parameterSize = string.Format("({0})", parameter.Size);
            }

            if (parameter.UseCast)
            {
                dest.WriteString("${0}::{1}{2}", paramNumber, parameter.TypeInfo.CastName, parameterSize);
            }
            else
            {
                dest.WriteString("${0}{1}", paramNumber, parameterSize);
            }

            dest.WriteBytes((byte)ASCIIBytes.ParenRight);
        }
コード例 #54
0
ファイル: BinkEntry.cs プロジェクト: xyzzys/Psiga
 public override void WriteTo(Stream s)
 {
     s.WriteByte((byte)(IsAlpha ? 1 : 0));
     s.WriteString(BinkFileName);
 }
コード例 #55
0
        private void AppendParameterValue(Stream dest, NpgsqlParameter parameter)
        {
            byte[] serialised = parameter.TypeInfo.ConvertToBackend(parameter.NpgsqlValue, false, Connector.NativeToBackendTypeConverterOptions);

            // Add parentheses wrapping parameter value before the type cast to avoid problems with Int16.MinValue, Int32.MinValue and Int64.MinValue
            // See bug #1010543
            // Check if this parenthesis can be collapsed with the previous one about the array support. This way, we could use
            // only one pair of parentheses for the two purposes instead of two pairs.
            dest
                .WriteBytes((byte)ASCIIBytes.ParenLeft)
                .WriteBytes((byte)ASCIIBytes.ParenLeft)
                .WriteBytes(serialised)
                .WriteBytes((byte)ASCIIBytes.ParenRight);

            if (parameter.UseCast)
            {
                dest.WriteString("::{0}", parameter.TypeInfo.CastName);

                if (parameter.TypeInfo.UseSize && (parameter.Size > 0))
                {
                    dest.WriteString("({0})", parameter.Size);
                }
            }

            dest.WriteBytes((byte)ASCIIBytes.ParenRight);
        }
コード例 #56
0
ファイル: BinarySerializer.cs プロジェクト: widovd/NEUNET
 public override void Serialize(Stream stream, ISerializable serializable)
 {
     stream.WriteString(Version.ToString());
     WriteValue(stream, serializable);
 }
コード例 #57
0
ファイル: PythonProcess.cs プロジェクト: KevinH-MS/PTVS
        private void HandleRequestHandlers(Stream stream) {
            string filename = stream.ReadString();

            Debug.WriteLine("Exception handlers requested for: " + filename);
            var statements = GetHandledExceptionRanges(filename);

            lock (_streamLock) {
                stream.Write(SetExceptionHandlerInfoCommandBytes);
                stream.WriteString(filename);

                stream.WriteInt32(statements.Count);

                foreach (var t in statements) {
                    stream.WriteInt32(t.Item1);
                    stream.WriteInt32(t.Item2);

                    foreach (var expr in t.Item3) {
                        stream.WriteString(expr);
                    }
                    stream.WriteString("-");
                }
            }
        }
コード例 #58
0
 public static void WriteStringU32(this Stream output, string value, Endian endian)
 {
     output.WriteValueS32(value.Length, endian);
     output.WriteString(value, Encoding.ASCII);
 }
コード例 #59
0
ファイル: Request.cs プロジェクト: aktaat/CoreTweet
        private static void WriteMultipartFormData(Stream stream, string boundary, IEnumerable<KeyValuePair<string, object>> prm)
        {
            const int bufferSize = 81920;

            prm.ForEach(x =>
            {
                var valueStream = x.Value as Stream;
                var valueBytes = x.Value as IEnumerable<byte>;
            #if !PCL
                var valueFile = x.Value as FileInfo;
            #endif
                var valueString = x.Value.ToString();
            #if WP
                var valueInputStream = x.Value as Windows.Storage.Streams.IInputStream;
                if(valueInputStream != null) valueStream = valueInputStream.AsStreamForRead();
            #endif

                stream.WriteString("--" + boundary + "\r\n");
                if(valueStream != null || valueBytes != null
            #if !PCL
                    || valueFile != null
            #endif
                   )
                {
                    stream.WriteString("Content-Type: application/octet-stream\r\n");
                }
                stream.WriteString(string.Format(@"Content-Disposition: form-data; name=""{0}""", x.Key));
            #if !PCL
                if(valueFile != null)
                    stream.WriteString(string.Format(@"; filename=""{0}""",
                        valueFile.Name.Replace("\n", "%0A").Replace("\r", "%0D").Replace("\"", "%22")));
                else
            #endif
                if(valueStream != null || valueBytes != null)
                    stream.WriteString(@"; filename=""file""");
                stream.WriteString("\r\n\r\n");

            #if !PCL
                if(valueFile != null)
                    valueStream = valueFile.OpenRead();
            #endif
                if(valueStream != null)
                {
                    var buffer = new byte[bufferSize];
                    int count;
                    while((count = valueStream.Read(buffer, 0, bufferSize)) > 0)
                        stream.Write(buffer, 0, count);
                }
                else if(valueBytes != null)
                {
                    var buffer = valueBytes as byte[];
                    if(buffer != null)
                        stream.Write(buffer, 0, buffer.Length);
                    else
                    {
                        buffer = new byte[bufferSize];
                        var i = 0;
                        foreach(var b in valueBytes)
                        {
                            buffer[i++] = b;
                            if(i == bufferSize)
                            {
                                stream.Write(buffer, 0, bufferSize);
                                i = 0;
                            }
                        }
                        if(i > 0)
                            stream.Write(buffer, 0, i);
                    }
                }
                else
                    stream.WriteString(valueString);

            #if !PCL
                if(valueFile != null)
                    valueStream.Close();
            #endif

                stream.WriteString("\r\n");
            });
            stream.WriteString("--" + boundary + "--");
        }
コード例 #60
0
        public void Serialize(Stream output, ArchiveSerializeOptions options)
        {
            var compress = (options & ArchiveSerializeOptions.Compress) > 0;

            var basePosition = output.Position;
            var endian       = this._Endian;

            using (var data = new MemoryStream(12))
            {
                data.WriteValueU32(Signature, Endian.Big);
                data.WriteValueU32(Version, endian);
                data.WriteValueU32((uint)this._Platform, Endian.Big);
                data.Flush();
                output.WriteFromMemoryStreamSafe(data, endian);
            }

            var headerPosition = output.Position;

            Archive.FileHeader fileHeader;
            output.Seek(56, SeekOrigin.Current);

            fileHeader.ResourceTypeTableOffset = (uint)(output.Position - basePosition);
            output.WriteValueS32(this._ResourceTypes.Count, endian);
            foreach (var resourceType in this._ResourceTypes)
            {
                resourceType.Write(output, endian);
            }
            uint stride         = (uint)(Version == 20 ? 38 : 30);
            uint alignment      = (uint)(Version == 20 ? 0x10000 : 0x4000);
            var  blockAlignment = (options & ArchiveSerializeOptions.OneBlock) != ArchiveSerializeOptions.None ? (uint)this._ResourceEntries.Sum(re => stride + (re.Data == null ? 0 : re.Data.Length)) : alignment;

            fileHeader.BlockTableOffset = (uint)(output.Position - basePosition);
            fileHeader.ResourceCount    = 0;
            var blockStream = BlockWriterStream.ToStream(output, blockAlignment, endian, compress, ChosenGameType == GamesEnumerator.MafiaI_DE);

            foreach (var resourceEntry in this._ResourceEntries)
            {
                Archive.ResourceHeader resourceHeader;
                resourceHeader.TypeId            = (uint)resourceEntry.TypeId;
                resourceHeader.Size              = stride + (uint)(resourceEntry.Data == null ? 0 : resourceEntry.Data.Length);
                resourceHeader.Version           = resourceEntry.Version;
                resourceHeader.FileHash          = resourceEntry.FileHash;
                resourceHeader.SlotRamRequired   = resourceEntry.SlotRamRequired;
                resourceHeader.SlotVramRequired  = resourceEntry.SlotVramRequired;
                resourceHeader.OtherRamRequired  = resourceEntry.OtherRamRequired;
                resourceHeader.OtherVramRequired = resourceEntry.OtherVramRequired;

                using (var data = new MemoryStream())
                {
                    resourceHeader.Write(data, endian, Version);
                    data.Flush();
                    blockStream.WriteFromMemoryStreamSafe(data, endian);
                }

                blockStream.WriteBytes(resourceEntry.Data);
                fileHeader.ResourceCount++;
            }

            blockStream.Flush();
            blockStream.Finish();

            fileHeader.XmlOffset = (uint)(output.Position - basePosition);
            if (string.IsNullOrEmpty(this._ResourceInfoXml) == false)
            {
                output.WriteString(this._ResourceInfoXml, Encoding.ASCII);
            }

            fileHeader.SlotRamRequired   = this.SlotRamRequired;
            fileHeader.SlotVramRequired  = this.SlotVramRequired;
            fileHeader.OtherRamRequired  = this.OtherRamRequired;
            fileHeader.OtherVramRequired = this.OtherVramRequired;
            fileHeader.Flags             = 1;
            fileHeader.Unknown20         = this._Unknown20 ?? new byte[16];

            output.Position = headerPosition;
            using (var data = new MemoryStream())
            {
                fileHeader.Write(data, endian);
                data.Flush();
                output.WriteFromMemoryStreamSafe(data, endian);
            }
        }