protected virtual void Dispose(bool disposing)
{
if (m_disposed)
{
return;
}
//if (disposing) { }
m_handlerDisconnected = null;
m_handlerReceived = null;
m_saeaReciver = null;
m_saeaSender = null;
m_pooledBufferManager = null;
m_queueSend = null;
m_listSend.Clear();
m_listSend = null;
m_bClosed = null;
m_bClosing = null;
m_bSending = null;
m_bReceiving = null;
m_disposed = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpChannel" /> class.
/// </summary>
/// <param name="readBuffer">Buffer used for our reading.</param>
/// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param>
/// <param name="decoder">
/// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be
/// overridden by this class.
/// </param>
public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder) {
if (readBuffer == null) throw new ArgumentNullException("readBuffer");
if (encoder == null) throw new ArgumentNullException("encoder");
if (decoder == null) throw new ArgumentNullException("decoder");
_readArgs = new SocketAsyncEventArgs();
_readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity);
_readArgs.Completed += OnReadCompleted;
_readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs);
_encoder = encoder;
_decoder = decoder;
_decoder.MessageReceived = OnMessageReceived;
_writeArgs = new SocketAsyncEventArgs();
_writeArgs.Completed += OnSendCompleted;
_writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs);
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
RemoteEndpoint = EmptyEndpoint.Instance;
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
public Handler(
InitializeHandler initialize,
TerminateHandler terminate,
LoginHandler login,
ConnectHandler connect,
LatencyHandler latency,
DisconnectHandler disconnect,
RoomHandler room,
RoomsPageHandler roomsPage,
RoomOperationHandler roomOperation,
DataHandler data,
ForeignDataHandler foreignData,
LogHandler log)
{
Initialize = initialize;
Terminate = terminate;
Login = login;
Connect = connect;
Latency = latency;
Disconnect = disconnect;
Room = room;
RoomsPage = roomsPage;
RoomOperation = roomOperation;
Data = data;
ForeignData = foreignData;
Log = log;
}
/// <summary>
/// </summary>
/// <param name="readBuffer"></param>
/// <param name="encoder"></param>
/// <param name="decoder"></param>
/// <param name="sslStreamBuilder">Used to wrap the socket with a SSL stream</param>
public SecureTcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder, ISslStreamBuilder sslStreamBuilder)
{
if (readBuffer == null)
{
throw new ArgumentNullException("readBuffer");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (decoder == null)
{
throw new ArgumentNullException("decoder");
}
if (sslStreamBuilder == null)
{
throw new ArgumentNullException("sslStreamBuilder");
}
_encoder = encoder;
_decoder = decoder;
_sslStreamBuilder = sslStreamBuilder;
_decoder.MessageReceived = OnMessageReceived;
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
RemoteEndpoint = EmptyEndpoint.Instance;
_readBuffer = new SocketBuffer(readBuffer);
_writeBuffer = new SocketBuffer();
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
public async Task ShouldRemoveClientFromStore(
[Frozen] Mock <IConnectedClientStore> store,
ConnectedClient client,
DisconnectHandler sut)
{
await sut.HandleAsync(client, Create <Disconnect>(), Cts.Token);
store.Verify(x => x.Remove(client.ClientId));
}
public async Task ShouldSendDisconnectedMessage(
[Frozen] Mock <IConnection> connection,
ConnectedClient client,
DisconnectHandler sut)
{
await sut.HandleAsync(client, Create <Disconnect>(), Cts.Token);
connection.Verify(x => x.SendAsync(It.IsAny <Disconnected>(), Cts.Token));
}
public bool AddDisconnectHandler(DisconnectHandler handler)
{
if (this.m_disconnectHandlers.Contains(handler))
{
return(false);
}
this.m_disconnectHandlers.Add(handler);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="SocketChannel" /> class.
/// </summary>
public SocketChannel()
{
ChannelId = Guid.NewGuid().ToString();
RemoteEndpoint = new IPEndPoint(0, 0);
_messageReceived = (channel, message) => { };
_messageSent = (channel, message) => { };
_clientDisconnected = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
}
/// <summary>
/// Create an instance of <see cref="WebAppServer"/>.
/// </summary>
/// <param name="urlReservation">
/// The URL reservation to listen on. This string is similar to a URL, but the
/// hostname may be a strong wildcard ('+') or a weak wildcard ('*'). E.g. "http://+:8080/".
/// </param>
public WebAppServer(string urlReservation)
{
_urlRegex = new Regex("^" + urlReservation.Replace("*", ".*?").Replace("+", ".*?"), RegexOptions.IgnoreCase);
_listener = new HttpListener();
_listener.Prefixes.Add(urlReservation);
_disconnectHandler = new DisconnectHandler(_listener);
var uri = new Uri(urlReservation.Replace("*", "localhost").Replace("+", "localhost"));
_webAppConfiguration = new WebAppConfiguration(uri);
StaticFiles = new StaticFileSpecCollection();
}
internal OwinHttpListenerContext(HttpListenerContext httpListenerContext, string basePath, string path, string query, DisconnectHandler disconnectHandler)
{
_httpListenerContext = httpListenerContext;
_environment = new CallEnvironment(this);
_owinRequest = new OwinHttpListenerRequest(_httpListenerContext.Request, basePath, path, query, _environment);
_owinResponse = new OwinHttpListenerResponse(_httpListenerContext, _environment);
_disconnectHandler = disconnectHandler;
_environment.OwinVersion = Constants.OwinVersion;
SetServerUser(_httpListenerContext.User);
_environment.RequestContext = _httpListenerContext;
}
internal OwinHttpListenerContext(HttpListenerContext httpListenerContext, string basePath, string path, string query, DisconnectHandler disconnectHandler)
{
_httpListenerContext = httpListenerContext;
_environment = new CallEnvironment(this);
_owinRequest = new OwinHttpListenerRequest(_httpListenerContext.Request, basePath, path, query, _environment);
_owinResponse = new OwinHttpListenerResponse(_httpListenerContext, _environment);
_disconnectHandler = disconnectHandler;
_environment.OwinVersion = Constants.OwinVersion;
SetServerUser(_httpListenerContext.User);
_environment.RequestContext = _httpListenerContext;
}
/// <summary>
/// 释放资源
/// </summary>
/// <param name="disposing">是否也释放托管资源</param>
protected virtual void Dispose(bool disposing)
{
this.Shutdown();
this.StreamReader.Stream.Dispose();
if (disposing)
{
this.socketRoot = null;
this.Socket = null;
this.Tag = null;
this.StreamReader = null;
this.CloseHandler = null;
this.DisconnectHandler = null;
this.ReceiveCompletedHandler = null;
}
}
public Handler(
InitializeHandler initialize,
TerminateHandler terminate,
LoginHandler login,
ConnectHandler connect,
LatencyHandler latency,
DisconnectHandler disconnect,
DataHandler data,
ForeignDataHandler foreignData,
LogHandler log)
{
Initialize = initialize;
Terminate = terminate;
Login = login;
Connect = connect;
Latency = latency;
Disconnect = disconnect;
Data = data;
ForeignData = foreignData;
Log = log;
}
/// <summary>
/// </summary>
/// <param name="readBuffer"></param>
/// <param name="encoder"></param>
/// <param name="decoder"></param>
/// <param name="sslStreamBuilder">Used to wrap the socket with a SSL stream</param>
public SecureTcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder, ISslStreamBuilder sslStreamBuilder) {
if (readBuffer == null) throw new ArgumentNullException("readBuffer");
if (encoder == null) throw new ArgumentNullException("encoder");
if (decoder == null) throw new ArgumentNullException("decoder");
if (sslStreamBuilder == null) throw new ArgumentNullException("sslStreamBuilder");
_encoder = encoder;
_decoder = decoder;
_sslStreamBuilder = sslStreamBuilder;
_decoder.MessageReceived = OnMessageReceived;
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
RemoteEndpoint = EmptyEndpoint.Instance;
_readBuffer = new SocketBuffer(readBuffer);
_writeBuffer = new SocketBuffer();
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
/// <summary>
/// Initializes a new instance of the <see cref="TcpChannel" /> class.
/// </summary>
/// <param name="readBuffer">Buffer used for our reading.</param>
/// <param name="encoder">Used to encode messages before they are put in the MicroMessage body of outbound messages.</param>
/// <param name="decoder">
/// Used to decode the body of incoming MicroMessages. The <c>MessageReceived</c> delegate will be
/// overridden by this class.
/// </param>
public TcpChannel(IBufferSlice readBuffer, IMessageEncoder encoder, IMessageDecoder decoder)
{
IsConnected = false;
if (readBuffer == null)
{
throw new ArgumentNullException("readBuffer");
}
if (encoder == null)
{
throw new ArgumentNullException("encoder");
}
if (decoder == null)
{
throw new ArgumentNullException("decoder");
}
_readArgs = new SocketAsyncEventArgs();
_readArgs.SetBuffer(readBuffer.Buffer, readBuffer.Offset, readBuffer.Capacity);
_readArgs.Completed += OnReadCompleted;
_readArgsWrapper = new SocketAsyncEventArgsWrapper(_readArgs);
_encoder = encoder;
_decoder = decoder;
_decoder.MessageReceived = OnMessageReceived;
_writeArgs = new SocketAsyncEventArgs();
_writeArgs.Completed += OnSendCompleted;
_writeArgsWrapper = new SocketAsyncEventArgsWrapper(_writeArgs);
_sendCompleteAction = (channel, message) => { };
_disconnectAction = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleRemoteDisconnect(SocketError.ProtocolNotSupported, error);
RemoteEndpoint = EmptyEndpoint.Instance;
ChannelId = GuidFactory.Create().ToString();
Data = new ChannelData();
}
private void OnDisconnectEventHandler()
{
DisconnectHandler?.Invoke(this, EventArgs.Empty);
}
public void SetDisconnectHandler(DisconnectHandler handler)
{
_disconnectHandler = handler;
}
public bool RemoveDisconnectHandler(DisconnectHandler handler)
{
return(this.m_disconnectHandlers.Remove(handler));
}
public void Update()
{
SslSocket.Process();
List <SslClientConnection.ConnectionEvent> connectionEvents = this.m_connectionEvents;
lock (connectionEvents)
{
using (List <SslClientConnection.ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator())
{
while (enumerator.MoveNext())
{
SslClientConnection.ConnectionEvent current = enumerator.get_Current();
switch (current.Type)
{
case SslClientConnection.ConnectionEventTypes.OnConnected:
{
if (current.Error != BattleNetErrors.ERROR_OK)
{
this.Disconnect();
this.m_connectionState = SslClientConnection.ConnectionState.ConnectionFailed;
}
else
{
this.m_connectionState = SslClientConnection.ConnectionState.Connected;
}
ConnectHandler[] array = this.m_connectHandlers.ToArray();
for (int i = 0; i < array.Length; i++)
{
ConnectHandler connectHandler = array[i];
connectHandler(current.Error);
}
break;
}
case SslClientConnection.ConnectionEventTypes.OnDisconnected:
{
if (current.Error != BattleNetErrors.ERROR_OK)
{
this.Disconnect();
}
DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray();
for (int j = 0; j < array2.Length; j++)
{
DisconnectHandler disconnectHandler = array2[j];
disconnectHandler(current.Error);
}
break;
}
case SslClientConnection.ConnectionEventTypes.OnPacketCompleted:
for (int k = 0; k < this.m_listeners.get_Count(); k++)
{
IClientConnectionListener <BattleNetPacket> clientConnectionListener = this.m_listeners.get_Item(k);
object state = this.m_listenerStates.get_Item(k);
clientConnectionListener.PacketReceived(current.Packet, state);
}
break;
}
}
}
this.m_connectionEvents.Clear();
}
if (this.m_sslSocket == null || this.m_connectionState != SslClientConnection.ConnectionState.Connected)
{
return;
}
while (this.m_outQueue.get_Count() > 0)
{
if (this.OnlyOneSend && !this.m_sslSocket.m_canSend)
{
return;
}
BattleNetPacket packet = this.m_outQueue.Dequeue();
this.SendPacket(packet);
}
}
public Task Disconnect(Connection connection)
{
return(DisconnectHandler?.Invoke(connection));
}
/// <summary>
/// Initializes a new instance of the <see cref="SocketChannel" /> class.
/// </summary>
public SocketChannel()
{
ChannelId = Guid.NewGuid().ToString();
RemoteEndpoint = new IPEndPoint(0, 0);
_messageReceived = (channel, message) => { };
_messageSent = (channel, message) => { };
_clientDisconnected = (channel, exception) => { };
ChannelFailure = (channel, error) => HandleDisconnect(SocketError.ProtocolNotSupported);
}
public void InitDisconnect()
{
Connection.On <string>("Disconnect", (tcpId) => DisconnectHandler?.Invoke(tcpId));
}
public void Update()
{
object mutex = this.m_mutex;
lock (mutex)
{
using (List <ClientConnection <PacketType> .ConnectionEvent> .Enumerator enumerator = this.m_connectionEvents.GetEnumerator())
{
while (enumerator.MoveNext())
{
ClientConnection <PacketType> .ConnectionEvent current = enumerator.get_Current();
this.PrintConnectionException(current);
switch (current.Type)
{
case ClientConnection <PacketType> .ConnectionEventTypes.OnConnected:
{
if (current.Error != BattleNetErrors.ERROR_OK)
{
this.DisconnectSocket();
this.m_connectionState = ClientConnection <PacketType> .ConnectionState.ConnectionFailed;
}
else
{
this.m_connectionState = ClientConnection <PacketType> .ConnectionState.Connected;
}
ConnectHandler[] array = this.m_connectHandlers.ToArray();
for (int i = 0; i < array.Length; i++)
{
ConnectHandler connectHandler = array[i];
connectHandler(current.Error);
}
break;
}
case ClientConnection <PacketType> .ConnectionEventTypes.OnDisconnected:
{
if (current.Error != BattleNetErrors.ERROR_OK)
{
this.Disconnect();
}
DisconnectHandler[] array2 = this.m_disconnectHandlers.ToArray();
for (int j = 0; j < array2.Length; j++)
{
DisconnectHandler disconnectHandler = array2[j];
disconnectHandler(current.Error);
}
break;
}
case ClientConnection <PacketType> .ConnectionEventTypes.OnPacketCompleted:
for (int k = 0; k < this.m_listeners.get_Count(); k++)
{
IClientConnectionListener <PacketType> clientConnectionListener = this.m_listeners.get_Item(k);
object state = this.m_listenerStates.get_Item(k);
clientConnectionListener.PacketReceived(current.Packet, state);
}
break;
}
}
}
this.m_connectionEvents.Clear();
}
if (this.m_socket == null || this.m_connectionState != ClientConnection <PacketType> .ConnectionState.Connected)
{
return;
}
this.SendQueuedPackets();
}
