/// <summary>
/// Constructor for client support
/// </summary>
/// <param name="sizeOfRawBuffer"> The size of the raw buffer </param>
/// <param name="userArg"> A Reference to the Users arguments </param>
/// <param name="messageHandler"> Reference to the user defined message handler method </param>
/// <param name="closeHandler"> Reference to the user defined close handler method </param>
/// <param name="errorHandler"> Reference to the user defined error handler method </param>
public SocketClient(int sizeOfRawBuffer, object userArg,
MessageHandler messageHandler, CloseHandler closeHandler,
ErrorHandler errorHandler, ConnectHandler connectHandler)
{
// Create the raw buffer
this.SizeOfRawBuffer = sizeOfRawBuffer;
this.RawBuffer = new Byte[this.SizeOfRawBuffer];
// Save the user argument
this.userArg = userArg;
// Set the handler methods
this.messageHandler = messageHandler;
this.closeHandler = closeHandler;
this.errorHandler = errorHandler;
this.connectHandler = connectHandler;
// Set the async socket method handlers
this.callbackReadMethod = new AsyncCallback(ReceiveComplete);
this.callbackWriteMethod = new AsyncCallback(SendComplete);
this.callbackWriteHeadMethod = new AsyncCallback(SendHead);
this.m_Connected = true;
// Init the dispose flag
this.disposed = false;
}
/// <summary>
/// </summary>
/// <param name="repository">
/// Used to provide all queues that this broker is for. There is a built in class,
/// <see cref="MemoryQueueRepository" />, which you can use.
/// </param>
public StompBroker(IQueueRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
_queues = repository;
_tcpListener = new StompTcpListener {
MessageReceived = OnMessageReceived, MessageSent = OnMessageDelivered
};
_tcpListener.ClientConnected += OnClientConnected;
_tcpListener.ClientDisconnected += OnClientDisconnected;
ServerName = "Griffin.Queue/1.0";
var connectHandler = new ConnectHandler(new NoAuthenticationService(), ServerName);
_frameHandlers.Add("ACK", new AckHandler());
_frameHandlers.Add("ABORT", new AbortHandler());
_frameHandlers.Add("BEGIN", new BeginHandler());
_frameHandlers.Add("COMMIT", new CommitHandler());
_frameHandlers.Add("CONNECT", connectHandler);
_frameHandlers.Add("DISCONNECT", new MessageHandlers.DisconnectHandler());
_frameHandlers.Add("NACK", new NackHandler(_queues));
_frameHandlers.Add("SEND", new SendHandler(_queues));
_frameHandlers.Add("SUBSCRIBE", new SubscribeHandler(_queues));
_frameHandlers.Add("STOMP", connectHandler);
}
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>
internal ClientSocketManager(Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer)
{
if (connecter == null)
{
throw new Exception("ClientSocketHandler.ClientSocketManager(...) - listener == null error!");
}
if (connectHandler == null)
{
throw new Exception("ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!");
}
if (receiveBuffer == null)
{
throw new Exception("ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!");
}
m_Connecter = connecter;
m_ConnectHandle = connectHandler;
m_ReceiveBuffer = receiveBuffer;
{
// 清空数据
m_ReceiveBuffer.Clear();
}
// 初始化数据 表示还没调用过Free(...)函数
m_LockFree.SetValid();
}
public void using_authentication()
{
var authService = Substitute.For <IAuthenticationService>();
authService.IsActivated.Returns(true);
authService.Login("hello", "world").Returns(new LoginResponse()
{
IsSuccessful = true, Token = "mamma"
});
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
frame.Headers["accept-version"] = "2.0";
frame.Headers["login"] = "******";
frame.Headers["passcode"] = "world";
client.SessionKey.Returns(Guid.NewGuid().ToString());
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Should().NotBeNull();
actual.Headers["version"].Should().Be("2.0");
actual.Headers["server"].Should().Be("Kickass");
actual.Headers["session"].Should().NotBeNull();
client.ReceivedWithAnyArgs().SetAsAuthenticated("mamma");
}
public static ConnectHandler Get(string connectStr)
{
ConnectHandler ret = null;
connectors.TryGetValue(connectStr, out ret);
return(ret);
}
protected override void ProcessAccept(UDPPacket packet)
{
IPEndPoint remote = (IPEndPoint)packet.AsyncEventArgs.RemoteEndPoint;
//Task.Run(() =>
//{
if (packet.BytesRecieved.Length < 6)
{
return;
}
BasePacket basePacket = new BasePacket(packet.BytesRecieved);
try
{
//BytesRecieved[7] is nnpacket.PacketType.
switch (basePacket.PacketType)
{
case NatPacketType.PreInit:
//NatNegHandler.PreInitResponse(this, packet, nnpacket);
break;
case NatPacketType.Init:
InitHandler.InitResponse(this, packet);
break;
case NatPacketType.AddressCheck:
AddressHandler.AddressCheckResponse(this, packet);
break;
case NatPacketType.NatifyRequest:
NatifyHandler.NatifyResponse(this, packet);
break;
case NatPacketType.ConnectAck:
ConnectHandler.ConnectResponse(this, packet);
break;
case NatPacketType.Report:
ReportHandler.ReportResponse(this, packet);
break;
default:
LogWriter.Log.Write(LogLevel.Error, "{0,-8} [Recv] unknow data", ServerName);
break;
}
}
catch (Exception e)
{
LogWriter.Log.WriteException(e);
}
finally
{
if (Replied == true)
{
Release(packet.AsyncEventArgs);
}
}
}
protected void OnConnectEvent(EventArgs e)
{
ConnectHandler ev = ConnectEvent;
//This may not be the exact right syntax.
_syncSource.BeginInvoke(ev, this, e);
}
public bool AddConnectHandler(ConnectHandler handler)
{
if (this.m_connectHandlers.Contains(handler))
{
return(false);
}
this.m_connectHandlers.Add(handler);
return(true);
}
protected virtual SocketClient AcceptedSocketClient( SocketServer socketServer,
Socket clientSocket, string ipAddress, int port,
int sizeOfRawBuffer, object userArg, MessageHandler messageHandler,
CloseHandler closeHandler, ErrorHandler errorHandler, ConnectHandler connectHandler)
{
return new SocketClient( socketServer, clientSocket,
ipAddress, port, sizeOfRawBuffer, userArg, messageHandler,
closeHandler, errorHandler, connectHandler);
}
public void version_is_required_according_to_the_specification()
{
var authService = Substitute.For <IAuthenticationService>();
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Should().NotBeNull();
actual.Headers["version"].Should().Be("2.0");
actual.Headers["message"].Should().Be("Missing the 'accept-version' header.");
}
public void only_accepting_20_clients()
{
var authService = Substitute.For <IAuthenticationService>();
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
frame.Headers["accept-version"] = "1.1";
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Should().NotBeNull();
actual.Headers["version"].Should().Be("2.0");
actual.Headers["message"].Should().Be("Only accepting stomp 2.0 clients.");
}
private void OnConnect(Target trg)
{
ConnectHandler handler = Connected;
m_curTarget = trg;
m_curTarget.IsConnected = true;
if (handler != null)
{
m_cctx.Send(delegate
{
handler(this, trg);
}, null);
}
}
private void OnDisconnected()
{
ConnectHandler handler = Disconnected;
m_curTarget.IsConnected = false;
lock (m_syncSocket)
{
m_ConnectionInProgress = false;
}
if (handler != null)
{
m_cctx.Send(delegate
{
handler(this, m_curTarget);
}, null);
}
}
public void using_authentication_but_no_password_was_supplied()
{
var authService = Substitute.For <IAuthenticationService>();
authService.IsActivated.Returns(true);
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
frame.Headers["accept-version"] = "2.0";
frame.Headers["login"] = "******";
client.SessionKey.Returns(Guid.NewGuid().ToString());
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Headers["message"].Should().NotBeNullOrEmpty();
}
public void always_accept_when_authentication_is_turned_off()
{
var authService = Substitute.For <IAuthenticationService>();
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
frame.Headers["accept-version"] = "2.0";
client.SessionKey.Returns(Guid.NewGuid().ToString());
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Should().NotBeNull();
actual.Headers["version"].Should().Be("2.0");
actual.Headers["server"].Should().Be("Kickass");
actual.Headers["session"].Should().NotBeNullOrEmpty();
client.ReceivedWithAnyArgs().SetAsAuthenticated(null);
}
public ConnectHandler AttachSpotifyConnect(
ISpotifyDevice device,
uint initialVolume,
int volumeSteps)
{
WaitAuthLock();
var player =
new SpotifyPlayer(
this,
device,
initialVolume,
volumeSteps);
var connectHandler
= new ConnectHandler(this, player);
return(connectHandler);
}
public static void Switch(NatNegServer server, byte[] message)
{
BasePacket basePacket = new BasePacket(message);
try
{
//BytesRecieved[7] is nnpacket.PacketType.
switch (basePacket.PacketType)
{
case NatPacketType.PreInit:
//NatNegHandler.PreInitResponse(this, packet, nnpacket);
break;
case NatPacketType.Init:
InitHandler.InitResponse(server, message);
break;
case NatPacketType.AddressCheck:
AddressHandler.AddressCheckResponse(server, message);
break;
case NatPacketType.NatifyRequest:
NatifyHandler.NatifyResponse(server, message);
break;
case NatPacketType.ConnectAck:
ConnectHandler.ConnectResponse(server, message);
break;
case NatPacketType.Report:
ReportHandler.ReportResponse(server, message);
break;
default:
server.UnknownDataRecived(message);
break;
}
}
catch (Exception e)
{
LogWriter.Log.WriteException(e);
}
}
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;
}
public void using_authentication_but_with_incorrect_password()
{
var authService = Substitute.For <IAuthenticationService>();
authService.IsActivated.Returns(true);
authService.Login("hello", "world").Returns(new LoginResponse()
{
IsSuccessful = false, Token = "mamma", Reason = "Incorrect password"
});
var frame = new BasicFrame("STOMP");
var client = Substitute.For <IStompClient>();
frame.Headers["accept-version"] = "2.0";
frame.Headers["login"] = "******";
frame.Headers["passcode"] = "world";
client.SessionKey.Returns(Guid.NewGuid().ToString());
var sut = new ConnectHandler(authService, "Kickass");
var actual = sut.Process(client, frame);
actual.Headers["message"].Should().Be("Incorrect password");
}
/// <summary>
///
/// </summary>
internal ClientSocketManager( Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer )
{
if ( connecter == null )
throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - listener == null error!" );
if ( connectHandler == null )
throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!" );
if ( receiveBuffer == null )
throw new Exception( "ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!" );
m_Connecter = connecter;
m_ConnectHandle = connectHandler;
m_ReceiveBuffer = receiveBuffer;
{
// 清空数据
m_ReceiveBuffer.Clear();
}
// 初始化数据 表示还没调用过Free(...)函数
m_LockFree.SetValid();
}
/// <summary>
/// Begins listening for new connections on the specified port. Note that the OnConnect method will
/// only be called for new connections from previously unknown IPEndPoint's. If stored, the returned listener
/// can eventually be used to end listening.
/// </summary>
public static Listener Listen(int Port, ConnectHandler OnConnect)
{
return new Listener(Port, OnConnect);
}
public bool RemoveConnectHandler(ConnectHandler handler)
{
return(this.m_connectHandlers.Remove(handler));
}
public void Update()
{
object mutex = this.m_mutex;
lock (mutex)
{
foreach (ConnectionEvent <PacketType> event2 in this.m_connectionEvents)
{
ConnectHandler <PacketType>[] handlerArray;
int num3;
IConnectionListener <PacketType> listener;
this.PrintConnectionException(event2);
switch (event2.Type)
{
case ConnectionEventTypes <PacketType> .OnConnected:
if (event2.Error == BattleNetErrors.ERROR_OK)
{
break;
}
this.DisconnectSocket();
this.m_connectionState = ConnectionState <PacketType> .ConnectionFailed;
goto Label_0071;
case ConnectionEventTypes <PacketType> .OnDisconnected:
{
if (event2.Error != BattleNetErrors.ERROR_OK)
{
this.Disconnect();
}
foreach (DisconnectHandler <PacketType> handler2 in this.m_disconnectHandlers.ToArray())
{
handler2(event2.Error);
}
continue;
}
case ConnectionEventTypes <PacketType> .OnPacketCompleted:
num3 = 0;
goto Label_0138;
default:
{
continue;
}
}
this.m_connectionState = ConnectionState <PacketType> .Connected;
Label_0071:
handlerArray = this.m_connectHandlers.ToArray();
for (int i = 0; i < handlerArray.Length; i++)
{
ConnectHandler <PacketType> handler = handlerArray[i];
handler(event2.Error);
}
continue;
Label_0105:
listener = this.m_listeners[num3];
object state = this.m_listenerStates[num3];
listener.PacketReceived(event2.Packet, state);
num3++;
Label_0138:
if (num3 < this.m_listeners.Count)
{
goto Label_0105;
}
}
this.m_connectionEvents.Clear();
}
if ((this.m_socket != null) && (this.m_connectionState == ConnectionState <PacketType> .Connected))
{
this.SendQueuedPackets();
}
}
public bool RemoveConnectHandler(ConnectHandler <PacketType> handler)
{
return(this.m_connectHandlers.Remove(handler));
}
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();
}
/// <summary>
/// Tries, asynchronously, to connect a UDPX client to the given endpoint. The connect handler will be called with
/// null if no connection can be established.
/// </summary>
public static void Connect(IPEndPoint EndPoint, ConnectHandler OnConnect)
{
// Create sequence number
int seq = _CreateInitialSequence();
byte[] handshake = new byte[5];
handshake[0] = (byte)PacketType.Handshake;
_WriteInt(seq, handshake, 1);
UdpClient cli = new UdpClient();
int attempts = 5;
double attemptinterval = 0.5;
double timeout = 1.0;
// Set up request timer
Timer timer = new Timer(attemptinterval * 1000.0);
timer.Elapsed += delegate
{
lock (cli)
{
if (OnConnect != null)
{
if (attempts > 0)
{
Send(cli, EndPoint, handshake);
attempts--;
}
else
{
timer.Dispose();
timer = new Timer(timeout * 1000.0);
timer.AutoReset = false;
timer.Elapsed += delegate
{
lock (cli)
{
if (OnConnect != null)
{
// Timeout
OnConnect(null);
OnConnect = null;
((IDisposable)cli).Dispose();
}
timer.Dispose();
}
};
timer.Start();
}
}
else
{
timer.Dispose();
}
}
};
timer.AutoReset = true;
// Send initial attempt to open receiving port.
Send(cli, EndPoint, handshake);
attempts--;
// Create receive callback
ReceiveRawPacketHandler receivepacket = null;
List<byte[]> queue = new List<byte[]>();
Receive(cli, receivepacket = delegate(IPEndPoint From, byte[] Data)
{
lock (cli)
{
if (OnConnect != null)
{
if (From.Equals(EndPoint))
{
if (Data.Length == 5 && Data[0] == (byte)PacketType.HandshakeAck)
{
int recvseq = _ReadInt(Data, 1);
_ClientConnection cc = new _ClientConnection(seq, recvseq, cli, EndPoint);
OnConnect(cc);
// Give the new connection the messages intended for it
foreach (byte[] qdata in queue)
{
cc.ReceiveRaw(qdata);
}
OnConnect = null;
}
else
{
// Add data to packet queue and try again
queue.Add(Data);
Receive(cli, receivepacket);
}
}
else
{
// Not the packet we were looking for, try again...
Receive(cli, receivepacket);
}
}
}
});
// Begin sending more attempts
timer.Start();
}
/// <summary>
///
/// </summary>
internal ClientSocketManager( Connecter connecter, ConnectHandler connectHandler, ReceiveQueue receiveBuffer )
{
if ( connecter == null )
throw new ArgumentNullException( "ClientSocketHandler.ClientSocketManager(...) - listener == null error!" );
if ( connectHandler == null )
throw new ArgumentNullException( "ClientSocketHandler.ClientSocketManager(...) - serviceHandle == null error!" );
if ( receiveBuffer == null )
throw new ArgumentNullException( "receiveBuffer", "ClientSocketHandler.ClientSocketManager(...) - receiveBuffer == null error!" );
m_Connecter = connecter;
m_ConnectHandle = connectHandler;
m_ReceiveBuffer = receiveBuffer;
{
// �������
m_ReceiveBuffer.Clear();
}
// ��ʼ������ ��ʾ��û���ù�Free(...)����
m_LockFree.SetValid();
}
/// <summary> Constructor for SocketServer Suppport </summary>
/// <param name="socketServer"> A Reference to the parent SocketServer </param>
/// <param name="clientSocket"> The Socket object we are encapsulating </param>
/// <param name="socketListArray"> The index of the SocketServer Socket List Array </param>
/// <param name="ipAddress"> The IpAddress of the remote server </param>
/// <param name="port"> The Port of the remote server </param>
/// <param name="messageHandler"> Reference to the user defined message handler function </param>
/// <param name="closeHandler"> Reference to the user defined close handler function </param>
/// <param name="errorHandler"> Reference to the user defined error handler function </param>
/// <param name="sizeOfRawBuffer"> The size of the raw buffer </param>
/// <param name="userArg"> A Reference to the Users arguments </param>
public SocketClient(SocketServer socketServer, Socket clientSocket,
string ipAddress, int port, int sizeOfRawBuffer,
object userArg, MessageHandler messageHandler, CloseHandler closeHandler,
ErrorHandler errorHandler, ConnectHandler connectHandler)
:this(sizeOfRawBuffer,userArg, messageHandler,closeHandler,errorHandler, connectHandler)
{
// Set reference to SocketServer
this.socketServer = socketServer;
// Init the socket references
this.clientSocket = clientSocket;
// Set the Ipaddress and Port
this.ipAddress = ipAddress;
this.port = port;
// Init the NetworkStream reference
this.networkStream = new NetworkStream(this.clientSocket);
// Set these socket options
this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket,
System.Net.Sockets.SocketOptionName.ReceiveBuffer, this.receiveBufferSize);
this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket,
System.Net.Sockets.SocketOptionName.SendBuffer, this.sendBufferSize);
this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Socket,
System.Net.Sockets.SocketOptionName.DontLinger, 1);
this.clientSocket.SetSocketOption(System.Net.Sockets.SocketOptionLevel.Tcp,
System.Net.Sockets.SocketOptionName.NoDelay, 1);
// Wait for a message
Receive();
}
/// <summary>
/// Overloaded constructor for client support
/// </summary>
/// <param name="sendBufferSize"></param>
/// <param name="receiveBufferSize"></param>
/// <param name="sizeOfRawBuffer"> The size of the raw buffer </param>
/// <param name="userArg"> A Reference to the Users arguments </param>
/// <param name="messageHandler"> Reference to the user defined message handler method </param>
/// <param name="closeHandler"> Reference to the user defined close handler method </param>
/// <param name="errorHandler"> Reference to the user defined error handler method </param>
public SocketClient(int sendBufferSize, int receiveBufferSize,
int sizeOfRawBuffer,
object userArg,
MessageHandler messageHandler,
CloseHandler closeHandler,
ErrorHandler errorHandler,
ConnectHandler conenectHandler
)
: this(sizeOfRawBuffer, userArg, messageHandler, closeHandler, errorHandler, conenectHandler)
{
//Set the size of the send/receive buffers
this.sendBufferSize = sendBufferSize;
this.receiveBufferSize = receiveBufferSize;
}
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 Listener(int Port, ConnectHandler OnConnect)
{
this._Client = new UdpClient(Port);
this._Connections = new Dictionary<IPEndPoint, _LConnection>();
this._OnConnect = OnConnect;
this._BeginListen();
}
