warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Targets .NET Core 3.0 (#39)

Browse source
This commit is contained in:
Kamron Batman 2019-08-02 17:53:18 -07:00 • committed by GitHub
parent 0993c03b70
commit 08bf44af9a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
125 changed files with 1473 additions and 14244 deletions
Download patch file Download diff file Expand all files Collapse all files

219
Server/Network/PacketWriter.cs
View file

@ -19,7 +19,7 @@
***************************************************************************/
using System;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.IO;
using System.Text;
@ -30,7 +30,7 @@ namespace Server.Network
/// </summary>
public class PacketWriter
{
private static Stack<PacketWriter> m_Pool = new Stack<PacketWriter>();
private static ConcurrentQueue<PacketWriter> m_Pool = new ConcurrentQueue<PacketWriter>();
/// <summary>
/// Internal format buffer.
@ -39,85 +39,50 @@ namespace Server.Network
private int m_Capacity;
/// <summary>
/// Internal stream which holds the entire packet.
/// </summary>
private MemoryStream m_Stream;
/// <summary>
/// Instantiates a new PacketWriter instance with a given capacity.
/// </summary>
/// <param name="capacity">Initial capacity for the internal stream.</param>
public PacketWriter(int capacity = 32)
{
m_Stream = new MemoryStream(capacity);
UnderlyingStream = new MemoryStream(capacity);
m_Capacity = capacity;
}
/// <summary>
/// Gets the total stream length.
/// </summary>
public long Length => m_Stream.Length;
public long Length => UnderlyingStream.Length;
/// <summary>
/// Gets or sets the current stream position.
/// </summary>
public long Position
{
get => m_Stream.Position;
set => m_Stream.Position = value;
get => UnderlyingStream.Position;
set => UnderlyingStream.Position = value;
}
/// <summary>
/// The internal stream used by this PacketWriter instance.
/// </summary>
public MemoryStream UnderlyingStream => m_Stream;
public MemoryStream UnderlyingStream { get; private set; }
public static PacketWriter CreateInstance()
public static PacketWriter CreateInstance(int capacity = 32)
{
return CreateInstance(32);
}
public static PacketWriter CreateInstance(int capacity)
{
PacketWriter pw = null;
lock (m_Pool)
if (m_Pool.TryDequeue(out PacketWriter pw))
{
if (m_Pool.Count > 0)
{
pw = m_Pool.Pop();
if (pw != null)
{
pw.m_Capacity = capacity;
pw.m_Stream.SetLength(0);
}
}
pw.m_Capacity = capacity;
pw.UnderlyingStream.SetLength(0);
return pw;
}
return pw ?? new PacketWriter(capacity);
return new PacketWriter(capacity);
}
public static void ReleaseInstance(PacketWriter pw)
{
lock (m_Pool)
{
if (!m_Pool.Contains(pw))
m_Pool.Push(pw);
else
try
{
using (StreamWriter op = new StreamWriter("neterr.log"))
{
op.WriteLine("{0}\tInstance pool contains writer", DateTime.UtcNow);
}
}
catch
{
Console.WriteLine("net error");
}
}
m_Pool.Enqueue(pw);
}
/// <summary>
@ -125,7 +90,7 @@ namespace Server.Network
/// </summary>
public void Write(bool value)
{
m_Stream.WriteByte((byte)(value ? 1 : 0));
UnderlyingStream.WriteByte((byte)(value ? 1 : 0));
}
/// <summary>
@ -133,7 +98,7 @@ namespace Server.Network
/// </summary>
public void Write(byte value)
{
m_Stream.WriteByte(value);
UnderlyingStream.WriteByte(value);
}
/// <summary>
@ -141,7 +106,7 @@ namespace Server.Network
/// </summary>
public void Write(sbyte value)
{
m_Stream.WriteByte((byte)value);
UnderlyingStream.WriteByte((byte)value);
}
/// <summary>
@ -152,7 +117,7 @@ namespace Server.Network
m_Buffer[0] = (byte)(value >> 8);
m_Buffer[1] = (byte)value;
m_Stream.Write(m_Buffer, 0, 2);
UnderlyingStream.Write(m_Buffer, 0, 2);
}
/// <summary>
@ -163,7 +128,7 @@ namespace Server.Network
m_Buffer[0] = (byte)(value >> 8);
m_Buffer[1] = (byte)value;
m_Stream.Write(m_Buffer, 0, 2);
UnderlyingStream.Write(m_Buffer, 0, 2);
}
/// <summary>
@ -176,7 +141,7 @@ namespace Server.Network
m_Buffer[2] = (byte)(value >> 8);
m_Buffer[3] = (byte)value;
m_Stream.Write(m_Buffer, 0, 4);
UnderlyingStream.Write(m_Buffer, 0, 4);
}
/// <summary>
@ -189,7 +154,7 @@ namespace Server.Network
m_Buffer[2] = (byte)(value >> 8);
m_Buffer[3] = (byte)value;
m_Stream.Write(m_Buffer, 0, 4);
UnderlyingStream.Write(m_Buffer, 0, 4);
}
/// <summary>
@ -197,7 +162,7 @@ namespace Server.Network
/// </summary>
public void Write(byte[] buffer, int offset, int size)
{
m_Stream.Write(buffer, offset, size);
UnderlyingStream.Write(buffer, offset, size);
}
/// <summary>
@ -214,29 +179,18 @@ namespace Server.Network
int length = value.Length;
m_Stream.SetLength(m_Stream.Length + size);
UnderlyingStream.SetLength(UnderlyingStream.Length + size);
if (length >= size)
{
m_Stream.Position += Encoding.ASCII.GetBytes(value, 0, size, m_Stream.GetBuffer(), (int)m_Stream.Position);
UnderlyingStream.Position +=
Encoding.ASCII.GetBytes(value, 0, size, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
}
else
{
Encoding.ASCII.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += size;
Encoding.ASCII.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += size;
}
/*byte[] buffer = Encoding.ASCII.GetBytes( value );
if ( buffer.Length >= size )
{
m_Stream.Write( buffer, 0, size );
}
else
{
m_Stream.Write( buffer, 0, buffer.Length );
Fill( size - buffer.Length );
}*/
}
/// <summary>
@ -252,15 +206,10 @@ namespace Server.Network
int length = value.Length;
m_Stream.SetLength(m_Stream.Length + length + 1);
UnderlyingStream.SetLength(UnderlyingStream.Length + length + 1);
Encoding.ASCII.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += length + 1;
/*byte[] buffer = Encoding.ASCII.GetBytes( value );
m_Stream.Write( buffer, 0, buffer.Length );
m_Stream.WriteByte( 0 );*/
Encoding.ASCII.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += length + 1;
}
/// <summary>
@ -276,18 +225,10 @@ namespace Server.Network
int length = value.Length;
m_Stream.SetLength(m_Stream.Length + (length + 1) * 2);
UnderlyingStream.SetLength(UnderlyingStream.Length + (length + 1) * 2);
m_Stream.Position += Encoding.Unicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += 2;
/*byte[] buffer = Encoding.Unicode.GetBytes( value );
m_Stream.Write( buffer, 0, buffer.Length );
m_Buffer[0] = 0;
m_Buffer[1] = 0;
m_Stream.Write( m_Buffer, 0, 2 );*/
UnderlyingStream.Position += Encoding.Unicode.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += 2;
}
/// <summary>
@ -302,36 +243,21 @@ namespace Server.Network
value = string.Empty;
}
int length = value.Length;
size *= 2;
int length = value.Length;
m_Stream.SetLength(m_Stream.Length + size);
UnderlyingStream.SetLength(UnderlyingStream.Length + size);
if (length * 2 >= size)
{
m_Stream.Position +=
Encoding.Unicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
UnderlyingStream.Position +=
Encoding.Unicode.GetBytes(value, 0, size, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
}
else
{
Encoding.Unicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += size;
Encoding.Unicode.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += size;
}
/*size *= 2;
byte[] buffer = Encoding.Unicode.GetBytes( value );
if ( buffer.Length >= size )
{
m_Stream.Write( buffer, 0, size );
}
else
{
m_Stream.Write( buffer, 0, buffer.Length );
Fill( size - buffer.Length );
}*/
}
/// <summary>
@ -347,19 +273,11 @@ namespace Server.Network
int length = value.Length;
m_Stream.SetLength(m_Stream.Length + (length + 1) * 2);
UnderlyingStream.SetLength(UnderlyingStream.Length + (length + 1) * 2);
m_Stream.Position +=
Encoding.BigEndianUnicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += 2;
/*byte[] buffer = Encoding.BigEndianUnicode.GetBytes( value );
m_Stream.Write( buffer, 0, buffer.Length );
m_Buffer[0] = 0;
m_Buffer[1] = 0;
m_Stream.Write( m_Buffer, 0, 2 );*/
UnderlyingStream.Position +=
Encoding.BigEndianUnicode.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += 2;
}
/// <summary>
@ -374,36 +292,21 @@ namespace Server.Network
value = string.Empty;
}
int length = value.Length;
size *= 2;
int length = value.Length;
UnderlyingStream.SetLength(UnderlyingStream.Length + size);
m_Stream.SetLength(m_Stream.Length + size);
if (length * 2 >= size)
if (length * 2 >= size )
{
m_Stream.Position +=
Encoding.BigEndianUnicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
UnderlyingStream.Position +=
Encoding.BigEndianUnicode.GetBytes(value, 0, size, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
}
else
{
Encoding.BigEndianUnicode.GetBytes(value, 0, length, m_Stream.GetBuffer(), (int)m_Stream.Position);
m_Stream.Position += size;
Encoding.BigEndianUnicode.GetBytes(value, 0, length, UnderlyingStream.GetBuffer(), (int)UnderlyingStream.Position);
UnderlyingStream.Position += size;
}
/*size *= 2;
byte[] buffer = Encoding.BigEndianUnicode.GetBytes( value );
if ( buffer.Length >= size )
{
m_Stream.Write( buffer, 0, size );
}
else
{
m_Stream.Write( buffer, 0, buffer.Length );
Fill( size - buffer.Length );
}*/
}
/// <summary>
@ -411,39 +314,33 @@ namespace Server.Network
/// </summary>
public void Fill()
{
Fill((int)(m_Capacity - m_Stream.Length));
Fill(m_Capacity - UnderlyingStream.Length);
}
/// <summary>
/// Writes a number of 0x00 byte values to the underlying stream.
/// </summary>
public void Fill(int length)
public void Fill(long length)
{
if (m_Stream.Position == m_Stream.Length)
if (UnderlyingStream.Position == UnderlyingStream.Length)
{
m_Stream.SetLength(m_Stream.Length + length);
m_Stream.Seek(0, SeekOrigin.End);
UnderlyingStream.SetLength(UnderlyingStream.Length + length);
UnderlyingStream.Seek(0, SeekOrigin.End);
}
else
{
m_Stream.Write(new byte[length], 0, length);
UnderlyingStream.Write(new byte[length], 0, (int)length);
}
}
/// <summary>
/// Offsets the current position from an origin.
/// </summary>
public long Seek(long offset, SeekOrigin origin)
{
return m_Stream.Seek(offset, origin);
}
public long Seek(long offset, SeekOrigin origin) => UnderlyingStream.Seek(offset, origin);
/// <summary>
/// Gets the entire stream content as a byte array.
/// </summary>
public byte[] ToArray()
{
return m_Stream.ToArray();
}
public byte[] ToArray() => UnderlyingStream.ToArray();
}
}