Beispiel #1
0
 /// <summary>
 /// Create new C file access
 /// </summary>
 public CFile(Stream stream, Encoding encoding = null)
 {
     this._Stream = stream;
     EOF = _Stream == null;
     this._Encoding = encoding ?? Encoding.GetEncoding("Windows-1252");
     this._Decoder = _Encoding.GetDecoder();
 }
        public void run()
        {
            Debug.Log("Starting Thread");
            running = true;
            try
            {
                Socket soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                System.Net.IPAddress  ipAdd    = System.Net.IPAddress.Parse("127.0.0.1");
                System.Net.IPEndPoint remoteEP = new IPEndPoint(ipAdd, 1111);
                //soc.ReceiveTimeout = 5000;
                //soc.SendTimeout = 5000;
                soc.Connect(remoteEP);
                soc.Send(System.Text.Encoding.ASCII.GetBytes("Output\n"));
                while (running)
                {
                    byte[] buffer = new byte[300000];
                    int    iRx    = soc.Receive(buffer);
                    char[] chars  = new char[iRx];

                    System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                    int           charLen = d.GetChars(buffer, 0, iRx, chars, 0);
                    System.String recv    = new System.String(chars);
                    //Console.WriteLine(recv);
                    //Debug.Log(recv);
                    pos = recv;
                }
                soc.Close();
            }
            catch (Exception e)
            {
                //Console.WriteLine(e);
                Debug.Log(e);
            }
        }
        public HttpRequestStreamReader(Stream stream, Encoding encoding, int bufferSize)
        {
            if (stream == null)
            {
                throw new ArgumentNullException(nameof(stream));
            }

            if (!stream.CanRead)
            {
                throw new ArgumentException(Resources.HttpRequestStreamReader_StreamNotReadable, nameof(stream));
            }

            if (encoding == null)
            {
                throw new ArgumentNullException(nameof(encoding));
            }

            _stream = stream;
            _encoding = encoding;
            _decoder = encoding.GetDecoder();

            if (bufferSize < MinBufferSize)
            {
                bufferSize = MinBufferSize;
            }

            _byteBufferSize = bufferSize;
            _byteBuffer = new byte[bufferSize];
            var maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize);
            _charBuffer = new char[maxCharsPerBuffer];
        }
Beispiel #4
0
    public static string base64Decode(string sData)
    {
        try
        {
            System.Text.UTF8Encoding encoder = new System.Text.UTF8Encoding();

            System.Text.Decoder utf8Decode = encoder.GetDecoder();

            byte[] todecode_byte = Convert.FromBase64String(sData);

            int charCount = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

            char[] decoded_char = new char[charCount];

            utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);

            string result = new String(decoded_char);

            return(result);
        }
        catch (Exception ex)
        {
            throw new Exception("Error in base64Decode" + ex.Message);
        }
    }
Beispiel #5
0
        static StaticUtils()
        {
            asciiDecoder = Encoding.ASCII.GetDecoder();

            utf8Encoder = Encoding.UTF8.GetEncoder();
            utf8Decoder = Encoding.UTF8.GetDecoder();
        }
    public static Highscore[] GetHighscores()
    {
        string path = Application.persistentDataPath + "/Highscores.lwhs";

        if (File.Exists(path))
        {
            Stream fs    = File.Open(path, FileMode.Open);
            int    count = fs.ReadByte();
            if (count == 0)
            {
                fs.Close();
                return(null);
            }
            else
            {
                if (count > MAX_HIGHSCORES_COUNT)
                {
                    count = MAX_HIGHSCORES_COUNT;
                }
                var hsa = new Highscore[count];
                System.Text.Decoder decoder = System.Text.Encoding.Default.GetDecoder();
                for (int i = 0; i < count; i++)
                {
                    hsa[i] = Load(fs, decoder);
                }
                fs.Close();
                return(hsa);
            }
        }
        else
        {
            return(null);
        }
    }
        /// <summary>
        /// Constructs a new binary reader with the given bit converter, reading
        /// to the given stream, using the given encoding.
        /// </summary>
        /// <param name="bitConverter">Converter to use when reading data</param>
        /// <param name="stream">Stream to read data from</param>
        /// <param name="encoding">Encoding to use when reading character data</param>
        public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, Encoding encoding)
        {
            if (bitConverter == null)
            {
                throw new ArgumentNullException("bitConverter");
            }
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }
            if (encoding == null)
            {
                throw new ArgumentNullException("encoding");
            }
            if (!stream.CanRead)
            {
                throw new ArgumentException("Stream isn't writable", "stream");
            }
            this.stream = stream;
            this.bitConverter = bitConverter;
            this.encoding = encoding;
            this.decoder = encoding.GetDecoder();
            this.minBytesPerChar = 1;

            if (encoding is UnicodeEncoding)
            {
                minBytesPerChar = 2;
            }
        }
Beispiel #8
0
        public EndianReader(Stream input, Endianness endianess, Encoding encoding, bool leaveOpen)
        {
            if (input == null)
            {
                throw new ArgumentNullException(nameof(input));
            }
            if (encoding == null)
            {
                throw new ArgumentNullException(nameof(encoding));
            }
            if (!input.CanRead)
                throw new ArgumentException("Can't read from the output stream", nameof(input));
            Contract.EndContractBlock();

            BaseStream = input;
            decoder = encoding.GetDecoder();
            maxCharsSize = encoding.GetMaxCharCount(MaxCharBytesSize);
            var minBufferSize = encoding.GetMaxByteCount(1);  // max bytes per one char
            if (minBufferSize < 16)
                minBufferSize = 16;
            buffer = new byte[minBufferSize];
            // m_charBuffer and m_charBytes will be left null.

            // For Encodings that always use 2 bytes per char (or more), 
            // special case them here to make Read() & Peek() faster.
            use2BytesPerChar = encoding is UnicodeEncoding;
            this.leaveOpen = leaveOpen;

            Endianness = endianess;
            resolvedEndianess = EndianessHelper.Resolve(endianess);

            Contract.Assert(decoder != null, "[EndianReader.ctor]m_decoder!=null");
        }
 public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, System.Text.Encoding encoding)
 {
     this.disposed = false;
     this.buffer = new byte[0x10];
     this.charBuffer = new char[1];
     if (bitConverter == null)
     {
         throw new ArgumentNullException("bitConverter");
     }
     if (stream == null)
     {
         throw new ArgumentNullException("stream");
     }
     if (encoding == null)
     {
         throw new ArgumentNullException("encoding");
     }
     if (!stream.CanRead)
     {
         throw new ArgumentException("Stream isn't writable", "stream");
     }
     this.stream = stream;
     this.bitConverter = bitConverter;
     this.encoding = encoding;
     this.decoder = encoding.GetDecoder();
     this.minBytesPerChar = 1;
     if (encoding is UnicodeEncoding)
     {
         this.minBytesPerChar = 2;
     }
 }
 public ContentReader(Stream stream, long length, Encoding encoding = null) {
     _stream = stream;
     _length = length;
     if (encoding != null) {
         _decoder = encoding.GetDecoder();
     }
 }
 static void Main(string[] args)
 {
     //第一个参数是第三方平台
     //第二个参数是平台账号信息,若此处不设置Account,则需要在策略代码中设置默认值
     var decoder = new Decoder(Platform.RuoKuai, new Account
     {
         SoftId = 0, // 软件ID(此ID需要注册开发者账号才可获得)
         TypeId = 0, // 验证码类型(四位字符或其他类型的验证码,根据各平台设置不同值)
         SoftKey = null, //软件Key (此Key也需要注册开发者账号才可获得)
         UserName = null, //账号(此账号为打码平台的普通用户账号,开发者账号不能进行图片识别)
         Password = null //密码
     });
     decoder.OnStart += (s, e) =>
     {
         Console.WriteLine("验证码("+e.FilePath+")识别启动……");
     };
     decoder.OnCompleted += (s, e) =>
     {
         Console.WriteLine("验证码(" + e.FilePath + ")识别完成:" + e.Code + ",耗时:" + (e.Milliseconds/1000) + "秒,线程ID:"+e.ThreadId);
     };
     decoder.OnError += (s, e) =>
     {
         Console.WriteLine("验证码识别出错:" + e.Exception.Message);
     };
     for (var i = 1; i <= 3; i++)
     {
         decoder.Decode("c:\\checkcode"+i+".png");
     }
     Console.ReadKey();
 }
Beispiel #12
0
        public BinaryReader(Stream input, Encoding encoding, bool leaveOpen) {
            if (input==null) {
                throw new ArgumentNullException(nameof(input));
            }
            if (encoding==null) {
                throw new ArgumentNullException(nameof(encoding));
            }
            if (!input.CanRead)
                throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable"));
            Contract.EndContractBlock();
            m_stream = input;
            m_decoder = encoding.GetDecoder();
            m_maxCharsSize = encoding.GetMaxCharCount(MaxCharBytesSize);
            int minBufferSize = encoding.GetMaxByteCount(1);  // max bytes per one char
            if (minBufferSize < 16) 
                minBufferSize = 16;
            m_buffer = new byte[minBufferSize];
            // m_charBuffer and m_charBytes will be left null.

            // For Encodings that always use 2 bytes per char (or more), 
            // special case them here to make Read() & Peek() faster.
            m_2BytesPerChar = encoding is UnicodeEncoding;
            // check if BinaryReader is based on MemoryStream, and keep this for it's life
            // we cannot use "as" operator, since derived classes are not allowed
            m_isMemoryStream = (m_stream.GetType() == typeof(MemoryStream));
            m_leaveOpen = leaveOpen;

            Contract.Assert(m_decoder!=null, "[BinaryReader.ctor]m_decoder!=null");
        }
    public static Highscore Load(Stream fs, System.Text.Decoder decoder)
    {
        const int length = 4;

        byte[] data = new byte[length];
        char[] chars;
        string name;

        fs.Read(data, 0, length);
        var bytesCount = System.BitConverter.ToInt32(data, 0);

        if (bytesCount > 0 && bytesCount < 100000)
        {
            data = new byte[bytesCount];
            fs.Read(data, 0, bytesCount);
            chars = new char[decoder.GetCharCount(data, 0, bytesCount)];
            decoder.GetChars(data, 0, bytesCount, chars, 0, true);
            name = new string(chars);
        }
        else
        {
            name = "highscore";
        }
        //
        bytesCount = 9;
        data       = new byte[bytesCount];
        fs.Read(data, 0, bytesCount);
        return(new Highscore(System.BitConverter.ToInt32(data, 0), name, System.BitConverter.ToUInt32(data, 4), (GameEndingType)data[8]));
    }
 public BinaryReader(Stream input, Encoding encoding)
 {
     if (input == null)
     {
         throw new ArgumentNullException("input");
     }
     if (encoding == null)
     {
         throw new ArgumentNullException("encoding");
     }
     if (!input.CanRead)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_StreamNotReadable"));
     }
     this.m_stream = input;
     this.m_decoder = encoding.GetDecoder();
     this.m_maxCharsSize = encoding.GetMaxCharCount(0x80);
     int maxByteCount = encoding.GetMaxByteCount(1);
     if (maxByteCount < 0x10)
     {
         maxByteCount = 0x10;
     }
     this.m_buffer = new byte[maxByteCount];
     this.m_charBuffer = null;
     this.m_charBytes = null;
     this.m_2BytesPerChar = encoding is UnicodeEncoding;
     this.m_isMemoryStream = this.m_stream.GetType() == typeof(MemoryStream);
 }
Beispiel #15
0
 void OnDataReceived(IAsyncResult asyn)
 {
     try
     {
         SocketPacket        packet  = (SocketPacket)asyn.AsyncState;
         int                 end     = packet.TCPSocket.EndReceive(asyn);
         char[]              chars   = new char[end + 1];
         System.Text.Decoder d       = System.Text.Encoding.UTF8.GetDecoder();
         int                 charLen = d.GetChars(packet.DataBuffer, 0, end, chars, 0);
         System.String       data    = new System.String(chars);
         ReceiveData(data);
         WaitForData();
     }
     catch (ObjectDisposedException)
     {
         Console.WriteLine("WARNING: Socket closed unexpectedly");
     }
     catch (SocketException se)
     {
         if (!_TCPSocket.Connected)
         {
             OnDisconnected(se);
         }
     }
 }
 /// <summary>
 /// コンストラクタです。
 /// </summary>
 public XmlParser(Stream stream)
 {
     this.stream = stream;
     this.element = this.name = this.data = "";
     this.attr = new Hashtable();
     this.dec = Encoding.Default.GetDecoder();
     this.letter = false;
 }
Beispiel #17
0
 /// <summary>
 /// Reads an ATTRIBUTEWORD from the byte buffer.
 /// </summary>
 /// <param name="buffer">buffer containing serialized data</param>
 /// <param name="offset">reference to an offset variable; upon entry offset 
 /// reflects the position within the buffer where reading should begin. 
 /// Upon success the offset will be incremented by the number of bytes that are used.</param>
 /// <param name="coder">Decoder used to translate byte data to character data</param>
 /// <returns>an ATTRIBUTEWORD value taken from the buffer</returns>
 public static string ReadATTRIBUTEWORD(byte[] buffer, ref int offset, Decoder coder)
 {
     #if DEBUG
     if (buffer == null) throw new ArgumentNullException("buffer");
     if (offset < 0 || offset > buffer.Length - 1) throw new BadLwesDataException(String.Concat("Expected ATTRIBUTEWORD at offset ", offset));
     #endif
     return ReadStringWithByteLengthPrefix(buffer, ref offset, coder);
 }
 public PositionedStreamReader(Stream stream, Encoding encoding)
 {
     this.stream = stream;
     this.encoding = encoding;
     decoder = encoding.GetDecoder();
     bufferpos = 0;
     readPosition = 0;
 }
 public UTF8SanitizerStream(string pattern, string substitute, Stream output)
 {
     _pattern = pattern;
     _substitute = substitute;
     _output = output;
     _decoder = Encoding.UTF8.GetDecoder();
     _buffer = String.Empty;
 }
Beispiel #20
0
 //bool disposed;
 public RequestState()
 {
     BufferRead = new byte[BufferSize];
     RequestData = new StringBuilder(String.Empty);
     Request = null;
     ResponseStream = null;
     StreamDecode = Encoding.UTF8.GetDecoder();
 }
Beispiel #21
0
        /// <summary>
        /// Unpacks next section of the compressed replay
        /// </summary>
        /// <param name="length">The length of the section</param>
        /// <returns>The decoded data</returns>
        protected byte[] UnpackNextSection(int length)
        {
            byte[] result = new byte[length];

            Decoder decoder = new Decoder();
            DecodeBuffer buffer = new DecodeBuffer(result);

            decoder.DecodeBuffer = buffer;

            int checksum = _reader.ReadInt32();
            int blocks = _reader.ReadInt32();

            for (int block = 0; block < blocks; block++)
            {

                // read the length of the next block of encoded data
                int encodedLength = _reader.ReadInt32();

                // we error if there is no space for the next block of encoded data
                if (encodedLength > result.Length - buffer.ResultOffset)
                {
                    throw new Exception("Insufficient space in decode buffer");
                }

                // read the block of encoded data into the result (decoded data will overwrite).
                _reader.Read(result, buffer.ResultOffset, encodedLength);

                // skip decoding if the encoded data filled the remaining space
                if (encodedLength == Math.Min(result.Length - buffer.ResultOffset, buffer.BufferLength))
                {
                    continue;
                }

                // set the decode buffer parameters
                buffer.EncodedOffset = 0;
                buffer.DecodedLength = 0;
                buffer.EncodedLength = encodedLength;

                // decode the block
                if (decoder.DecodeBlock() != 0)
                {
                    throw new Exception("Error decoding block offset " + block);
                }

                // sanity check the decoded length
                if (buffer.DecodedLength == 0 ||
                        buffer.DecodedLength > buffer.BufferLength ||
                        buffer.DecodedLength > result.Length)
                {
                    throw new Exception("Decode data length mismatch");
                }

                // flush the decoded bytes into the result
                buffer.WriteDecodedBytes();
            }

            return result;
        }
 public CancellableStreamReader(Stream stream, Encoding encoding)
 {
     _stream = stream;
     _decoder = encoding.GetDecoder();
     _byteBuffer = new byte[BufferLength];
     _buffer = new char[encoding.GetMaxCharCount(BufferLength)];
     _bufferedLength = -1;
     _bufferCursor = -1;
 }
Beispiel #23
0
 TextSource(Encoding encoding)
 {
     _buffer = new Byte[BufferSize];
     _chars = new Char[BufferSize + 1];
     _raw = new MemoryStream();
     _index = 0;
     _encoding = encoding ?? TextEncoding.Utf8;
     _decoder = _encoding.GetDecoder();
 }
Beispiel #24
0
 public AsyncTextReader(IAsyncDataSource dataSource, Encoding encoding, int bufferSize = DefaultBufferSize)
     : base()
 {
     _DataSource = dataSource;
     _Encoding = encoding;
     _Decoder = _Encoding.GetDecoder();
     _BufferSize = Math.Max(MinimumBufferSize, bufferSize);
     AllocateBuffer();
 }
Beispiel #25
0
 public AsyncLineReader(Stream stream, Encoding encoding, int bufferSize, int maxLineLength)
 {
     this.stream = stream;
     this.decoder = encoding.GetDecoder();
     this.readBuffer = new byte[bufferSize];
     this.decodeBuffer = new char[bufferSize];
     this.maxLineLength = maxLineLength;
     StartRead();
 }
    public static Highscore[] GetHighscores()
    {
        string path = Application.persistentDataPath + "/Highscores.lwhs";

        if (File.Exists(path))
        {
            FileStream fs    = File.Open(path, FileMode.Open);
            int        count = fs.ReadByte();
            if (count == 0)
            {
                fs.Close();
                return(null);
            }
            else
            {
                if (count > MAX_HIGHSCORES_COUNT)
                {
                    count = MAX_HIGHSCORES_COUNT;
                }
                var    hsa  = new Highscore[count];
                string name = "highscore";
                var    data = new byte[4];
                System.Text.Decoder decoder = System.Text.Encoding.Default.GetDecoder();
                char[] chars;
                int    bytesCount = 0;
                for (int i = 0; i < count; i++)
                {
                    fs.Read(data, 0, 4);
                    bytesCount = System.BitConverter.ToInt32(data, 0);
                    if (bytesCount > 0 && bytesCount < 100000)
                    {
                        data = new byte[bytesCount];
                        fs.Read(data, 0, bytesCount);
                        chars = new char[decoder.GetCharCount(data, 0, bytesCount)];
                        decoder.GetChars(data, 0, bytesCount, chars, 0, true);
                        name = new string(chars);
                    }
                    else
                    {
                        name = "highscore";
                    }
                    //
                    bytesCount = 9;
                    data       = new byte[bytesCount];
                    fs.Read(data, 0, bytesCount);
                    hsa[i] = new Highscore(name, System.BitConverter.ToUInt64(data, 0), (GameEndingType)data[bytesCount - 1]);
                }
                fs.Close();
                return(hsa);
            }
        }
        else
        {
            return(null);
        }
    }
Beispiel #27
0
    public void Load(System.IO.FileStream fs)
    {
        int LENGTH = 47;
        var data   = new byte[LENGTH];

        fs.Read(data, 0, LENGTH);
        ID = System.BitConverter.ToInt32(data, 0);

        atHome       = data[4] == 1;
        membersCount = data[5];
        if (data[6] == 2)
        {
            chanceMod = null;
        }
        else
        {
            chanceMod = data[6] == 1;
        }
        persistence     = data[7];
        survivalSkills  = data[8];
        secretKnowledge = data[9];
        perception      = data[10];
        intelligence    = data[11];
        techSkills      = data[12];
        freePoints      = data[13];
        level           = data[14];
        RecalculatePath();

        stamina      = System.BitConverter.ToSingle(data, 15);
        confidence   = System.BitConverter.ToSingle(data, 19);
        unity        = System.BitConverter.ToSingle(data, 23);
        loyalty      = System.BitConverter.ToSingle(data, 27);
        adaptability = System.BitConverter.ToSingle(data, 31);
        experience   = System.BitConverter.ToInt32(data, 35);

        missionsParticipated = System.BitConverter.ToUInt16(data, 39);
        missionsSuccessed    = System.BitConverter.ToUInt16(data, 41);

        int bytesCount = System.BitConverter.ToInt32(data, 43); //выдаст количество байтов, не длину строки

        if (bytesCount < 0 | bytesCount > 1000000)
        {
            Debug.Log("crew load error - name bytes count incorrect");
            GameMaster.LoadingFail();
            return;
        }
        if (bytesCount > 0)
        {
            data = new byte[bytesCount];
            fs.Read(data, 0, bytesCount);
            System.Text.Decoder d = System.Text.Encoding.Default.GetDecoder();
            var chars             = new char[d.GetCharCount(data, 0, bytesCount)];
            d.GetChars(data, 0, bytesCount, chars, 0, true);
            name = new string(chars);
        }
    }
Beispiel #28
0
		public MiniStream (IMiniStreamSink sink, Encoding encoding, int buf_size) {
			if (sink == null)
				throw new ArgumentNullException ();

			this.sink = sink;
			this.sb = new StringBuilder ();
			this.decoder = encoding.GetDecoder ();

			this.buf = new char[buf_size];
		}
        /// <summary>
        /// Comment about constructing.
        /// </summary>
        private InterningBinaryReader(Stream input, Buffer buffer)
            : base(input, buffer.Encoding)
        {
            if (input == null)
            {
                throw new InvalidOperationException();
            }

            _buffer = buffer;
            _decoder = buffer.Encoding.GetDecoder();
        }
 public MyBinaryReader(Stream stream, Encoding encoding)
     : base(stream, encoding)
 {
     this.m_decoder = encoding.GetDecoder();
     this.m_maxCharsSize = encoding.GetMaxCharCount(0x80);
     int maxByteCount = encoding.GetMaxByteCount(1);
     if (maxByteCount < 0x10)
     {
         maxByteCount = 0x10;
     }
 }
Beispiel #31
0
    public static string Decrypt(this string str)
    {
        System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
        System.Text.Decoder      utf8Decode = encoder.GetDecoder();
        byte[] todecode_byte = Convert.FromBase64String(str);
        int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

        char[] decoded_char = new char[charCount];
        utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
        return(new string(decoded_char));
    }
Beispiel #32
0
        /// <summary>Initializes a new reusable reader.</summary>
        /// <param name="encoding">The Encoding to use.  Defaults to UTF8.</param>
        /// <param name="bufferSize">The size of the buffer to use when reading from the stream.</param>
        public ReusableTextReader(Encoding encoding = null, int bufferSize = 1024)
        {
            if (encoding == null)
            {
                encoding = Encoding.UTF8;
            }

            _decoder = encoding.GetDecoder();
            _bytes = new byte[bufferSize];
            _chars = new char[encoding.GetMaxCharCount(_bytes.Length)];
        }
Beispiel #33
0
 //bool disposed;
 public RequestState()
 {
     BufferRead = new byte[BufferSize];
     RequestData = new StringBuilder(String.Empty);
     Request = null;
     ResponseStream = null;
     Response = null;
     StreamDecode = Encoding.UTF8.GetDecoder();
     RequestByte=new MemoryStream();
     //disposed = false;
 }
Beispiel #34
0
    public string base64Decode(string sData)
    {
        System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
        System.Text.Decoder      utf8Decode = encoder.GetDecoder();
        byte[] todecode_byte = Convert.FromBase64String(sData);
        int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

        char[] decoded_char = new char[charCount];
        utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
        string result = new String(decoded_char); return(result);
    }
		public BinaryReader(Stream input, Encoding encoding) {
			if (input == null || encoding == null) 
				throw new ArgumentNullException(Locale.GetText ("Input or Encoding is a null reference."));
			if (!input.CanRead)
				throw new ArgumentException(Locale.GetText ("The stream doesn't support reading."));

			m_stream = input;
			m_encoding = encoding;
			decoder = encoding.GetDecoder ();
			m_buffer = new byte [32];
		}
Beispiel #36
0
 static MacUtil()
 {
     Encoding macencoding;
     try
     {
         macencoding = Encoding.GetEncoding("macintosh");
     }
     catch (ArgumentException)
     {
         macencoding = Encoding.ASCII;
     }
     macdecoder = macencoding.GetDecoder();
 }
Beispiel #37
0
        //Test method to verify encode/decode service with orderclass
        static Boolean testOrder()
        {
            OrderClass order = new OrderClass();
            order.setAmt(123);
            order.setID("test");
            order.setCardNo(456418);

            Encoder enc = new Encoder(order);
            String encoded = enc.getOrder();
            Decoder dec = new Decoder(encoded);

            return order == dec.getOrder();
        }
Beispiel #38
0
    public string DecryptCode(string code)
    {
        code = code.Substring(0, code.Length - 1);
        System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
        System.Text.Decoder      utf8Decode = encoder.GetDecoder();
        byte[] todecode_byte = Convert.FromBase64String(code);
        int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

        char[] decoded_char = new char[charCount];
        utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
        code = new String(decoded_char);
        return(code);
    }
 internal DryadLinqBinaryReader(NativeBlockStream stream, Encoding encoding)
 {
     this.m_nativeStream = stream;
     this.m_encoding = encoding;
     this.m_decoder = encoding.GetDecoder();
     this.m_curDataBlockInfo.DataBlock = null;
     this.m_curDataBlockInfo.BlockSize = -1;
     this.m_curDataBlockInfo.ItemHandle = IntPtr.Zero;
     this.m_curDataBlock = this.m_curDataBlockInfo.DataBlock;
     this.m_curBlockSize = this.m_curDataBlockInfo.BlockSize;
     this.m_curBlockPos = -1;
     this.m_isClosed = false;
 }
Beispiel #40
0
		public BinaryReader(Stream input, Encoding encoding) {
			if (input == null || encoding == null) 
				throw new ArgumentNullException(Locale.GetText ("Input or Encoding is a null reference."));
			if (!input.CanRead)
				throw new ArgumentException(Locale.GetText ("The stream doesn't support reading."));

			m_stream = input;
			m_encoding = encoding;
			decoder = encoding.GetDecoder ();
			
			// internal buffer size is documented to be between 16 and the value
			// returned by GetMaxByteCount for the specified encoding
			m_buffer = new byte [Math.Max (16, encoding.GetMaxByteCount (1))];
		}
        public void run()
        {
            Debug.Log("Starting Thread");
            running = true;
            try
            {
                Socket soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                System.Net.IPAddress  ipAdd    = System.Net.IPAddress.Parse("10.19.186.134");
                System.Net.IPEndPoint remoteEP = new IPEndPoint(ipAdd, 1234);
                soc.ReceiveTimeout = 1000;
                soc.SendTimeout    = 1000;
                soc.Connect(remoteEP);
                soc.Send(System.Text.Encoding.ASCII.GetBytes("Output\n"));
                while (running)
                {
                    byte[] buffer = new byte[300000];
                    int    iRx    = soc.Receive(buffer);
                    char[] chars  = new char[iRx];

                    System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                    int           charLen = d.GetChars(buffer, 0, iRx, chars, 0);
                    System.String recv    = new System.String(chars);
                    //Console.WriteLine(recv);
                    //Debug.Log(recv);
                    //msg = recv;
                    string[] msgs = recv.Split('@');
                    ori = msgs[0];
                    pos = msgs[1];

                    /*
                     * if (msgs[0].Split(' ').Length == 4)
                     * {
                     *  ori = msgs[0];
                     *  pos = msgs[1];
                     * }
                     * else {
                     *  pos = msgs[0];
                     *  ori = msgs[1];
                     * }*/
                }
                soc.Close();
            }
            catch (Exception e)
            {
                //Console.WriteLine(e);
                Debug.Log(e);
            }
        }
Beispiel #42
0
    public static void LoadStaticData(System.IO.Stream fs)
    {
        if (artifactsList == null)
        {
            artifactsList = new List <Artifact>();
        }
        else
        {
            artifactsList.Clear();
        }
        var data = new byte[4];

        fs.Read(data, 0, 4);
        int artsCount = System.BitConverter.ToInt32(data, 0);

        int LENGTH = 23;

        while (artsCount > 0)
        {
            data = new byte[LENGTH];
            fs.Read(data, 0, LENGTH);
            var a = new Artifact(
                System.BitConverter.ToSingle(data, 0), // stability
                System.BitConverter.ToSingle(data, 4), //saturation
                System.BitConverter.ToSingle(data, 8), //frequency
                (Path)data[12]
                );
            a.ID         = System.BitConverter.ToInt32(data, 13);
            a.researched = data[17] == 1;
            a.status     = (ArtifactStatus)data[18];
            int bytesCount = System.BitConverter.ToInt32(data, 19); //выдаст количество байтов, не длину строки
            if (bytesCount > 0)
            {
                data = new byte[bytesCount];
                fs.Read(data, 0, bytesCount);
                System.Text.Decoder d = System.Text.Encoding.Default.GetDecoder();
                var chars             = new char[d.GetCharCount(data, 0, bytesCount)];
                d.GetChars(data, 0, bytesCount, chars, 0, true);
                a.name = new string(chars);
            }
            artsCount++;
        }

        fs.Read(data, 0, 4);
        nextID = System.BitConverter.ToInt32(data, 0);
    }
Beispiel #43
0
            public static string Decrypt(string cipherText, string passPhrasee = "ASD")
            {
                var rand = cipherText.Substring(0, 6);


                string passPhrase = passPhrasee;


                System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
                System.Text.Decoder      utf8Decode = encoder.GetDecoder();
                byte[] todecode_byte = Convert.FromBase64String(cipherText.Decode());
                int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

                char[] decoded_char = new char[charCount];
                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
                string result = new String(decoded_char);

                return(result);
            }
Beispiel #44
0
 public static string Base64Decode(string data)
 {
     try
     {
         System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
         System.Text.Decoder      utf8Decode = encoder.GetDecoder();
         data = data.Replace("-", "+").Replace("_", "/");
         byte[] todecode_byte = Convert.FromBase64String(data);
         int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
         char[] decoded_char  = new char[charCount];
         utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
         string result = new String(decoded_char);
         return(result);
     }
     catch (Exception e)
     {
         return("");
     }
 }
Beispiel #45
0
    String storeProfileImage(String _userImage, String _userID)
    {
        string profileImgURL = "";

        if (_userImage != "")
        {
            string sSavePath = "App_Resources/";
            System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
            System.Text.Decoder      utf8Decode = encoder.GetDecoder();
            byte[] ret = Convert.FromBase64String(_userImage);

            // Save the stream to disk
            System.IO.FileStream newFile = new System.IO.FileStream(Server.MapPath(sSavePath + _userID + ".jpg"), System.IO.FileMode.Create);
            newFile.Write(ret, 0, ret.Length);
            newFile.Close();
            profileImgURL = "http://192.168.69.1/MTutorService/App_Resources/" + _userID + ".jpg";
        }
        return(profileImgURL);
    }
Beispiel #46
0
    public void LoginAccess()
    {
        string userName = usernameTxt.text + ";" + CalculateMD5Hash(passwordTxt.text);
        int    i        = 0;

        Socket soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

        System.Net.IPAddress  ipAdd    = System.Net.IPAddress.Parse("192.168.1.157");
        System.Net.IPEndPoint remoteEP = new IPEndPoint(ipAdd, 10000);
        soc.Connect(remoteEP);
        outputTxt.text = "Connectected to server, authenticating...";

        i++;

        byte[] byData = System.Text.Encoding.ASCII.GetBytes(userName);
        soc.Send(byData);

        byte[] buffer = new byte[1024];
        int    iRx    = soc.Receive(buffer);

        char[] chars = new char[iRx];

        System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
        int charLen           = d.GetChars(buffer, 0, iRx, chars, 0);

        System.String recv = new System.String(chars);
        if (recv == "s")
        {
            outputTxt.text = "Connection Success! Logging in...";
            SceneManager.LoadScene("mainScreen", LoadSceneMode.Single);
            iRx = soc.Receive(buffer);
            char[] chars2 = new char[iRx];

            System.Text.Decoder d2 = System.Text.Encoding.UTF8.GetDecoder();
            int           charLen2 = d.GetChars(buffer, 0, iRx, chars2, 0);
            System.String recv2    = new System.String(chars2);
            i++;
        }
        else
        {
            outputTxt.text = "Invalid Username or Password, try again.";
        }
    }
        public string decryptPassword(string sData)
        {
            System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
            System.Text.Decoder      utf8Decode = encoder.GetDecoder();
            int mod4 = sData.Length % 4;

            if (mod4 > 0)
            {
                sData += new string('=', 4 - mod4);
            }
            byte[] todecode_byte = Convert.FromBase64String(sData);
            int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);

            char[] decoded_char = new char[charCount];
            utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
            string result = new String(decoded_char);

            return(result);
        }
Beispiel #48
0
        private static string base64Decode(string sData)
        {
            try
            {
                System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
                System.Text.Decoder      utf8Decode = encoder.GetDecoder();
                byte[] todecode_byte = Convert.FromBase64String(sData);
                int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
                char[] decoded_char  = new char[charCount];
                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
                string result = new String(decoded_char);

                return(result);
            }
            catch
            {
                throw new InvalidCastException("Error decoding DB password");
            }
        }
Beispiel #49
0
        /// <summary>
        /// Decodes a base64 string
        /// </summary>
        /// <param name="data">string that will be converted</param>
        /// <returns>true if the conversion succeeded or false if it didnt</returns>
        public static bool Base64StringDecode(string data)
        {
            try
            {
                System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
                System.Text.Decoder      utf8Decode = encoder.GetDecoder();

                byte[] todecode_byte = System.Convert.FromBase64String(data);
                int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
                char[] decoded_char  = new char[charCount];
                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
                data = new String(decoded_char);
                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Beispiel #50
0
        /*
         * Method        : cmdReceiveData
         * Returns       : none
         * Parameters    : none
         * Description   : recieves data from the previously connected address
         */
        private void cmdReceiveData()
        {
            try
            {
                byte[] buffer = new byte[1024];
                int    iRx    = m_socWorker.Receive(buffer);
                char[] chars  = new char[iRx];

                System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                int           charLen = d.GetChars(buffer, 0, iRx, chars, 0);
                System.String szData  = new System.String(chars);
                IDValidLabel.Text = szData;
            }
            catch (System.Net.Sockets.SocketException se)
            {
                log.logger(se.Message);
                MessageBox.Show(se.Message);
            }
        }
Beispiel #51
0
        /// <summary>
        /// This the call back function which will be invoked when the socket
        //  detects any client writing of data on the stream
        /// </summary>
        /// <param name="asyn"></param>
        public void OnDataReceived(IAsyncResult asyn)
        {
            try
            {
                SocketPacket socketData = (SocketPacket)asyn.AsyncState;

                int iRx = 0;
                // Complete the BeginReceive() asynchronous call by EndReceive() method
                // which will return the number of characters written to the stream
                // by the client
                iRx = socketData.m_currentSocket.EndReceive(asyn);
                char[] chars          = new char[iRx + 1];
                System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                int charLen           = d.GetChars(socketData.dataBuffer,
                                                   0, iRx, chars, 0);
                System.String szData = new System.String(chars);

                this.Invoke(new System.Action(delegate()
                {
                    richTextBoxReceivedMsg.AppendText(szData);
                    //when we are sure we received the entire message
                    //pass the Object received into parameter
                    //after removing the flag indicating the end of message
                    if (richTextBoxReceivedMsg.Text.Contains("ENDOFMESSAGE"))
                    {
                        RetrieveReceivedEventData(
                            richTextBoxReceivedMsg.Text.Remove(richTextBoxReceivedMsg.Text.IndexOf("ENDOFMESSAGE"), 12),
                            socketData.m_currentSocket.RemoteEndPoint
                            );
                    }
                }));
                // Continue the waiting for data on the Socket
                WaitForData(socketData.m_currentSocket);
            }
            catch (ObjectDisposedException)
            {
                System.Diagnostics.Debugger.Log(0, "1", "\nOnDataReceived: Socket has been closed\n");
            }
            catch (SocketException se)
            {
                MessageBox.Show(se.Message);
            }
        }
Beispiel #52
0
 private void Init(Process process, Stream stream, UserCallBack callback, Encoding encoding, int bufferSize)
 {
     this.process      = process;
     this.stream       = stream;
     this.encoding     = encoding;
     this.userCallBack = callback;
     this.decoder      = encoding.GetDecoder();
     if (bufferSize < 0x80)
     {
         bufferSize = 0x80;
     }
     this.byteBuffer         = new byte[bufferSize];
     this._maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize);
     this.charBuffer         = new char[this._maxCharsPerBuffer];
     this.cancelOperation    = false;
     this.eofEvent           = new ManualResetEvent(false);
     this.sb = null;
     this.bLastCarriageReturn = false;
 }
Beispiel #53
0
 public SerialPort()
 {
     this.baudRate = 0x2580;
     this.dataBits = 8;
     this.stopBits = System.IO.Ports.StopBits.One;
     this.portName = "COM1";
     this.encoding = System.Text.Encoding.ASCII;
     this.decoder  = System.Text.Encoding.ASCII.GetDecoder();
     this.maxByteCountForSingleChar = System.Text.Encoding.ASCII.GetMaxByteCount(1);
     this.readTimeout            = -1;
     this.writeTimeout           = -1;
     this.receivedBytesThreshold = 1;
     this.parityReplace          = 0x3f;
     this.newLine         = "\n";
     this.readBufferSize  = 0x1000;
     this.writeBufferSize = 0x800;
     this.inBuffer        = new byte[0x400];
     this.oneChar         = new char[1];
 }
Beispiel #54
0
        private void button10_Click_1(object sender, EventArgs e)
        {
            try
            {
                ButUpload.Enabled = false;
                dtgvFile.Rows.Clear();
                if (files == null)
                {
                    return;
                }
                byte[] share;
                string Str_share = "Share@";
                foreach (FileInfo file in files)
                {
                    share      = new byte[1024];
                    Str_share += file.Name + "@" + file.Length.ToString() + "@" + UserName;
                    share      = System.Text.Encoding.ASCII.GetBytes(Str_share);
                    this.S_loginConnect.Send(share);
                    Str_share = "Share@";

                    //Receive "Next" to :
                    byte[] Next                = new byte[1024];
                    int    i_Next              = this.S_loginConnect.Receive(Next);
                    char[] chars_Next          = new char[i_Next];
                    System.Text.Decoder d_Next = System.Text.Encoding.UTF8.GetDecoder();
                    int           charLenNext  = d_Next.GetChars(Next, 0, i_Next, chars_Next, 0);
                    System.String S_Next       = new System.String(chars_Next);
                    if (S_Next != "Next")
                    {
                        break;
                    }
                    else
                    {
                        dtgvFile.Rows.Add(file.Name, file.Length, file.Exists);
                    }
                }
                //MessageBox.Show("Upload Complete!", "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (SocketException)
            {
            }
        }
Beispiel #55
0
        public string base64Decode(string sData)
        {
            System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
            System.Text.Decoder      utf8Decode = encoder.GetDecoder();
            try
            {
                byte[] todecode_byte = Convert.FromBase64String(sData);

                int    charCount    = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
                char[] decoded_char = new char[charCount];
                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
                string result = new String(decoded_char);
                return(result);
            }
            catch (Exception err)
            {
                //Response.Redirect("~/error.aspx");
                return("");
            }
        }
 protected string decodepwd(string depas)
 {
     try
     {
         System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
         System.Text.Decoder      utf8Decode = encoder.GetDecoder();
         byte[] todecode_byte = Convert.FromBase64String(depas);
         int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
         char[] decoded_char  = new char[charCount];
         utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
         string result = new String(decoded_char);
         return(result);
     }
     catch (Exception ex)
     {
         CreateLogFile log = new CreateLogFile();
         log.ErrorLog(Server.MapPath("../Logs/Errorlog"), "Decode method of AlumniProfileHome page for " + Session["loginname"] + ":" + ex.Message);
         return("conversion error");
     }
 }
    private string Decryptdata(string encryptpwd)
    {
        try
        {
            string decryptpwd = string.Empty;

            UTF8Encoding        encodepwd  = new UTF8Encoding();
            System.Text.Decoder utf8Decode = encodepwd.GetDecoder();
            byte[] todecode_byte           = Convert.FromBase64String(encryptpwd);
            int    charCount    = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
            char[] decoded_char = new char[charCount];
            utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
            decryptpwd = new String(decoded_char);
            return(decryptpwd);
        }
        catch
        {
            return(null);
        }
    }
Beispiel #58
0
 protected virtual void Dispose(bool disposing)
 {
     if (disposing && (this.stream != null))
     {
         this.stream.Close();
     }
     if (this.stream != null)
     {
         this.stream     = null;
         this.encoding   = null;
         this.decoder    = null;
         this.byteBuffer = null;
         this.charBuffer = null;
     }
     if (this.eofEvent != null)
     {
         this.eofEvent.Close();
         this.eofEvent = null;
     }
 }
        //public static string profileidEncrypt(string clearText)
        //{
        //    string EncryptionKey = "MAKV2SPBNI99212";
        //    byte[] clearBytes = Encoding.Unicode.GetBytes(clearText);
        //    using (Aes encryptor = Aes.Create())
        //    {
        //        Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
        //        encryptor.Key = pdb.GetBytes(32);
        //        encryptor.IV = pdb.GetBytes(16);

        //        using (MemoryStream ms = new MemoryStream())
        //        {
        //            using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
        //            {
        //                cs.Write(clearBytes, 0, clearBytes.Length);
        //                cs.Close();
        //            }
        //            clearText = Convert.ToBase64String(ms.ToArray());
        //        }
        //    }

        //    return clearText;
        //}

        public static string base64Decode(string data)
        {
            try
            {
                data = data.Replace("100", "=").Replace("200", "+").Replace("300", "#").Replace("400", "!").Replace("500", ";").Replace("600", "'").Replace("700", "/").Replace("800", "\\");
                System.Text.UTF8Encoding encoder    = new System.Text.UTF8Encoding();
                System.Text.Decoder      utf8Decode = encoder.GetDecoder();

                byte[] todecode_byte = Convert.FromBase64String(data);
                int    charCount     = utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length);
                char[] decoded_char  = new char[charCount];
                utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0);
                string result = new String(decoded_char);
                return(result);
            }
            catch (Exception e)
            {
                throw new Exception("Error in base64Decode" + e.Message);
            }
        }
 private void Init(Stream stream, Encoding encoding, bool detectEncodingFromByteOrderMarks, int bufferSize)
 {
     this.stream   = stream;
     this.encoding = encoding;
     this.decoder  = encoding.GetDecoder();
     if (bufferSize < 0x80)
     {
         bufferSize = 0x80;
     }
     this.byteBuffer         = new byte[bufferSize];
     this._maxCharsPerBuffer = encoding.GetMaxCharCount(bufferSize);
     this.charBuffer         = new char[this._maxCharsPerBuffer];
     this.byteLen            = 0;
     this.bytePos            = 0;
     this._detectEncoding    = detectEncodingFromByteOrderMarks;
     this._preamble          = encoding.GetPreamble();
     this._checkPreamble     = this._preamble.Length > 0;
     this._isBlocked         = false;
     this._closable          = true;
 }