private bool connection()
{
bool connected = false;
while (_isALive)
{
try
{
_socket.Connect(IPADDRESS, PORT);
Package package;
if (trySendAndReceive(new Package(0, Convert.ToByte('v'), null), out package))
{
Connected.Raise(this, new LinkEventArgs(String.Format("The connection is established ({0}). Version: {1}", PORT, string.Join(".", package.Data.Skip(4).Take(4)))));
//Received.Raise(this, new ReceiveEventArgs(package));
return(true);
}
return(false);
}
catch (SocketException)
{
Thread.Sleep(1000);
if (!connected)
{
connected = true;
Connected.Raise(this, new LinkEventArgs(String.Format("The connection is failed ({0})", PORT)));
return(true);
}
}
}
return(false);
}
private void Connect(IPEndPoint endpoint)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ReceiveBufferSize = BUFF_SIZE
};
_socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
_recvBuffer = new byte[BUFF_SIZE];
_incompletePacketBuffer = new byte[BUFF_SIZE];
_decompBuffer = new byte[BUFF_SIZE];
_circularBuffer = new CircularBuffer();
_recvEventArgs = new SocketAsyncEventArgs();
_recvEventArgs.Completed += IO_Socket;
_recvEventArgs.SetBuffer(_recvBuffer, 0, _recvBuffer.Length);
_recvQueue = new ConcurrentQueue <Packet>();
Statistics.Reset();
try
{
_socket.Connect(endpoint);
if (_socket.Connected)
{
Connected.Raise();
Statistics.ConnectedFrom = DateTime.Now;
StartRecv();
}
}
catch (SocketException e)
{
Log.Error(e.ToString());
Disconnect(e.SocketErrorCode);
}
}
private bool connection()
{
bool connected = false;
while (_isALive)
{
try
{
_port.Open();
Connected.Raise(this, new LinkEventArgs(String.Format("{0} opened", _port.PortName)));
return(true);
}
catch (IOException)
{
Thread.Sleep(1000);
if (!connected)
{
connected = true;
Connected.Raise(this, new LinkEventArgs(String.Format("{0} failed", _port.PortName)));
return(true);
}
}
}
return(false);
}
private void Connect(IPEndPoint endpoint)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
_recvBuffer = _pool.GetFreeSegment();
_incompletePacketBuffer = _pool.GetFreeSegment();
_sendQueue = new SendQueue();
_circularBuffer = new CircularBuffer();
_sendEventArgs = new SocketAsyncEventArgs();
_sendEventArgs.Completed += IO_Socket;
_recvEventArgs = new SocketAsyncEventArgs();
_recvEventArgs.Completed += IO_Socket;
_recvEventArgs.SetBuffer(_recvBuffer, 0, _recvBuffer.Length);
_queue.Clear();
_workingQueue.Clear();
SocketAsyncEventArgs connectEventArgs = new SocketAsyncEventArgs();
connectEventArgs.Completed += (sender, e) =>
{
if (e.SocketError == SocketError.Success)
{
Connected.Raise();
StartRecv();
}
else
{
Log.Message(LogTypes.Error, e.SocketError.ToString());
Disconnect();
}
};
connectEventArgs.RemoteEndPoint = endpoint;
_socket.ConnectAsync(connectEventArgs);
}
private Task <bool> InternalConnect(IPAddress address, ushort port)
{
try
{
return(_tcpClient
.ConnectAsync(address, port)
.ContinueWith(
(t) =>
{
if (!t.IsFaulted && _tcpClient.Connected)
{
_netStream = _tcpClient.GetStream();
Status = ClientSocketStatus.Connected;
Connected.Raise();
Statistics.ConnectedFrom = DateTime.Now;
return true;
}
Status = ClientSocketStatus.Disconnected;
Log.Error("socket not connected");
return false;
}, TaskContinuationOptions.ExecuteSynchronously));
}
catch (SocketException e)
{
Log.Error($"Socket error when connecting:\n{e}");
Disconnect(e.SocketErrorCode);
return(TaskCompletedFalse);
}
}
public async Task <bool> Connect(IPAddress address, ushort port)
{
IsDisposed = false;
if (Status != ClientSocketStatus.Disconnected)
{
Log.Warn($"Socket status: {Status}");
return(false);
}
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_sendingBuffer = new byte[4096];
_sendingCount = 0;
_circularBuffer = new CircularBuffer(BUFF_SIZE);
_incompleteBuffer = new CircularBuffer(512);
_pluginRecvQueue = new ConcurrentQueue <byte[]>();
Statistics.Reset();
Status = ClientSocketStatus.Connecting;
try
{
return(await _socket
.ConnectAsync(address, port)
.ContinueWith
(
(t) =>
{
if (!t.IsFaulted && _socket.Connected)
{
Status = ClientSocketStatus.Connected;
Connected.Raise();
Statistics.ConnectedFrom = DateTime.Now;
return true;
}
Status = ClientSocketStatus.Disconnected;
Log.Error("socket not connected");
return false;
},
TaskContinuationOptions.ExecuteSynchronously
));
}
catch (SocketException e)
{
Log.Error($"Socket error when connecting:\n{e}");
_logFile?.Write($"connection error: {e}");
Disconnect(e.SocketErrorCode);
return(false);
}
}
private void InternalConnect(EndPoint endpoint)
{
try
{
_socket.Connect(endpoint);
if (_socket.Connected)
{
Connected.Raise();
Statistics.ConnectedFrom = DateTime.Now;
StartRecv();
}
}
catch (SocketException e)
{
Log.Error(e.ToString());
Disconnect(e.SocketErrorCode);
}
}
private void Connect(IPEndPoint endpoint)
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
ReceiveBufferSize = BUFF_SIZE
};
_socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
_recvBuffer = new byte[BUFF_SIZE];
_incompletePacketBuffer = new byte[BUFF_SIZE];
_decompBuffer = new byte[BUFF_SIZE];
_sendQueue = new SendQueue();
_circularBuffer = new CircularBuffer();
_sendEventArgs = new SocketAsyncEventArgs();
_sendEventArgs.Completed += IO_Socket;
_recvEventArgs = new SocketAsyncEventArgs();
_recvEventArgs.Completed += IO_Socket;
_recvEventArgs.SetBuffer(_recvBuffer, 0, _recvBuffer.Length);
_recvQueue = new ConcurrentQueue <Packet>();
Statistics.Reset();
SocketAsyncEventArgs connectEventArgs = new SocketAsyncEventArgs();
connectEventArgs.Completed += (sender, e) =>
{
if (e.SocketError == SocketError.Success)
{
Connected.Raise();
Statistics.ConnectedFrom = Engine.CurrDateTime;
StartRecv();
}
else
{
Log.Message(LogTypes.Error, e.SocketError.ToString());
Disconnect(e.SocketError);
}
};
connectEventArgs.RemoteEndPoint = endpoint;
_socket.ConnectAsync(connectEventArgs);
}
private void InternalConnect(EndPoint endpoint)
{
try
{
_socket.Connect(endpoint);
if (_socket.Connected)
{
Connected.Raise();
Statistics.ConnectedFrom = DateTime.Now;
StartRecv();
}
else
{
Log.Error("socket not connected");
}
}
catch (SocketException e)
{
Log.Error($"Socket error when connecting:\n{e}");
Disconnect(e.SocketErrorCode);
}
}
private void NetPluginConnectedEvent(object sender, ISledTarget target)
{
if (!m_bAuthenticated)
{
NetPluginConnectingEvent(target);
}
else
{
IsConnecting = false;
IsConnected = true;
IsDebugging = true;
SledOutDevice.OutLine(
SledMessageType.Info,
SledUtil.TransSub(Localization.SledTargetConnectionEstablishedTo, target));
// Update status text
m_connectStatus.Text = Localization.SledConnected + ": " + target;
// Fire event
Connected.Raise(this, new SledDebugServiceEventArgs(target));
}
}
public static void InvokeConnect()
{
NetworkManager.SocketClient.Status = ConnectionStatus.Online;
Connected.Raise();
}
private static unsafe int OnMessage(UOMessage msg, int arg1, int arg2, int arg3, byte *data)
{
try
{
switch (msg)
{
case UOMessage.Ready:
Ready = true;
hooks.Send(UOMessage.ConnectionInfo, (int)ServerIP, ServerPort);
hooks.Send(UOMessage.GameSize, Width, Height);
OnInit();
break;
case UOMessage.Connected:
Connected.Raise();
break;
case UOMessage.Disconnecting:
Disconnecting.Raise();
break;
case UOMessage.Closing:
Closing.Raise();
break;
case UOMessage.Focus:
FocusChanged.Raise(arg1 != 0);
break;
case UOMessage.Visibility:
VisibilityChanged.Raise(arg1 != 0);
break;
case UOMessage.KeyDown:
UOKeyEventArgs keyArgs = new UOKeyEventArgs(arg1, arg2);
KeyDown.Raise(keyArgs);
if (keyArgs.Filter)
{
return(1);
}
break;
case UOMessage.PacketToClient:
Packet toClient = new Packet(data, arg1);
PacketToClient.Raise(toClient);
if (toClient.Filter)
{
return(1);
}
if (toClient.Changed)
{
return(2);
}
break;
case UOMessage.PacketToServer:
Packet toServer = new Packet(data, arg1);
PacketToServer.Raise(toServer);
if (toServer.Filter)
{
return(1);
}
if (toServer.Changed)
{
return(2);
}
break;
}
}
catch (Exception ex) { OnException(ex); }
return(0);
}
