protected override void ProtectedImport(Stream stream, BufferManager bufferManager) { using (DeadlockMonitor.Lock(this.ThisLock)) { Encoding encoding = new UTF8Encoding(false); byte[] lengthBuffer = new byte[4]; for (; ;) { if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } int length = NetworkConverter.ToInt32(lengthBuffer); byte id = (byte)stream.ReadByte(); using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.CommandMessage) { this.CommandMessages.Add(CommandMessage.Import(rangeStream, bufferManager)); } } } } }
private static Stream RemoveType(Stream stream, string type) { if (stream == null) { throw new ArgumentNullException("stream"); } Encoding encoding = new UTF8Encoding(false); byte[] lengthBuffer = new byte[4]; if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { throw new FormatException(); } int length = NetworkConverter.ToInt32(lengthBuffer); using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { using (StreamReader reader = new StreamReader(rangeStream, encoding)) { if (type != reader.ReadToEnd()) { throw new FormatException(); } } } return(new RangeStream(stream, true)); }
public static void Write(Stream stream, byte type, Stream exportStream) { stream.WriteByte(type); stream.Write(NetworkConverter.GetBytes((int)exportStream.Length), 0, 4); byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(1024 * 4); int length = 0; while ((length = exportStream.Read(buffer, 0, buffer.Length)) > 0) { stream.Write(buffer, 0, length); } } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
public static string GetSignature(Certificate certificate) { if (certificate == null || certificate.Nickname == null || certificate.PublicKey == null) { return(null); } try { if (certificate.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.EcDsaP521_Sha256 || certificate.DigitalSignatureAlgorithm == DigitalSignatureAlgorithm.Rsa2048_Sha256) { using (BufferStream bufferStream = new BufferStream(_bufferManager)) { Signature.WriteString(bufferStream, certificate.Nickname); bufferStream.Write(certificate.PublicKey, 0, certificate.PublicKey.Length); bufferStream.Seek(0, SeekOrigin.Begin); var signature = certificate.Nickname + "@" + NetworkConverter.ToBase64UrlString(Sha256.ComputeHash(bufferStream)); return(_signatureCache.GetValue(signature, certificate)); } } return(null); } catch (Exception) { return(null); } }
public static long GetLong(Stream stream) { if (stream.Length != 8) { throw new ArgumentException(); } byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(8); stream.Read(buffer, 0, 8); return(NetworkConverter.ToInt64(buffer)); } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
public static int GetInt(Stream stream) { if (stream.Length != 4) { throw new ArgumentException(); } byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(4); stream.Read(buffer, 0, 4); return(NetworkConverter.ToInt32(buffer)); } finally { if (buffer != null) { _bufferManager.ReturnBuffer(buffer); } } }
private static ArraySegment <byte>[] FromBuffer(ArraySegment <byte> buffer, BufferManager bufferManager) { List <ArraySegment <byte> > list = new List <ArraySegment <byte> >(); using (MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count)) { byte[] lengthBuffer = new byte[4]; for (; ;) { if (memoryStream.Read(lengthBuffer, 0, 4) < 4) { break; } int length = NetworkConverter.ToInt32(lengthBuffer); byte[] buffer2 = bufferManager.TakeBuffer(length); if (memoryStream.Read(buffer2, 0, length) < length) { break; } list.Add(new ArraySegment <byte>(buffer2, 0, length)); } } return(list.ToArray()); }
private static Stream AddType(Stream stream, string type) { if (stream == null) { throw new ArgumentNullException("stream"); } List <Stream> streams = new List <Stream>(); Encoding encoding = new UTF8Encoding(false); // Type if (type != null) { BufferStream bufferStream = new BufferStream(_bufferManager); bufferStream.SetLength(4); bufferStream.Seek(4, SeekOrigin.Begin); using (WrapperStream wrapperStream = new WrapperStream(bufferStream, true)) using (StreamWriter writer = new StreamWriter(wrapperStream, encoding)) { writer.Write(type); } bufferStream.Seek(0, SeekOrigin.Begin); bufferStream.Write(NetworkConverter.GetBytes((int)bufferStream.Length - 4), 0, 4); streams.Add(bufferStream); } streams.Add(new WrapperStream(stream, true)); return(new UniteStream(streams)); }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager) { Encoding encoding = new UTF8Encoding(false); byte[] lengthBuffer = new byte[4]; for (; ;) { if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } int length = NetworkConverter.ToInt32(lengthBuffer); byte id = (byte)stream.ReadByte(); using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.Id) { byte[] buffer = new byte[rangeStream.Length]; rangeStream.Read(buffer, 0, buffer.Length); this.Id = buffer; } else if (id == (byte)SerializeId.Name) { using (StreamReader reader = new StreamReader(rangeStream, encoding)) { this.Name = reader.ReadToEnd(); } } } } }
private void sendMessage(NetworkMessage networkMessage) { networkMessage.playerInfo.userId = this.clientId; byte[] data = NetworkConverter.Serialize(networkMessage); byte[] header = BitConverter.GetBytes(data.Length); client.GetStream().Write(header, 0, header.Length); client.GetStream().Write(data, 0, data.Length); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value is byte[] item) { return(NetworkConverter.ToBase64UrlString(item)); } return(""); }
public Ipv4(IPAddress ipAddress) { if (ipAddress.AddressFamily != AddressFamily.InterNetwork) { throw new ArgumentException(nameof(ipAddress)); } this.Value = NetworkConverter.ToUInt32(ipAddress.GetAddressBytes()); }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { if (value is string item) { return(NetworkConverter.FromBase64UrlString(item)); } return(Array.Empty <byte>()); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value is long item) { return(NetworkConverter.DecimalToSizeString(item)); } return(NetworkConverter.DecimalToSizeString(0)); }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { if (value is string item) { return((long)Math.Min(Math.Max(NetworkConverter.SizeStringToDecimal(item), long.MinValue), long.MaxValue)); } return((long)0); }
public void TestConvertToIPv6(string ipv6Text, ushort[] ipv6Data) { var ipv6 = NetworkConverter.ToIPv6(ipv6Data); Assert.Equal(ipv6Text, ipv6); var words = NetworkConverter.GetWordsForIPv6(ipv6); Assert.Equal(ipv6Data, words); }
private void Setting_CheckDiskSpace() { bool watchFlag = true; _checkDiskSpaceTimer = new WatchTimer(() => { if (!watchFlag) { return; } try { bool flag = false; if (_amoebaInterfaceManager.Report.Core.Cache.FreeSpace < NetworkConverter.FromSizeString("10GB")) { flag |= true; } if (!flag) { if (_amoebaInterfaceManager.State == ManagerState.Stop) { _amoebaInterfaceManager.Start(); Log.Information("Start"); } } else { if (_amoebaInterfaceManager.State == ManagerState.Start) { _amoebaInterfaceManager.Stop(); Log.Information("Stop"); watchFlag = false; App.Current.Dispatcher.InvokeAsync(() => { if (_dialogService.ShowDialog(LanguagesManager.Instance.MainWindow_SpaceNotFound_Message, MessageBoxButton.OKCancel, MessageBoxImage.Question, MessageBoxResult.Cancel) == MessageBoxResult.OK) { watchFlag = true; } }); } } } catch (Exception e) { Log.Error(e); } }); _checkDiskSpaceTimer.Start(new TimeSpan(0, 0, 0), new TimeSpan(0, 3, 0)); }
private bool CheckUri(string uri) { string host = null; { var match = _regex.Match(uri); if (match.Success) { host = match.Groups[2].Value; } else { var match2 = _regex2.Match(uri); if (match2.Success) { host = match2.Groups[2].Value; } } } if (host == null) { return(false); } IPAddress ip; if (IPAddress.TryParse(host, out ip)) { if (ip.AddressFamily == AddressFamily.InterNetwork) { uint uip = NetworkConverter.ToUInt32(ip.GetAddressBytes()); lock (_thisLock) { if (_settings.Ipv4AddressSet.Contains(uip)) { return(false); } foreach (var range in _settings.Ipv4AddressRangeSet) { if (range.Verify(uip)) { return(false); } } } } } return(true); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { var item = value as long?; if (item == null) { return(null); } return(NetworkConverter.ToSizeString(item.Value)); }
private static string ToBase64String(Stream stream) { using (var targetStream = new RangeStream(stream, true)) using (var safeBuffer = _bufferManager.CreateSafeBuffer((int)targetStream.Length)) { targetStream.Seek(0, SeekOrigin.Begin); targetStream.Read(safeBuffer.Value, 0, (int)targetStream.Length); return(NetworkConverter.ToBase64UrlString(safeBuffer.Value, 0, (int)targetStream.Length)); } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { var item = value as byte[]; if (item == null) { return(null); } return(NetworkConverter.ToHexString(item)); }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count) { lock (this.ThisLock) { for (; ;) { byte id; { byte[] idBuffer = new byte[1]; if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length) { return; } id = idBuffer[0]; } int length; { byte[] lengthBuffer = new byte[4]; if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } length = NetworkConverter.ToInt32(lengthBuffer); } using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.Key) { this.Keys.Add(Key.Import(rangeStream, bufferManager)); } else if (id == (byte)SerializeId.CorrectionAlgorithm) { this.CorrectionAlgorithm = (CorrectionAlgorithm)Enum.Parse(typeof(CorrectionAlgorithm), ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.InformationLength) { this.InformationLength = ItemUtilities.GetInt(rangeStream); } else if (id == (byte)SerializeId.BlockLength) { this.BlockLength = ItemUtilities.GetInt(rangeStream); } else if (id == (byte)SerializeId.Length) { this.Length = ItemUtilities.GetLong(rangeStream); } } } } }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count) { lock (this.ThisLock) { for (; ;) { byte id; { byte[] idBuffer = new byte[1]; if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length) { return; } id = idBuffer[0]; } int length; { byte[] lengthBuffer = new byte[4]; if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } length = NetworkConverter.ToInt32(lengthBuffer); } using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.KeyExchangeAlgorithm) { this.KeyExchangeAlgorithm = EnumEx <KeyExchangeAlgorithm> .Parse(ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.KeyDerivationAlgorithm) { this.KeyDerivationAlgorithm = EnumEx <KeyDerivationAlgorithm> .Parse(ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.CryptoAlgorithm) { this.CryptoAlgorithm = EnumEx <CryptoAlgorithm> .Parse(ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.HashAlgorithm) { this.HashAlgorithm = EnumEx <HashAlgorithm> .Parse(ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.SessionId) { this.SessionId = ItemUtilities.GetByteArray(rangeStream); } } } } }
private static Stream FromBase64String(string value) { var match = _base64Regex.Match(value); if (!match.Success) { throw new ArgumentException(); } value = match.Groups[1].Value; return(new MemoryStream(NetworkConverter.FromBase64UrlString(value))); }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count) { for (; ;) { byte id; { byte[] idBuffer = new byte[1]; if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length) { return; } id = idBuffer[0]; } int length; { byte[] lengthBuffer = new byte[4]; if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } length = NetworkConverter.ToInt32(lengthBuffer); } using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.Tag) { this.Tag = Chat.Import(rangeStream, bufferManager); } else if (id == (byte)SerializeId.CreationTime) { this.CreationTime = DateTime.ParseExact(ItemUtilities.GetString(rangeStream), "yyyy-MM-ddTHH:mm:ssZ", System.Globalization.DateTimeFormatInfo.InvariantInfo).ToUniversalTime(); } else if (id == (byte)SerializeId.FormatType) { this.FormatType = (HypertextFormatType)Enum.Parse(typeof(HypertextFormatType), ItemUtilities.GetString(rangeStream)); } else if (id == (byte)SerializeId.Hypertext) { this.Hypertext = ItemUtilities.GetString(rangeStream); } else if (id == (byte)SerializeId.Certificate) { this.Certificate = Certificate.Import(rangeStream, bufferManager); } } } }
private static Stream AddPadding(Stream stream, int size) { if (stream == null) { throw new ArgumentNullException("stream"); } try { byte[] seedBuffer = new byte[4]; _random.GetBytes(seedBuffer); Random random = new Random(NetworkConverter.ToInt32(seedBuffer)); BufferStream metadataStream = new BufferStream(_bufferManager); byte[] lengthBuffer = NetworkConverter.GetBytes((int)stream.Length); metadataStream.Write(lengthBuffer, 0, lengthBuffer.Length); int paddingLength = size - ((int)stream.Length + 4); BufferStream paddingStream = new BufferStream(_bufferManager); { byte[] buffer = null; try { buffer = _bufferManager.TakeBuffer(1024); while (paddingLength > 0) { int writeSize = Math.Min(paddingLength, buffer.Length); random.NextBytes(buffer); paddingStream.Write(buffer, 0, writeSize); paddingLength -= writeSize; } } finally { _bufferManager.ReturnBuffer(buffer); } } return(new UniteStream(metadataStream, new WrapperStream(stream, true), paddingStream)); } catch (Exception e) { throw new ArgumentException(e.Message, e); } }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager) { using (DeadlockMonitor.Lock(this.ThisLock)) { Encoding encoding = new UTF8Encoding(false); byte[] lengthBuffer = new byte[4]; for (; ;) { if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } int length = NetworkConverter.ToInt32(lengthBuffer); byte id = (byte)stream.ReadByte(); using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.Name) { using (StreamReader reader = new StreamReader(rangeStream, encoding)) { this.Name = reader.ReadToEnd(); } } else if (id == (byte)SerializeId.State) { using (StreamReader reader = new StreamReader(rangeStream, encoding)) { this.State = (ChannelState)Enum.Parse(typeof(ChannelState), reader.ReadToEnd()); } } else if (id == (byte)SerializeId.Manager) { byte[] buffer = new byte[rangeStream.Length]; rangeStream.Read(buffer, 0, buffer.Length); this.Managers.Add(buffer); } else if (id == (byte)SerializeId.Member) { byte[] buffer = new byte[rangeStream.Length]; rangeStream.Read(buffer, 0, buffer.Length); this.Members.Add(buffer); } } } } }
public void FromHexString() { Random random = new Random(); string value; { byte[] buffer = new byte[32]; random.NextBytes(buffer); value = NetworkConverter.ToHexString(buffer); } Stopwatch sw1 = new Stopwatch(); Stopwatch sw2 = new Stopwatch(); var flags = new int[] { 0, 1 }; for (int i = 0; i < 1024 * 1024 * 2; i++) { byte[] result1 = null; byte[] result2 = null; random.Shuffle(flags); foreach (var index in flags) { if (index == 0) { sw1.Start(); result1 = NetworkConverter.FromHexString(value); sw1.Stop(); } else if (index == 1) { sw2.Start(); result2 = NetworkConverter.FromHexString_2(value); sw2.Stop(); } } Assert.IsTrue(Unsafe.Equals(result1, result2)); } StringBuilder sb = new StringBuilder(); sb.AppendLine("FromHexString: " + sw1.Elapsed.ToString()); sb.AppendLine("FromHexString_2: " + sw2.Elapsed.ToString()); Console.WriteLine(sb.ToString()); }
protected override void ProtectedImport(Stream stream, BufferManager bufferManager, int count) { lock (this.ThisLock) { for (; ;) { byte id; { byte[] idBuffer = new byte[1]; if (stream.Read(idBuffer, 0, idBuffer.Length) != idBuffer.Length) { return; } id = idBuffer[0]; } int length; { byte[] lengthBuffer = new byte[4]; if (stream.Read(lengthBuffer, 0, lengthBuffer.Length) != lengthBuffer.Length) { return; } length = NetworkConverter.ToInt32(lengthBuffer); } using (RangeStream rangeStream = new RangeStream(stream, stream.Position, length, true)) { if (id == (byte)SerializeId.CreationTime) { this.CreationTime = DateTime.ParseExact(ItemUtilities.GetString(rangeStream), "yyyy-MM-ddTHH:mm:ssZ", System.Globalization.DateTimeFormatInfo.InvariantInfo).ToUniversalTime(); } if (id == (byte)SerializeId.ExchangeKey) { this.ExchangeKey = ItemUtilities.GetByteArray(rangeStream); } if (id == (byte)SerializeId.ProtocolHash) { this.ProtocolHash = ItemUtilities.GetByteArray(rangeStream); } else if (id == (byte)SerializeId.Certificate) { this.Certificate = Certificate.Import(rangeStream, bufferManager); } } } } }
public void MessageUpload() { _callback.Invoke("----- CoreManager Message Upload Test (Start) -----"); _callback.Invoke(""); var random = RandomProvider.GetThreadRandom(); _coreManager.Resize((long)1024 * 1024 * 1024 * 32).Wait(); Metadata metadata = null; Hash hash; using (var stream = new RecyclableMemoryStream(_bufferManager)) { using (var safeBuffer = _bufferManager.CreateSafeBuffer(1024 * 4)) { for (long remain = (long)1024 * 1024 * 256; 0 < remain; remain -= safeBuffer.Value.Length) { int length = (int)Math.Min(remain, safeBuffer.Value.Length); random.NextBytes(safeBuffer.Value); stream.Write(safeBuffer.Value, 0, length); } } stream.Seek(0, SeekOrigin.Begin); hash = new Hash(HashAlgorithm.Sha256, Sha256.Compute(new WrapperStream(stream))); stream.Seek(0, SeekOrigin.Begin); metadata = _coreManager.VolatileSetStream(stream, new TimeSpan(1, 0, 0, 0), CancellationToken.None).Result; } using (var stream = metadata.Export(_bufferManager)) using (var safeBuffer = _bufferManager.CreateSafeBuffer((int)stream.Length)) { stream.Read(safeBuffer.Value, 0, (int)stream.Length); Console.WriteLine(NetworkConverter.ToBase64UrlString(safeBuffer.Value, 0, (int)stream.Length)); } using (var stream = hash.Export(_bufferManager)) using (var safeBuffer = _bufferManager.CreateSafeBuffer((int)stream.Length)) { stream.Read(safeBuffer.Value, 0, (int)stream.Length); Console.WriteLine(NetworkConverter.ToBase64UrlString(safeBuffer.Value, 0, (int)stream.Length)); } _callback.Invoke("----- CoreManager Message Upload Test (End) -----"); }