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) -----");
}
