private GetChars ( byte bytes, int byteCount, char chars, int charCount ) : int | ||
bytes | byte | |
byteCount | int | |
chars | char | |
charCount | int | |
return | int |
internal String ReadString() { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); int length = ReadInt(); char[] chars = encoding.GetChars(data, offset, length); offset += length; return(new String(chars)); }
/// <summary> /// Base64 string decoder /// </summary> /// <param name="text">The text string to decode</param> /// <returns>The decoded string</returns> public static string Base64Decode(this string text) { Decoder decoder = new UTF8Encoding().GetDecoder(); byte[] bytes = Convert.FromBase64String(text); char[] chars = new char[decoder.GetCharCount(bytes, 0, bytes.Length)]; decoder.GetChars(bytes, 0, bytes.Length, chars, 0); return new String(chars); }
protected string ConvertBytesToUTF8(string str) { UTF8Encoding utf8 = new UTF8Encoding(); byte[] bytes = Convert.FromBase64String(str); int charCount = utf8.GetCharCount(bytes); Char[] chars = new Char[charCount]; utf8.GetChars(bytes, 0, bytes.Length, chars, 0); return new String(chars); }
public void PosTest2() { Byte[] bytes; Char[] chars = new Char[] { }; UTF8Encoding utf8 = new UTF8Encoding(); int byteCount = utf8.GetByteCount(chars, 0, 0); bytes = new Byte[byteCount]; int charsEncodedCount = utf8.GetChars(bytes, 0, 0, chars, 0); Assert.Equal(0, charsEncodedCount); }
public static string DecodeFromBase64(this string input) { Decoder decoder = new UTF8Encoding().GetDecoder(); byte[] bytes = Convert.FromBase64String(input); int charCount = decoder.GetCharCount(bytes, 0, bytes.Length); char[] chars = new char[charCount]; decoder.GetChars(bytes, 0, bytes.Length, chars, 0); return new String(chars); }
public void TestDecodingGetChars1() { UTF8Encoding utf8Enc = new UTF8Encoding (); // 41 E2 89 A2 CE 91 2E may be decoded as "A<NOT IDENTICAL TO><ALPHA>." // see (RFC 2044) byte[] utf8Bytes = new byte [] {0x41, 0xE2, 0x89, 0xA2, 0xCE, 0x91, 0x2E}; char[] UniCodeChars = utf8Enc.GetChars(utf8Bytes); Assertion.AssertEquals ("UTF #1", 0x0041, UniCodeChars [0]); Assertion.AssertEquals ("UTF #2", 0x2262, UniCodeChars [1]); Assertion.AssertEquals ("UTF #3", 0x0391, UniCodeChars [2]); Assertion.AssertEquals ("UTF #4", 0x002E, UniCodeChars [3]); }
public static string ToString(sbyte[] sbytes) { var bytes = new byte[sbytes.Length]; int i; for (i = 0; i < bytes.Length && sbytes[i] != '\0'; i++) bytes[i] = (byte)sbytes[i]; var bytesUntilNull = new byte[i]; Array.Copy(bytes, bytesUntilNull, i); var encoding = new UTF8Encoding(); return new string(encoding.GetChars(bytesUntilNull)); }
public void PosTest1() { Byte[] bytes; Char[] chars = new Char[] { '\u0023', '\u0025', '\u03a0', '\u03a3' }; UTF8Encoding utf8 = new UTF8Encoding(); int byteCount = utf8.GetByteCount(chars, 1, 2); bytes = new Byte[byteCount]; int charsEncodedCount = utf8.GetChars(bytes, 1, 2, chars, 0); }
static public int GetChars__A_Byte(IntPtr l) { try { System.Text.UTF8Encoding self = (System.Text.UTF8Encoding)checkSelf(l); System.Byte[] a1; checkArray(l, 2, out a1); var ret = self.GetChars(a1); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
/// <summary> /// Decode the UTF-8 string beginning at pos within the buffer. When complete, pos will point /// to the byte immediately after the string in the buffer. /// </summary> /// <param name="src"></param> /// <param name="pos"></param> /// <returns></returns> public static string DecodeString(byte[] src, ref int pos) { var encoder = new UTF8Encoding(); var sb = new StringBuilder(); int length = Frame.DecodeInt16(src, ref pos); if (length > 0) { int start = pos; pos += length; char[] chars = encoder.GetChars(src, start, length); sb.Append(chars); } return sb.ToString(); }
public void NegTest1() { Byte[] bytes; Char[] chars = new Char[] { '\u0023', '\u0025', '\u03a0', '\u03a3' }; UTF8Encoding utf8 = new UTF8Encoding(); int byteCount = utf8.GetByteCount(chars, 1, 2); bytes = null; Assert.Throws<ArgumentNullException>(() => { int charsEncodedCount = utf8.GetChars(bytes, 1, 2, chars, 0); }); }
public static String FromBase64(this String myBase64String) { try { var _UTF8Decoder = new UTF8Encoding().GetDecoder(); var _Bytes = Convert.FromBase64String(myBase64String); var _DecodedChars = new Char[_UTF8Decoder.GetCharCount(_Bytes, 0, _Bytes.Length)]; _UTF8Decoder.GetChars(_Bytes, 0, _Bytes.Length, _DecodedChars, 0); return new String(_DecodedChars); } catch (Exception e) { throw new Exception("Error in base64Decode" + e.Message, e); } }
public override void Write(byte[] /*!*/ buffer, int offset, int count) { if (_consoleType == ConsoleStreamType.Output) { _io.OutputStream.Write(buffer, offset, count); } else { _io.ErrorStream.Write(buffer, offset, count); } //RHO if (!(count == 1 && buffer[0] == 10 || buffer[0] == 13)) { Encoding enc = new System.Text.UTF8Encoding(); char[] str = enc.GetChars(buffer, offset, count); System.Diagnostics.Debug.WriteLine(new String(str)); } //RHO }
private string ReadAsciiString(BinaryReader reader) { byte b = reader.ReadByte(); byte[] bt = new byte[b]; for (byte z = 0; z < b; z++) { byte c = reader.ReadByte(); bt[z] = c; } var encoding = Encoding.GetEncoding(1251); var coding = new System.Text.UTF8Encoding(false); var utf = Encoding.Convert(encoding, coding, bt); // Convert the new byte[] into a char[] and then into a string. char[] utfChars = new char[coding.GetCharCount(utf, 0, utf.Length)]; coding.GetChars(utf, 0, utf.Length, utfChars, 0); return(new string(utfChars)); }
static public int GetChars__A_Byte__Int32__Int32__A_Char__Int32(IntPtr l) { try { System.Text.UTF8Encoding self = (System.Text.UTF8Encoding)checkSelf(l); System.Byte[] a1; checkArray(l, 2, out a1); System.Int32 a2; checkType(l, 3, out a2); System.Int32 a3; checkType(l, 4, out a3); System.Char[] a4; checkArray(l, 5, out a4); System.Int32 a5; checkType(l, 6, out a5); var ret = self.GetChars(a1, a2, a3, a4, a5); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
// Added by RPH for Borland 2006 // The assumption is that we will decode using UTF8 based on // "The Firebird Book" by Helen Borrie. public int GetClob(short index, ref char[] buffer, ref int nullInd, int iLength) { this.CheckPosition(); this.CheckIndex(index); this.GetIsNull(index, ref nullInd); if (nullInd == 0) { // Not null, get data int realLength = iLength; byte[] byteArray = this.row[index].GetBinary(); if (iLength > byteArray.Length) { // Fix length realLength = byteArray.Length; } UTF8Encoding encoder = new UTF8Encoding(); encoder.GetChars(byteArray, 0, realLength, buffer, 0); } return 0; }
public override void Write(byte[]/*!*/ buffer, int offset, int count) { if (_consoleType == ConsoleStreamType.Output) { _io.OutputStream.Write(buffer, offset, count); } else { _io.ErrorStream.Write(buffer, offset, count); } //RHO if (!(count == 1 && buffer[0] == 10 || buffer[0] == 13)) { Encoding enc = new System.Text.UTF8Encoding(); char[] str = enc.GetChars(buffer, offset, count); System.Diagnostics.Debug.WriteLine(new String(str)); } //RHO }
private int Dispose(string keystring, bool run) { int num18 = 0; if (keystring.Length == 0) { return 0; } try { byte[] buffer1 = Convert.FromBase64String(keystring); byte[] buffer2 = new byte[0x10] { 0x21, 0x53, 0x1b, 0x5f, 0x1c, 0x54, 0xc5, 0xa9, 0x27, 0x5d, 0x4b, 0x69, 0x52, 0x61, 0x31, 0x2c }; MemoryStream stream1 = new MemoryStream(buffer1); RijndaelManaged managed1 = new RijndaelManaged(); CryptoStream stream2 = new CryptoStream(stream1, managed1.CreateDecryptor(buffer2, buffer2), CryptoStreamMode.Read); byte[] buffer3 = new byte[0x1000]; int num1 = stream2.Read(buffer3, 0, buffer3.Length); System.Text.Decoder decoder1 = new UTF8Encoding().GetDecoder(); char[] chArray1 = new char[decoder1.GetCharCount(buffer3, 0, num1)]; int num2 = decoder1.GetChars(buffer3, 0, num1, chArray1, 0); string text1 = new string(chArray1, 0, num2); char[] chArray2 = new char[1] { '|' }; string[] textArray1 = text1.Split(chArray2); int num3 = textArray1.Length; DateTime time1 = DateTime.Today; CultureInfo info1 = CultureInfo.CurrentCulture; if (run) { if (num3 < 11) { return 0; } string text2 = (num3 > 0) ? textArray1[0] : ""; string text3 = (num3 > 1) ? textArray1[1] : ""; int num4 = (num3 > 2) ? this.ParseInt(textArray1[2]) : -1; int num5 = (num3 > 3) ? this.ParseInt(textArray1[3]) : -1; int num6 = (num3 > 9) ? this.ParseInt(textArray1[9]) : 7; string text4 = (num3 > 10) ? textArray1[10] : "E"; int num7 = (num3 > 11) ? this.ParseInt(textArray1[11]) : 0x270f; int num8 = (num3 > 12) ? this.ParseInt(textArray1[12]) : 1; int num9 = (num3 > 13) ? this.ParseInt(textArray1[13]) : 1; int num10 = (num3 > 14) ? this.ParseInt(textArray1[14]) : 360; AssemblyName name1 = Assembly.GetExecutingAssembly().GetName(); if ((text3.Length > 0) && (string.Compare(text3, name1.Name, true, info1) != 0)) { return 0; } if (num4 >= 0) { if (name1.Version.Major > num4) { return 0; } if (((num5 >= 0) && (name1.Version.Major == num4)) && (name1.Version.Minor > num5)) { return 0; } } if (text4[0] == 'E') { return 0; } if ((text4[0] == 'R') && ((DiagramView.myVersionAssembly == null) || (string.Compare(text2, DiagramView.myVersionAssembly.GetName().Name, true, info1) != 0))) { return 0; } DateTime time2 = new DateTime(num7, num8, num9); if (time1.AddDays((double)num10) <= time2) { return 4; } if (time1.AddDays(7) <= time2) { return 6; } if (time1.AddDays((double)-num6) <= time2) { return 5; } goto Label_0522; } string text5 = (num3 > 1) ? textArray1[1] : ""; int num11 = (num3 > 2) ? this.ParseInt(textArray1[2]) : -1; int num12 = (num3 > 3) ? this.ParseInt(textArray1[3]) : -1; string text6 = (num3 > 4) ? textArray1[4] : ""; string text7 = (num3 > 5) ? textArray1[5] : ""; int num13 = (num3 > 6) ? this.ParseInt(textArray1[6]) : 1; int num14 = (num3 > 7) ? this.ParseInt(textArray1[7]) : 1; int num15 = (num3 > 8) ? this.ParseInt(textArray1[8]) : 1; DateTime time3 = new DateTime(num13, num14, num15); int num16 = (num3 > 9) ? this.ParseInt(textArray1[9]) : 7; string text8 = (num3 > 10) ? textArray1[10] : "E"; int num17 = (num3 > 14) ? this.ParseInt(textArray1[14]) : 360; AssemblyName name2 = Assembly.GetExecutingAssembly().GetName(); if ((text5.Length > 0) && (string.Compare(text5, name2.Name, true, info1) != 0)) { return 0; } if (num11 >= 0) { if (name2.Version.Major > num11) { return 0; } if (((num12 >= 0) && (name2.Version.Major == num11)) && (name2.Version.Minor > num12)) { return 0; } } if ((text6.Length > 0) && (string.Compare(Environment.MachineName, text6, true, info1) != 0)) { return 0; } if ((text7.Length > 0) && (string.Compare(Environment.UserName, text7, true, info1) != 0)) { return 0; } if (text8[0] == 'B') { if (time1.AddDays((double)num17) <= time3) { return 4; } if (time1.AddDays(7) <= time3) { return 6; } if (time1.AddDays((double)-num16) <= time3) { return 5; } goto Label_0522; } if (time1.AddDays(7) <= time3) { return 2; } if (time1.AddDays((double)-num16) > time3) { goto Label_0522; } num18 = 1; } catch (Exception) { } return num18; Label_0522: return 0; }
public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) { return(encoding.GetChars(bytes, byteIndex, byteCount, chars, charIndex, this)); }
/// <summary> /// Estimate the quality of a password. /// </summary> /// <param name="pbUnprotectedUtf8">Password to check, UTF-8 encoded.</param> /// <returns>Estimated bit-strength of the password.</returns> public static uint EstimatePasswordBits(byte[] pbUnprotectedUtf8) { if(pbUnprotectedUtf8 == null) { Debug.Assert(false); return 0; } UTF8Encoding utf8 = new UTF8Encoding(); char[] vChars = utf8.GetChars(pbUnprotectedUtf8); uint uResult = EstimatePasswordBits(vChars); Array.Clear(vChars, 0, vChars.Length); return uResult; }
private static char[] ReadUTF8Char(Stream s) { byte[] bytes = new byte[4]; var enc = new UTF8Encoding(false, true); if (1 != s.Read(bytes, 0, 1)) return null; if (bytes[0] <= 0x7F) //Single byte character { return enc.GetChars(bytes, 0, 1); } else { var remainingBytes = ((bytes[0] & 240) == 240) ? 3 : ( ((bytes[0] & 224) == 224) ? 2 : ( ((bytes[0] & 192) == 192) ? 1 : -1 )); if (remainingBytes == -1) return null; s.Read(bytes, 1, remainingBytes); return enc.GetChars(bytes, 0, remainingBytes + 1); } }
internal String ReadString() { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); int length = ReadInt(); char[] chars = encoding.GetChars(data, offset, length); offset += length; return new String(chars); }
public bool TryReadChars(char[] chars, int offset, int count, out int actual) { Fx.Assert(offset + count <= chars.Length, string.Format("offset '{0}' + count '{1}' MUST BE <= chars.Length '{2}'", offset, count, chars.Length)); if (type == ValueHandleType.Unicode) return TryReadUnicodeChars(chars, offset, count, out actual); if (type != ValueHandleType.UTF8) { actual = 0; return false; } int charOffset = offset; int charCount = count; byte[] bytes = bufferReader.Buffer; int byteOffset = this.offset; int byteCount = this.length; bool insufficientSpaceInCharsArray = false; while (true) { while (charCount > 0 && byteCount > 0) { // fast path for codepoints U+0000 - U+007F byte b = bytes[byteOffset]; if (b >= 0x80) break; chars[charOffset] = (char)b; byteOffset++; byteCount--; charOffset++; charCount--; } if (charCount == 0 || byteCount == 0 || insufficientSpaceInCharsArray) break; int actualByteCount; int actualCharCount; UTF8Encoding encoding = new UTF8Encoding(false, true); try { // If we're asking for more than are possibly available, or more than are truly available then we can return the entire thing if (charCount >= encoding.GetMaxCharCount(byteCount) || charCount >= encoding.GetCharCount(bytes, byteOffset, byteCount)) { actualCharCount = encoding.GetChars(bytes, byteOffset, byteCount, chars, charOffset); actualByteCount = byteCount; } else { Decoder decoder = encoding.GetDecoder(); // Since x bytes can never generate more than x characters this is a safe estimate as to what will fit actualByteCount = Math.Min(charCount, byteCount); // We use a decoder so we don't error if we fall across a character boundary actualCharCount = decoder.GetChars(bytes, byteOffset, actualByteCount, chars, charOffset); // We might've gotten zero characters though if < 4 bytes were requested because // codepoints from U+0000 - U+FFFF can be up to 3 bytes in UTF-8, and represented as ONE char // codepoints from U+10000 - U+10FFFF (last Unicode codepoint representable in UTF-8) are represented by up to 4 bytes in UTF-8 // and represented as TWO chars (high+low surrogate) // (e.g. 1 char requested, 1 char in the buffer represented in 3 bytes) while (actualCharCount == 0) { // Note the by the time we arrive here, if actualByteCount == 3, the next decoder.GetChars() call will read the 4th byte // if we don't bail out since the while loop will advance actualByteCount only after reading the byte. if (actualByteCount >= 3 && charCount < 2) { // If we reach here, it means that we're: // - trying to decode more than 3 bytes and, // - there is only one char left of charCount where we're stuffing decoded characters. // In this case, we need to back off since decoding > 3 bytes in UTF-8 means that we will get 2 16-bit chars // (a high surrogate and a low surrogate) - the Decoder will attempt to provide both at once // and an ArgumentException will be thrown complaining that there's not enough space in the output char array. // actualByteCount = 0 when the while loop is broken out of; decoder goes out of scope so its state no longer matters insufficientSpaceInCharsArray = true; break; } else { Fx.Assert(byteOffset + actualByteCount < bytes.Length, string.Format("byteOffset {0} + actualByteCount {1} MUST BE < bytes.Length {2}", byteOffset, actualByteCount, bytes.Length)); // Request a few more bytes to get at least one character actualCharCount = decoder.GetChars(bytes, byteOffset + actualByteCount, 1, chars, charOffset); actualByteCount++; } } // Now that we actually retrieved some characters, figure out how many bytes it actually was actualByteCount = encoding.GetByteCount(chars, charOffset, actualCharCount); } } catch (FormatException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateEncodingException(bytes, byteOffset, byteCount, exception)); } // Advance byteOffset += actualByteCount; byteCount -= actualByteCount; charOffset += actualCharCount; charCount -= actualCharCount; } this.offset = byteOffset; this.length = byteCount; actual = (count - charCount); return true; }
public bool TryReadChars(char[] chars, int offset, int count, out int actual) { if (_type == ValueHandleType.Unicode) return TryReadUnicodeChars(chars, offset, count, out actual); if (_type != ValueHandleType.UTF8) { actual = 0; return false; } int charOffset = offset; int charCount = count; byte[] bytes = _bufferReader.Buffer; int byteOffset = _offset; int byteCount = _length; while (true) { while (charCount > 0 && byteCount > 0) { byte b = bytes[byteOffset]; if (b >= 0x80) break; chars[charOffset] = (char)b; byteOffset++; byteCount--; charOffset++; charCount--; } if (charCount == 0 || byteCount == 0) break; int actualByteCount; int actualCharCount; UTF8Encoding encoding = new UTF8Encoding(false, true); try { // If we're asking for more than are possibly available, or more than are truly available then we can return the entire thing if (charCount >= encoding.GetMaxCharCount(byteCount) || charCount >= encoding.GetCharCount(bytes, byteOffset, byteCount)) { actualCharCount = encoding.GetChars(bytes, byteOffset, byteCount, chars, charOffset); actualByteCount = byteCount; } else { Decoder decoder = encoding.GetDecoder(); // Since x bytes can never generate more than x characters this is a safe estimate as to what will fit actualByteCount = Math.Min(charCount, byteCount); // We use a decoder so we don't error if we fall across a character boundary actualCharCount = decoder.GetChars(bytes, byteOffset, actualByteCount, chars, charOffset); // We might've gotten zero characters though if < 3 chars were requested // (e.g. 1 char requested, 1 char in the buffer represented in 3 bytes) while (actualCharCount == 0) { // Request a few more bytes to get at least one character actualCharCount = decoder.GetChars(bytes, byteOffset + actualByteCount, 1, chars, charOffset); actualByteCount++; } // Now that we actually retrieved some characters, figure out how many bytes it actually was actualByteCount = encoding.GetByteCount(chars, charOffset, actualCharCount); } } catch (FormatException exception) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateEncodingException(bytes, byteOffset, byteCount, exception)); } // Advance byteOffset += actualByteCount; byteCount -= actualByteCount; charOffset += actualCharCount; charCount -= actualCharCount; } _offset = byteOffset; _length = byteCount; actual = (count - charCount); return true; }
public void SetPassword(byte[] pbUtf8) { Debug.Assert(pbUtf8 != null); if(pbUtf8 == null) throw new ArgumentNullException("pbUTF8"); if(m_secString != null) { m_secString.Clear(); UTF8Encoding utf8 = new UTF8Encoding(); char[] vChars = utf8.GetChars(pbUtf8); for(int i = 0; i < vChars.Length; ++i) { m_secString.AppendChar(vChars[i]); vChars[i] = char.MinValue; } } else m_strAlternativeSecString = Encoding.UTF8.GetString(pbUtf8); ShowCurrentPassword(0, 0); }
public char[] ConvetToChar(byte[] toConvert) { UTF8Encoding en = new UTF8Encoding(); return en.GetChars(toConvert); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Processes the directory entry. /// </summary> /// <param name="fId">set to <c>true</c> if its an ID entry, <c>false</c> if its a Name /// entry.</param> /// ------------------------------------------------------------------------------------ private void ProcessDirectoryEntry(bool fId) { long nBasePos = m_stream.Position; int id; int nameRVA; if (fId) { id = m_reader.ReadInt32(); m_TypeStack.Add(id); } else { nameRVA = m_reader.ReadInt32() & 0x7FFFFFFF; m_stream.Position = m_BaseAddress + nameRVA; short nStringLen = m_reader.ReadInt16(); UTF8Encoding encoding = new UTF8Encoding(); byte[] buffer = UnicodeEncoding.Convert(new UnicodeEncoding(), encoding, m_reader.ReadBytes(2 * nStringLen)); string name = new string(encoding.GetChars(buffer)); m_TypeStack.Add(name); m_stream.Position = nBasePos + 4; } int value = m_reader.ReadInt32(); bool fSubDir = (value & 0x80000000) != 0; int nVirtualAddress = value & 0x7FFFFFFF; m_stream.Position = m_BaseAddress + nVirtualAddress; if (fSubDir) ProcessResourceDirectoryTable(); else ProcessDataEntry(); m_TypeStack.RemoveAt(m_TypeStack.Count - 1); m_stream.Position = nBasePos + 8; }
/// <summary> /// Recieves data on the client socket /// Raises the OnNewTweet event when usable data has been received. /// </summary> private void Receive() { while (receivingData) { // Make a buffer in which we recieve the new tweet // The length is determined by having byte[] buffer = new byte[1024]; // This is a blocking call so you best run this function threadded try { socketClient.Receive(buffer); } catch (Exception e) { } // If there's data.. if ((RequestResponse)buffer[0] != RequestResponse.NOP) { if ((RequestResponse)buffer[0] == RequestResponse.SHOW_NEW_TWEET) { System.Text.UTF8Encoding encoding = new System.Text.UTF8Encoding(); char[] characters = encoding.GetChars(buffer); StringBuilder sb = new StringBuilder(); for (int i = 1; i < characters.Length; i++) { if (characters[i] > 31) sb.Append(characters[i]); } if (OnNewTweet != null) OnNewTweet(sb.ToString()); } } // No data, connection probaly has been closed or an exception occured // Probaly not ideal but.. // TODO: Add relistening for client else { receivingData = false; } } }
public static string XmlDocumentToString(XmlDocument doc) { MemoryStream ms = new MemoryStream(); XmlTextWriter writer = new XmlTextWriter(ms,System.Text.Encoding.UTF8); writer.Formatting = Formatting.None; // None / Indented; //writer.Namespaces = false; writer.Indentation = 1; doc.Save(writer); ms.Seek(0,SeekOrigin.Begin); //ASCIIEncoding ascii = new ASCIIEncoding(); UTF8Encoding utf8 = new UTF8Encoding(); return new String(utf8.GetChars(ms.ToArray())); // return doc.InnerXml; }
private static char[] ExtractUTF8(byte[] content, bool abortAfterTermination) { // $03 UTF-8 [UTF-8] encoded Unicode [UNICODE]. Terminated with $00. var data = new List<char>(); var encoder = new UTF8Encoding(); var chars = encoder.GetChars(content, 0, content.Length); foreach (var curChar in chars) { if (abortAfterTermination && curChar == '\u0000') { break; } data.Add(curChar); } return data.ToArray(); }
private char[] ByteArrayToString(byte[] arr) { System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding(); return enc.GetChars(arr); }
private void linkUpdates_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) { if (CurrentlyCheckingForUpdates) { return; } const string url = "http://trainsimframework.org/common/version.txt"; CurrentlyCheckingForUpdates = true; this.Cursor = Cursors.WaitCursor; Application.DoEvents(); try { byte[] bytes = Internet.DownloadBytesFromUrl(url); System.Text.Encoding Encoding = new System.Text.UTF8Encoding(); string Text = new string(Encoding.GetChars(bytes)); if (Text.Length != 0 && Text[0] == '\uFEFF') Text = Text.Substring(1); string[] Lines = Text.Split(new char[] { '\r', '\n' }); if (Lines.Length == 0 || !Lines[0].Equals("$OpenBveVersionInformation", StringComparison.OrdinalIgnoreCase)) { MessageBox.Show(Interface.GetInterfaceString("panel_updates_invalid"), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } else { string StableVersion = "0.0.0.0"; string StableDate = "0000-00-00"; string DevelopmentVersion = "0.0.0.0"; string DevelopmentDate = "0000-00-00"; int i; for (i = 1; i < Lines.Length; i++) { if (Lines[i].Equals("----")) break; int h = Lines[i].IndexOf('='); if (h >= 0) { string a = Lines[i].Substring(0, h).TrimEnd(); string b = Lines[i].Substring(h + 1).TrimStart(); if (a.Equals("version", StringComparison.OrdinalIgnoreCase)) { StableVersion = b; } else if (a.Equals("date", StringComparison.OrdinalIgnoreCase)) { StableDate = b; } else if (a.Equals("developmentversion", StringComparison.OrdinalIgnoreCase)) { DevelopmentVersion = b; } else if (a.Equals("developmentdate", StringComparison.OrdinalIgnoreCase)) { DevelopmentDate = b; } } } StringBuilder StableText = new StringBuilder(); StringBuilder DevelopmentText = new StringBuilder(); int j; for (j = i + 1; j < Lines.Length; j++) { if (Lines[j].Equals("----")) break; StableText.AppendLine(Lines[j]); } for (int k = j + 1; k < Lines.Length; k++) { if (Lines[k].Equals("----")) break; DevelopmentText.AppendLine(Lines[k]); } bool Found = false; if (ManagedContent.CompareVersions(Application.ProductVersion, StableVersion) < 0) { string Message = Interface.GetInterfaceString("panel_updates_new") + StableText.ToString().Trim(); Message = Message.Replace("[version]", StableVersion); Message = Message.Replace("[date]", StableDate); MessageBox.Show(Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information); Found = true; } #pragma warning disable 0162 // Unreachable code if (Program.IsDevelopmentVersion) { if (ManagedContent.CompareVersions(Application.ProductVersion, DevelopmentVersion) < 0) { string Message = Interface.GetInterfaceString("panel_updates_new") + DevelopmentText.ToString().Trim(); Message = Message.Replace("[version]", DevelopmentVersion); Message = Message.Replace("[date]", DevelopmentDate); MessageBox.Show(Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information); Found = true; } } #pragma warning restore 0162 // Unreachable code if (!Found) { string Message = Interface.GetInterfaceString("panel_updates_old"); MessageBox.Show(Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Information); } } } catch (Exception ex) { MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Hand); } this.Cursor = Cursors.Default; CurrentlyCheckingForUpdates = false; }
public string GetVersion() { RunCommand(Command.GEN_VERSION, new byte[] { 0x01 }, 16); Array.Copy(_response, 5, _response, 0, 11); _response[12] = _response[13] = 0; var encoding = new UTF8Encoding(); return new string(encoding.GetChars(_response)); }
private string ReadAllBytes(Stream client, out Dictionary<string,string> header) { var sb = new StringBuilder(); Decoder dec = new UTF8Encoding().GetDecoder(); int contentLength = -1; int dataOffset = -1; int dataBytesRead = 0; header = new Dictionary<string, string>(); try { int len; do { var bufferSeg = new byte[8192]; var chars = new char[8192]; len = client.Read(bufferSeg, 0, bufferSeg.Length); if (len == 0) return null; int clen = dec.GetChars(bufferSeg, 0, len, chars, 0, false); sb.Append(chars, 0, clen); if (dataOffset < 0) // try to parse HTTP header { header = TryExtractingHttpHeader(sb, bufferSeg, len, ref dataBytesRead, ref dataOffset); const string ContentLength = "Content-Length:"; if (header.ContainsKey(ContentLength)) int.TryParse(header[ContentLength], out contentLength); } else dataBytesRead += len; // enforce maximum allowed request size to prevent denial-of-service if (dataBytesRead >= MaxRequestSize) { var buff = Encoding.ASCII.GetBytes("HTTP/1.1 413 Request Entity Too Large\r\n\r\n"); client.Write(buff, 0, buff.Length); Log("Request exceeded maximum allowed size"); return null; } } while (dataOffset < 0 // header not finished || (contentLength >= 0 && dataBytesRead < contentLength) // data not finished || (dataOffset >= 0 && contentLength < 0 && len == 0)); // stalled out stream of unknown length } catch (IOException) { // clients may just close the stream when they're done sending requests on a keep-alive connection } return sb.ToString(); }
private int SendTextSMS (string ClientSerialNo, string SMSKey, string Recepient, string strSenderEmail, string strSenderName, string txtMsg, int canReply) { Object[] obj_params = { ClientSerialNo, SMSKey, Recepient, strSenderEmail, strSenderName, txtMsg, canReply }; WebHeaderCollection req_headers = new WebHeaderCollection(); string req_text = String.Format (RC_req_fmt, obj_params); byte [] req_bytes = new UTF8Encoding().GetBytes (req_text); req_text = null; Uri _req_uri = new Uri (req_uri); HttpWebRequest web_req = (HttpWebRequest) WebRequest.Create (_req_uri); req_headers.Add ("SOAPAction", SoapAction); web_req.Headers = req_headers; web_req.ContentType = "text/xml"; web_req.KeepAlive = false; web_req.UserAgent = "Virtuoso SOAP sample"; web_req.Method = "POST"; web_req.ContentLength = req_bytes.Length; Stream req_str = web_req.GetRequestStream (); req_str.Write (req_bytes, 0, req_bytes.Length); req_str.Flush(); req_bytes = null; HttpWebResponse resp = (HttpWebResponse) web_req.GetResponse (); Encoding enc = new UTF8Encoding (); XmlDocument doc = new XmlDocument (); long clen = resp.ContentLength; Stream resp_stream = resp.GetResponseStream(); String content; if (clen != -1) { byte [] bytes = new byte[clen]; long read = 0; while (read < clen) { read += resp_stream.Read (bytes, (int) read, (int) (clen - read)); } UTF8Encoding enc1 = new UTF8Encoding (false, true); content = new String (enc1.GetChars (bytes)); } else if (typeof (NetworkStream).IsInstanceOfType (resp_stream)) { NetworkStream nstr = resp_stream as NetworkStream; byte [] bytes = new byte[10000]; long read = 0; while (nstr.DataAvailable) { read += nstr.Read (bytes, (int) read, (int) (bytes.Length - read)); } UTF8Encoding enc1 = new UTF8Encoding (false, true); content = new String (enc1.GetChars (bytes, 0, (int) read)); } else { resp_stream.Close(); req_str.Close(); throw new Exception ("don't know how to read the stream"); } resp_stream.Close(); req_str.Close(); doc.LoadXml (content); XmlNode xml_env = doc.DocumentElement; XmlNode xml_body = xml_env["Body", xml_env.NamespaceURI]; XmlNode xml_fault = xml_body["Fault", xml_env.NamespaceURI]; if (xml_fault != null) throw new Exception (xml_fault.InnerText); XmlNode xml_resp = xml_body[SoapResp_name, SoapResp_uri]; XmlNode result = xml_resp[SoapResp_val]; return Int32.Parse (result.InnerXml); }
private string Base64_Decode(string input) { Decoder utf8Decode = new UTF8Encoding().GetDecoder(); byte[] todecode_byte = Convert.FromBase64String(input); char[] decoded_char = new char[utf8Decode.GetCharCount(todecode_byte, 0, todecode_byte.Length)]; utf8Decode.GetChars(todecode_byte, 0, todecode_byte.Length, decoded_char, 0); return new string(decoded_char); }