public TcpTransport(string hostname, int port, OnPacket onPacket, OnDisconnect onDisconnect)
{
_bQuit = false;
_client = new TcpClient();
_client.NoDelay = true;
_client.ReceiveBufferSize = 2048;
_client.SendBufferSize = 2048;
_client.ReceiveTimeout = 0;
_client.SendTimeout = 30000;
_client.LingerState = new LingerOption(true, 30);
_client.Connect(hostname, port);
//m_stream = m_client.GetStream();
_onPacket = onPacket;
_onDisconnect = onDisconnect;
DoHandShake();
StartThread("JDbg.TcpTransport");
}
internal void FireOnDisconnect()
{
OnDisconnect?.Invoke();
}
private void CallOnDisconnect(NetConnection client)
{
OnDisconnect?.Invoke(this, client);
}
private void Connection_OnDisconnect(SyncIOConnectedClient client, Exception ex)
{
OnDisconnect?.Invoke(this, ex);
}
public new void Dispose()
{
base.Dispose();
_messageReplies.Clear();
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
public void Disconnect()
{
client.Close();
OnDisconnect?.Invoke(null);
}
/// <summary>
/// On disconnecting the observer, trigger
/// the action(s).
/// </summary>
public async ValueTask Disconnect()
{
await(OnDisconnect.Invoke(this.Id));
}
private void runSender()
{
while (m_isOpen && m_port >= 0)
{
try
{
bool moreWork = false;
for (int i = 0; i < connections.Count; i++)
{
if (connections[i].CallbackThread != null)
{
try
{
connections[i].CallbackThread = null;
lock (activeThreadsLock)
{
activeThreads--;
}
}
catch (Exception ex)
{
OnError?.Invoke(this, ex);
}
}
if (connections[i].CallbackThread != null)
{
}
else if (connections[i].connected() &&
(connections[i].LastVerifyTime.AddMilliseconds(m_verifyConnectionInterval) > DateTime.UtcNow ||
connections[i].verifyConnected()))
{
moreWork = moreWork || processConnection(connections[i]);
}
else
{
lock (connections)
{
OnDisconnect?.Invoke(this, connections[i]);
connections.RemoveAt(i);
i--;
}
}
}
if (moreWork)
{
continue;
}
Thread.Yield();
lock (sem)
{
if (connections.Any(conn => conn.hasMoreWork()))
{
moreWork = true;
}
}
if (moreWork)
{
continue;
}
waiting = true;
sem.Wait(m_idleTime);
waiting = false;
}
catch (ThreadInterruptedException ex)
{
OnError?.Invoke(this, ex);
}
catch (Exception e)
{
if (m_isOpen)
{
OnError?.Invoke(this, e);
}
}
}
}
protected virtual void OnDisconnectInvoke()
{
OnDisconnect?.Invoke(this);
}
public override void HandleDisconnect()
{
base.HandleDisconnect();
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
public void Disconnect()
{
_obdDevice.Disconnect();
STDType = StandardType.Automatic;
OnDisconnect?.Invoke();
}
public void Dispose()
{
_messageReplies.Clear();
_listener?.Dispose();
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
void ITcpListener.handleDisconnect(IChannel channel)
{
OnDisconnect?.Invoke(channel);
}
protected virtual void HandleDisconnect(GhostNetConnection con)
{
if (!ConnectionMap.TryGetValue(con.ManagementEndPoint, out con) || con == null)
{
return; // Probably already disconnected.
}
uint id = (uint)Connections.IndexOf(con);
if (id == uint.MaxValue)
{
Logger.Log(LogLevel.Verbose, "ghostnet-s", $"Client #? ({con.ManagementEndPoint}) disconnected?");
return;
}
Logger.Log(LogLevel.Verbose, "ghostnet-s", $"Client #{id} ({con.ManagementEndPoint}) disconnected");
Connections[(int)id] = null;
if (KevinballPlayerIDs.Contains(id))
{
KevinballPlayerIDs.Remove(id);
}
if (KevinballScores.ContainsKey(id))
{
KevinballScores.Remove(id);
}
if (KevinballQueue.Contains(id))
{
KevinballQueue.Remove(id);
}
ConnectionMap[con.ManagementEndPoint] = null;
if (con.UpdateEndPoint != null)
{
ConnectionMap[con.UpdateEndPoint] = null;
}
else
{
UpdateConnectionQueue[con.ManagementEndPoint.Address] = null;
}
ChunkMPlayer player;
if (PlayerMap.TryGetValue(id, out player) && player != null &&
!string.IsNullOrWhiteSpace(player.Name) &&
!string.IsNullOrWhiteSpace(GhostNetModule.Settings.ServerMessageLeave))
{
BroadcastMChat(new GhostNetFrame {
HHead = new ChunkHHead {
PlayerID = id
},
MPlayer = player
}, GhostNetModule.Settings.ServerMessageLeave, fillVars: true);
}
OnDisconnect?.Invoke(id, player);
// Propagate disconnect to all other players.
GhostNetFrame frame = new GhostNetFrame {
HHead = new ChunkHHead {
PlayerID = id
},
MPlayer = new ChunkMPlayer {
Name = "",
SID = "",
Mode = AreaMode.Normal,
Level = ""
}
};
lock (PlayerMap) {
PlayerMap[id] = null;
}
PropagateM(frame);
}
/// <summary>
/// Début de la réception async
/// </summary>
/// <param name="result"></param>
private void beginReceive(IAsyncResult result)
{
Buffers.Read buffer = (Buffers.Read)result.AsyncState;
if (!Socket.Connected)
{
OnDisconnect?.Invoke();
return;
}
int read = Socket.EndReceive(result);
if (read == 0)
{
Socket.Disconnect(true);
OnDisconnect?.Invoke();
}
else
{
Buffers.Read next;
if (buffer.GetType() == typeof(Buffers.HTTP.Read))
{
Buffers.HTTP.Read current = buffer as Buffers.HTTP.Read;
current.Append(read);
if (read == buffer.Size)
{
Socket.BeginReceive(current.Buffer, 0, current.Size, 0, beginReceive, current);
}
else if (read < buffer.Size)
{
current.Parse();
// Upgrade to websocket on server request
if (current.HTTP_STATUS == 101 && current.Headers.Contains(new KeyValuePair <string, string>("Upgrade", "websocket")))
{
OnConnected?.Invoke();
next = new Buffers.WebSocket.Read(new byte[40960]);
}
else
{
string payload = current.Payload.Replace("\0", "").Trim();
if (!string.IsNullOrEmpty(payload))
{
OnReceive?.Invoke(payload);
}
Console.WriteLine("Unable to upgrade connection");
OnDisconnect?.Invoke();
return;
}
Socket.BeginReceive(next.Buffer, 0, next.Size, 0, beginReceive, next);
}
}
else if (buffer.GetType() == typeof(Buffers.WebSocket.Read))
{
Buffers.WebSocket.Read current = buffer as Buffers.WebSocket.Read;
current.Append(read);
if (read == buffer.Size)
{
Socket.BeginReceive(current.Buffer, 0, current.Size, 0, beginReceive, current);
}
else if (read < buffer.Size)
{
current.Parse();
if (current.Type == Buffers.WebSocket.Read.DataType.PIN) // Answer PON to PIN
{
Buffers.WebSocket.Write pong = new Buffers.WebSocket.Write(new byte[0], Buffers.WebSocket.Write.DataType.PON, false);
Socket.BeginSend(pong.Parsed, 0, pong.Parsed.Length, 0, beginSend, pong);
}
else
{
OnReceive?.Invoke(Encoding.UTF8.GetString(current.Payload));
}
next = new Buffers.WebSocket.Read(new byte[40960]);
Socket.BeginReceive(next.Buffer, 0, next.Size, 0, beginReceive, next);
}
}
}
}
public void Disconnect()
{
tokenSource.Cancel();
OnDisconnect?.Invoke(this, new EventArgs());
_webSocket.Dispose();
}
internal void Disconnected()
{
IsConnected = false;
OnDisconnect?.Invoke(this, EventArgs.Empty);
}
private void RaiseOnDisconnect()
{
OnDisconnect?.Invoke();
}
public void StartListening(String host, int port, OnReceive on_receive, OnConnect on_connect, OnDisconnect on_disconnect, OnListenError on_listen_error)
{
on_receive_ = on_receive;
on_connect_ = on_connect;
on_disconnect_ = on_disconnect;
on_listen_error_ = on_listen_error;
size_receiving_ = 0;
IPAddress ipAddress = IPAddress.Parse(GetIPAddress(host));
IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port);
// Create a TCP/IP socket.
listener_ = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listener_.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
// Bind the socket to the local endpoint and listen for incoming connections.
try
{
listener_.Bind(localEndPoint);
listener_.Listen(0);
// Start an asynchronous socket to listen for connections.
listener_.BeginAccept(new AsyncCallback(AcceptCallback), listener_);
}
catch (Exception e)
{
on_listen_error_(e.ToString());
}
}
internal void TriggerOnDisconnect(ServerConnectorContext serverConnectorContext)
{
OnDisconnect?.Invoke(serverConnectorContext);
}
public void handleDisconnect(IChannel channel)
{
OnDisconnect?.Invoke(channel);
}
private void Listener_OnDisconnect(object sender, EventArgs e)
{
Connected = false;
OnDisconnect?.Invoke(this, null);
}
internal void Disconnect(MqttMessage message)
{
OnDisconnect?.Invoke(this, new MqttMessageEventArgs(message));
}
internal WebSocketWrapper(Uri baseUri, WebSocketOptions options) : base(options)
{
_baseUri = baseUri;
_messageReplies = new ConcurrentDictionary <string, TaskCompletionSource <WebSocketMessageEnvelope> >();
options.ValidateOptions();
_options = options.Clone();
if (!IsTrace)
{
_options.Logger = new NullLogger();
}
OnError = (sender, exception) => _options.Logger.Error(exception);
OnChannelMessage = (sender, message) =>
_options.Logger.DebugFormat("Received channel message '{0}'", message);
OnChannelPresence = (sender, _event) =>
_options.Logger.DebugFormat("Received channel presence '{0}'", _event);
OnConnect = (sender, args) => _options.Logger.Debug("Socket connected.");
OnDisconnect = (sender, args) => _options.Logger.Debug("Socket disconnected.");
OnMatchmakerMatched = (sender, matched) =>
_options.Logger.DebugFormat("Received matchmaker match '{0}'", matched);
OnMatchPresence = (sender, _event) =>
_options.Logger.DebugFormat("Received match presence '{0}'", _event);
OnMatchState = (sender, state) => _options.Logger.DebugFormat("Received match state '{0}'", state);
OnNotification = (sender, notification) =>
_options.Logger.DebugFormat("Received notification '{0}'", notification);
OnStatusPresence = (sender, _event) =>
_options.Logger.DebugFormat("Received status presence '{0}'", _event);
OnStreamPresence = (sender, _event) =>
_options.Logger.DebugFormat("Received stream presence '{0}'", _event);
OnStreamState = (sender, state) => _options.Logger.DebugFormat("Received stream state '{0}'", state);
Connected += (sender, args) => OnConnect.Invoke(this, EventArgs.Empty);
Disconnected += (sender, args) => OnDisconnect.Invoke(this, EventArgs.Empty);
ErrorReceived += (sender, exception) => OnError?.Invoke(this, exception);
MessageReceived += (sender, message) =>
{
if (IsTrace)
{
_options.Logger.DebugFormat("Socket read message: '{0}'", message);
}
var envelope = message.FromJson <WebSocketMessageEnvelope>();
if (!string.IsNullOrEmpty(envelope.Cid))
{
// Handle message response.
TaskCompletionSource <WebSocketMessageEnvelope> completer;
var cid = envelope.Cid;
_messageReplies.TryRemove(cid, out completer);
if (completer == null)
{
if (IsTrace)
{
_options.Logger.InfoFormat("No task completer for message: '{0}'", cid);
}
return;
}
if (envelope.Error != null)
{
// FIXME use a dedicated exception type.
completer.SetException(new WebSocketException(envelope.Error.Message));
}
else
{
completer.SetResult(envelope);
}
}
else if (envelope.Error != null)
{
OnError?.Invoke(this, new WebSocketException(envelope.Error.Message));
}
else if (envelope.ChannelMessage != null)
{
OnChannelMessage?.Invoke(this, envelope.ChannelMessage);
}
else if (envelope.ChannelPresenceEvent != null)
{
OnChannelPresence?.Invoke(this, envelope.ChannelPresenceEvent);
}
else if (envelope.MatchmakerMatched != null)
{
OnMatchmakerMatched?.Invoke(this, envelope.MatchmakerMatched);
}
else if (envelope.MatchPresenceEvent != null)
{
OnMatchPresence?.Invoke(this, envelope.MatchPresenceEvent);
}
else if (envelope.MatchState != null)
{
OnMatchState?.Invoke(this, envelope.MatchState);
}
else if (envelope.NotificationList != null)
{
foreach (var notification in envelope.NotificationList.Notifications)
{
OnNotification?.Invoke(this, notification);
}
}
else if (envelope.StatusPresenceEvent != null)
{
OnStatusPresence?.Invoke(this, envelope.StatusPresenceEvent);
}
else if (envelope.StreamPresenceEvent != null)
{
OnStreamPresence?.Invoke(this, envelope.StreamPresenceEvent);
}
else if (envelope.StreamState != null)
{
OnStreamState?.Invoke(this, envelope.StreamState);
}
else
{
if (IsTrace)
{
_options.Logger.InfoFormat("Socket received unrecognised message: '{0}'", message);
}
}
};
}
public async Task StartListen()
{
if (_reading)
{
return;
}
_reading = true;
var send = Task.Run(StartSend);
WebSocketReceiveResult closeResult = null;
try
{
while (!_cancellation.IsCancellationRequested)
{
try
{
var(result, message) = await ReceiveFullMessage();
if (result.MessageType == WebSocketMessageType.Binary)
{
var array = message.ToArray();
var memStream = new MemoryStream(array, 0, array.Length);
HandleMessage(memStream);
}
if (result.MessageType == WebSocketMessageType.Close)
{
closeResult = result;
break;
}
}
catch (OperationCanceledException)
{
// Exit normally
}
}
_reading = false;
await send;
WebSocketCloseStatus closeStatus = WebSocketCloseStatus.NormalClosure;
if (closeResult?.CloseStatus != null)
{
closeStatus = (WebSocketCloseStatus)closeResult.CloseStatus;
}
await DisconnectAsync(closeStatus, closeResult?.CloseStatusDescription);
}
catch (WebSocketException e) when(e.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely)
{
OnDisconnect?.Invoke(WebSocketCloseStatus.ProtocolError, "ConnectionClosedPrematurely");
}
catch (Exception e)
{
Console.WriteLine("RECV ERR");
Console.WriteLine(e);
/*Disconnect();
* RawSocket.Dispose();*/
}
}
/// <summary>
/// Se déclanche quand le client mobile se déconnecte de la communication socket
/// </summary>
private void OnSocketClientDisconnected(object sender, EventArgs e)
{
IsConnected = false;
OnDisconnect?.Invoke(this, new EventArgs());
}
private void ProcessClosed(object sender, EventArgs e)
{
IsEnabled = false;
OnDisconnect?.Invoke(this, new EventArgs());
}
/// <summary>
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public void Disconnect(object sender, EventArgs args = default(EventArgs))
{
OnDisconnect?.Invoke(sender, args);
}
public void FireDisconnectEvent(Session session)
{
OnDisconnect?.Invoke(session);
}
public void RaiseOnDisconnect()
{
OnDisconnect?.Invoke();
}
/// <summary>
/// Thông báo cho server biết Client này bị disconnect
/// </summary>
private void NotifyDisconnect()
{
OnDisconnect?.Invoke(Guid);
}
