public NetState(Socket socket, SocketConnector messagePump) {
mSocket = socket;
mBuffer = new ByteQueue();
Seeded = false;
mRunning = false;
mRecvBuffer = new byte[BufferSize];
mMessagePump = messagePump;
mSendQueue = new SendQueue();
UpdateAcitivty();
mInstances.Add(this);
try {
mAddress = ((IPEndPoint)mSocket.RemoteEndPoint).Address.Intern();
mToString = mAddress.ToString();
} catch (Exception ex) {
throw;
}
mConnectedOn = DateTime.Now;
if (mCreatedCallback != null) {
mCreatedCallback(this);
}
}
private async Task ReadClientHandler(OwnTcpServerConnection connection, AsyncQueue <OwnTcpSendMessage> processQueue)
{
try
{
while (connection.Client.Connected)
{
OwnTcpMessage message = await connection.ReadMessage();
if (message == null || !connection.Client.Connected)
{
break;
}
switch (message.Topic)
{
case PingCmd:
await SendAnswer(connection, message.ID, 200);
break;
case SyncCmd:
ByteQueue data = new ByteQueue();
data.Enqueue(Service);
await SendMessageToClient(connection, SyncCmd, message.ID, data);
break;
case CloseCmd:
await CloseConnection(connection, false);
return;
default:
OwnTcpSendMessage processItem = new OwnTcpSendMessage(message);
await processQueue.Enqueue(processItem);
if (await processItem.Task)
{
Task responseTask = message.IsFireAndForget
? Task.CompletedTask
: SendAnswer(connection, message.ID, 200);
await SendMessageToAllOtherClients(connection, message.Topic, message.Payload);
await responseTask;
}
else
{
await CloseConnection(connection);
}
break;
}
}
}
catch (Exception e)
{
await CloseConnection(connection);
}
}
protected Task PublishShuffle(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue((int)playlist.Shuffle);
return(PublishPlaylistAsync(playlist, nameof(playlist.Shuffle), data));
}
public Encryption()
{
m_AlreadyRelayed = false;
m_Encryption = null;
m_Buffer = new ByteQueue();
m_Seeded = false;
m_Seed = 0;
}
public Encryption()
{
m_AlreadyRelayed = false;
m_Encryption = null;
m_Buffer = new ByteQueue();
m_Seeded = false;
m_Seed = 0;
}
protected async Task PublishMediaSources(ISourcePlaylistBase source)
{
ByteQueue data = new ByteQueue();
data.Enqueue(source.FileMediaSources);
await PublishPlaylistAsync(source, nameof(source.FileMediaSources), data);
}
private Task PublishName(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.Name);
return(PublishPlaylistAsync(playlist, nameof(playlist.Name), data));
}
private Task PublishWannaSong(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.WannaSong);
return(SendAsync(playlist, nameof(playlist.WannaSong), data, false));
}
protected Task PublishPosition(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.Position);
return(SendAsync(playlist, nameof(playlist.Position), data, false));
}
private Task PublishWannaSong(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.WannaSong);
return(PublishPlaylistAsync(playlist, nameof(playlist.WannaSong), data, MqttQualityOfServiceLevel.AtMostOnce, false));
}
protected Task PublishMediaSources(ISourcePlaylistBase source)
{
ByteQueue data = new ByteQueue();
data.Enqueue(source.FileMediaSources);
return(SendAsync(source, nameof(source.FileMediaSources), data, false));
}
protected Task PublishLoop(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue((int)playlist.Loop);
return(SendAsync(playlist, nameof(playlist.Loop), data, false));
}
protected Task PublishPlayState()
{
ByteQueue data = new ByteQueue();
data.Enqueue((int)Service.PlayState);
return(SendAsync(nameof(Service.PlayState), data, false));
}
protected Task PublishVolume()
{
ByteQueue data = new ByteQueue();
data.Enqueue(Service.Volume);
return(SendAsync(nameof(Service.Volume), data, true));
}
protected async Task PublishPlayState()
{
ByteQueue data = new ByteQueue();
data.Enqueue((int)Service.PlayState);
await PublishServiceAsync(nameof(Service.PlayState), data);
}
protected Task PublishSongs(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.Songs);
return(SendAsync(playlist, nameof(playlist.Songs), data, false));
}
protected Task PublishDuration(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.Duration);
return(PublishPlaylistAsync(playlist, nameof(playlist.Duration), data));
}
protected Task PublishCurrentSong(IPlaylistBase playlist)
{
ByteQueue data = new ByteQueue();
data.Enqueue(playlist.CurrentSong);
return(PublishPlaylistAsync(playlist, nameof(playlist.CurrentSong), data));
}
protected async Task PublishCurrentPlaylist()
{
ByteQueue data = new ByteQueue();
data.Enqueue(GetPlaylistType(Service.CurrentPlaylist));
data.Enqueue(Service.CurrentPlaylist?.ID);
await Task.WhenAll(PublishServiceAsync(nameof(Service.CurrentPlaylist), data), AddPlaylist(Service.CurrentPlaylist));
}
public override void FromBytes(ByteQueue bytes)
{
var count = bytes.GetByte();
for (int i = 0; i < count; i++)
{
Add(new Entity(bytes.GetByte()));
}
}
public override void FromBytes(ByteQueue bytes)
{
var count = bytes.GetByte();
for (int i = 0; i < count; i++)
{
Add(bytes.GetIToBytes <T>(type));
}
}
public virtual void FromBytes(ByteQueue bytes)
{
var count = bytes.GetInt();
for (int i = 0; i < count; i++)
{
Add(new Entity(bytes.GetInt()));
}
}
public void TestLengthAfterWrite()
{
ByteQueue queue = new ByteQueue();
byte[] input = Encoding.ASCII.GetBytes("hello world!");
queue.Enqueue(input, 0, input.Length);
Assert.AreEqual(input.Length, queue.Length);
}
public void FromBytes(ByteQueue bytes)
{
var count = bytes.GetInt();
for (int i = 0; i < count; i++)
{
Add(bytes.GetString());
}
}
private static void OnReceiveMessage(object sender, Message <Socket> e)
{
var bytes = new ByteQueue(e.bytes);
var command = (CommandEnum)bytes.GetByte();
if (command == CommandEnum.Input)
{
// Receive Input:
}
if (command == CommandEnum.StateUpdate)
{
var state = new TransformState();
state.FromBytes(bytes);
Console.WriteLine($"TCPClient {e.client.Handle}: {state}");
var existingState = stateHistory.GetState(state.tick);
if (existingState != null)
{
existingState.Clear();
existingState.entities.AddRange(state.entities);
}
else
{
stateHistory.Add(state);
foreach (var client in clients)
{
server.Send(client, Packet.Create(CommandEnum.StateUpdate, state.ToBytes()));
}
}
}
if (command == CommandEnum.DeltaStateUpdate)
{
var deltaState = new TransformDeltaState();
deltaState.FromBytes(bytes);
Console.WriteLine($"TCPClient {e.client.Handle}: {deltaState}");
var startState = stateHistory.GetState(deltaState.startStateTick);
if (startState != null)
{
var endState = (TransformState)deltaState.GenerateEndState(startState);
Console.WriteLine($"End State Generated: {endState}");
var existingState = stateHistory.GetState(endState.tick);
if (existingState != null)
{
existingState.Clear();
existingState.entities.AddRange(endState.entities);
}
else
{
stateHistory.Add(endState);
foreach (var client in clients)
{
server.Send(client, Packet.Create(CommandEnum.StateUpdate, endState.ToBytes()));
}
}
}
}
}
public override void doAction(int readed)
{
DecodeIncomingPacket(m_ListenSocket, ref data, ref readed, true);
ByteQueue temp = new ByteQueue(this);
temp.Enqueue(data, 0, readed);
temp.Socket = m_ListenSocket;
HandleReceive(temp);
}
public override ByteQueue ToBytes()
{
var output = new ByteQueue();
output.Enqueue(Compression.MapToByte(X, MIN_POSITION, MAX_POSITION));
output.Enqueue(Compression.MapToByte(Y, MIN_POSITION, MAX_POSITION));
output.Enqueue(Compression.MapToByte(Z, MIN_POSITION, MAX_POSITION));
return(output);
}
protected async Task PublishSearchKey()
{
return;
ByteQueue data = new ByteQueue();
data.Enqueue(Service.SearchKey);
await PublishServiceAsync(nameof(Service.SearchKey), data);
}
public void Displose()
{
buffer = null;
tmpbuf = null;
m_Crypto.Dispose();
m_SendControlCode = null;
m_RecvControlCode = null;
_queue = null;
//m_UserInfo = null;
}
public Client(string Name, PacketskHandler hander)
{
proxyIp = ConfigurationManager.AppSettings.Get("proxyIp").Split('.');
//m_Thread = new Thread(new ThreadStart(ThreadStartHander));
//m_Thread.Name = Name;
//m_Thread.Start();
m_Buffer = new ByteQueue(this);
this.m_PacketsHander = hander;
this.m_Disposed = false;
}
private void Setup(uint sequenceNumber, uint acknowlegementNumber)
{
this.send_queue = new SendQueue(acknowlegementNumber, Socket.packet_size);
this.recv_queue = new RecvQueue(sequenceNumber, 1);
this.byte_queue = new ByteQueue();
this.OnConnect();
}
protected async Task PublishIsSearchShuffle()
{
return;
ByteQueue data = new ByteQueue();
data.Enqueue(Service.IsSearchShuffle);
await PublishServiceAsync(nameof(Service.IsSearchShuffle), data);
}
public NetState(Socket socket, MessagePump messagePump)
{
m_Socket = socket;
m_Buffer = new ByteQueue();
m_Running = false;
m_RecvBuffer = m_ReceiveBufferPool.AcquireBuffer();
m_MessagePump = messagePump;
m_SendQueue = new SendQueue();
m_NextCheckActivity = DateTime.Now + TimeSpan.FromMinutes(0.5);
}
public virtual void Dispose(bool flush) {
if (mDisposing)
return;
ServerConsole.StatusLine("{0}: Disconnected.", this);
mDisposing = true;
//##PACKET## Logout
Thread.Sleep(100);
if (flush) {
flush = Flush();
}
// Check for existing objects in the World
// FIXME - Account cant be removed
// We need to check using World.GetAccount() after a new connection
// from login -> char or char -> world
// ...
//if (Account != null) {
// World.RemoveObject(Account);
//}
if (mSocket != null) {
try {
mSocket.Shutdown(SocketShutdown.Both);
} catch (SocketException ex) {
ExceptionHandler.Trace(ex);
}
try {
mSocket.Close();
SocketPool.ReleaseSocket(mSocket);
} catch (SocketException ex) {
ExceptionHandler.Trace(ex);
}
mSocket = null;
}
mBuffer = null;
mRecvBuffer = null;
mOnReceive = null;
mOnSend = null;
mRunning = false;
mDisposed.Enqueue(this);
if (!mSendQueue.IsEmpty) {
lock (mSendQueue) {
mSendQueue.Clear();
}
}
}
public void FinishDispose()
{
if (m_DisposeFinished)
return;
m_DisposeFinished = true;
try { m_Socket.Shutdown( SocketShutdown.Both ); }
catch {}
try { m_Socket.Close(); }
catch {}
if ( m_RecvBuffer != null )
m_ReceiveBufferPool.ReleaseBuffer( m_RecvBuffer );
m_Socket = null;
m_Buffer = null;
m_RecvBuffer = null;
m_OnReceive = null;
m_OnSend = null;
m_Running = false;
m_Disposed.Enqueue( this );
if ( /*!flush &&*/ !m_SendQueue.IsEmpty )
{
lock ( m_SendQueue )
m_SendQueue.Clear();
}
}
public NetState( Socket socket, MessagePump messagePump )
{
m_Socket = socket;
m_Buffer = new ByteQueue();
m_Seeded = false;
m_Running = false;
m_RecvBuffer = m_ReceiveBufferPool.AquireBuffer();
m_MessagePump = messagePump;
m_Gumps = new GumpCollection();
m_HuePickers = new HuePickerCollection();
m_Menus = new MenuCollection();
m_Trades = new ArrayList();
m_SendQueue = new SendQueue();
m_NextCheckActivity = DateTime.Now + TimeSpan.FromMinutes( 0.5 );
m_Instances.Add( this );
try{ m_Address = ((IPEndPoint)m_Socket.RemoteEndPoint).Address; m_ToString = m_Address.ToString(); }
catch{ m_Address = IPAddress.None; m_ToString = "(error)"; }
m_Super = Core.Config.LoginConfig.IsSuperClient(m_ToString);
if ( m_CreatedCallback != null )
m_CreatedCallback( this );
}
/** client constructor, used to connect to other UO servers */
public NetState( IPEndPoint connectTo, MessagePump messagePump )
{
m_Socket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp );
m_EndPoint = connectTo;
m_Buffer = new ByteQueue();
m_Seeded = true;
m_Running = false;
m_Client = true;
m_RecvBuffer = m_ReceiveBufferPool.AquireBuffer();
m_MessagePump = messagePump;
m_SendQueue = new SendQueue();
m_NextCheckActivity = Core.Now + TimeSpan.FromMinutes( 0.5 );
m_Instances.Add( this );
try {
m_Address = m_EndPoint.Address;
m_ToString = "[To GameServer " + m_EndPoint.ToString() + "]";
} catch{ m_Address = IPAddress.None; m_ToString = "(error)"; }
if ( m_CreatedCallback != null )
m_CreatedCallback( this );
}
public virtual void Dispose( bool flush )
{
if ( m_Socket == null || m_Disposing ) {
return;
}
m_Disposing = true;
if ( flush )
flush = Flush();
try {
m_Socket.Shutdown( SocketShutdown.Both );
} catch ( SocketException ex ) {
TraceException( ex );
}
try {
m_Socket.Close();
SocketPool.ReleaseSocket( m_Socket );
} catch ( SocketException ex ) {
TraceException( ex );
}
if ( m_RecvBuffer != null )
m_ReceiveBufferPool.ReleaseBuffer( m_RecvBuffer );
m_Socket = null;
m_Buffer = null;
m_RecvBuffer = null;
m_OnReceive = null;
m_OnSend = null;
m_Running = false;
m_Disposed.Enqueue( this );
if ( /*!flush &&*/ !m_SendQueue.IsEmpty ) {
lock ( m_SendQueue )
m_SendQueue.Clear();
}
}
public NetState( Socket socket, MessagePump messagePump )
{
m_Socket = socket;
m_Buffer = new ByteQueue();
m_Seeded = false;
m_Running = false;
m_RecvBuffer = m_ReceiveBufferPool.AcquireBuffer();
m_MessagePump = messagePump;
m_Gumps = new List<Gump>();
m_HuePickers = new List<HuePicker>();
m_Menus = new List<IMenu>();
m_Trades = new List<SecureTrade>();
m_SendQueue = new SendQueue();
m_NextCheckActivity = DateTime.Now + TimeSpan.FromMinutes( 0.5 );
m_Instances.Add( this );
try {
m_Address = Utility.Intern( ( ( IPEndPoint ) m_Socket.RemoteEndPoint ).Address );
m_ToString = m_Address.ToString();
} catch ( Exception ex ) {
TraceException( ex );
m_Address = IPAddress.None;
m_ToString = "(error)";
}
m_ConnectedOn = DateTime.Now;
if ( m_CreatedCallback != null )
{
m_CreatedCallback( this );
}
}
public void Displose()
{
buffer = null;
tmpbuf = null;
m_Crypto.Dispose();
m_SendControlCode = null;
m_RecvControlCode = null;
_queue = null;
m_UserInfo = null;
}
public virtual void Dispose(bool flush) {
if (mSocket == null || mDisposing) {
return;
}
mDisposing = true;
//##PACKET## Logout
Thread.Sleep(100);
if (flush) {
Flush();
}
try {
mSocket.Shutdown(SocketShutdown.Both);
} catch (SocketException ex) {
Debug.WriteLine(ex);
}
try {
mSocket.Close();
SocketPool.ReleaseSocket(mSocket);
} catch (SocketException ex) {
Debug.WriteLine(ex);
}
mSocket = null;
mBuffer = null;
mRecvBuffer = null;
mOnReceive = null;
mOnSend = null;
mRunning = false;
mDisposed.Enqueue(this);
if (!mSendQueue.IsEmpty) {
lock (mSendQueue)
mSendQueue.Clear();
}
}
public NetState(Socket socket, SocketConnector messagePump) {
mSocket = socket;
mBuffer = new ByteQueue();
mSeeded = false;
mRunning = false;
mRecvBuffer = new byte[mBufferSize];
mMessagePump = messagePump;
mSendQueue = new SendQueue();
UpdateAcitivty();
InstanceID = mInstanceID++;
Instances.Add(InstanceID, this);
try {
mAddress = ((IPEndPoint)mSocket.RemoteEndPoint).Address;
} catch (Exception ex) {
ExceptionHandler.Trace(ex);
mAddress = IPAddress.None;
}
mConnectedOn = DateTime.Now;
if (mCreatedCallback != null)
mCreatedCallback(this);
}
internal void Send_Start()
{
if (!Running || !_socket.Connected)
{
DisposeSendSystem();
return;
}
Packet packet = null;
try
{
ByteQueue byteQueue = new ByteQueue();
int length = 0;
while (!PacketsToBeSent.IsEmpty && length <= 1024)
{
if (!PacketsToBeSent.TryDequeue(out packet))
{
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
return;
}
if (!packet.Shared)
packet.Write();
byte[] packetBuffer = packet.GetBuffer();
length += packetBuffer.Length;
byteQueue.Enqueue(packetBuffer, 0, packetBuffer.Length);
packet.Release();
}
if (byteQueue.Length > 0)
{
byte[] data = new byte[length];
byteQueue.Dequeue(data, 0, data.Length);
Send_Async(data);
}
else
{
Interlocked.Exchange(ref _TimesEnqueuedForSend, 0);
if (!PacketsToBeSent.IsEmpty)
{
int newValue = Interlocked.Increment(ref _TimesEnqueuedForSend);
if (newValue == 1)
{
Server.SendClientQueue.Enqueue(this);
Server.NetworkSignal.Set();
}
}
}
}
catch (Exception e)
{
MarkToDispose();
DisposeSendSystem();
if(packet != null)
Logger.Log(Logger.LogLevel.Error, "Sending packet: {0}", packet.ToString());
Logger.Log(Logger.LogLevel.Error, e.ToString());
// TODO: log something?
}
}
private bool HandleSeed(NetState ns, ByteQueue buffer) {
if (buffer.GetPacketID() == 0xEF) {
// new packet in client 6.0.5.0 replaces the traditional seed method with a seed packet
// 0xEF = 239 = multicast IP, so this should never appear in a normal seed. So this is backwards compatible with older clients.
ns.Seeded = true;
return true;
} else if (buffer.Length >= 4) {
byte[] m_Peek = new byte[4];
buffer.Dequeue(m_Peek, 0, 4);
int seed = (m_Peek[0] << 24) | (m_Peek[1] << 16) | (m_Peek[2] << 8) | m_Peek[3];
if (seed == 0) {
Console.WriteLine("Login: {0}: Invalid client detected, disconnecting", ns);
ns.Dispose();
return false;
}
ns.m_Seed = seed;
ns.Seeded = true;
return true;
} else {
return false;
}
}
