public void Connect(string addr, int port, string pub, bool async = true)
{
var ip = NetHelper.ParseIpAddressV6(addr);
if (ip == null)
{
throw new Exception("Unknown addr = " + addr);
}
Close(string.Empty);
m_SocketArgs = new SocketArgs();
m_SocketArgs.m_RsaPub = pub;
if (!Rsa.CheckIsPub(pub))
{
throw new Exception(string.Format("RsaPub error {0}", pub));
}
m_SocketArgs.m_Socket = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
m_SocketArgs.m_Socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
m_SocketArgs.m_Socket.NoDelay = true;
LogHelper.Debug("NetClient Connect {0}:{1}", ip, port);
if (async)
{
m_SocketArgs.m_Socket.BeginConnect(new IPEndPoint(ip, port), new AsyncCallback(ConnectCallback), m_SocketArgs);
}
else
{
m_SocketArgs.m_Socket.Connect(new IPEndPoint(ip, port));
LogHelper.Debug("NetClient Connect {0}", "OK");
OnConnected(m_SocketArgs);
}
}
private void ReadAsync(EventHandler <SocketAsyncEventArgs> callback, object state = null)
{
SocketAsyncState = state;
SocketArgs.SetBuffer(ReceiveData, Index, Remaining);
SocketCallback = callback;
connection.Client.ReceiveAsync(SocketArgs);
}
//bool bigIncoming = false;
//byte[] auxTextBuffer = null;
//byte[] auxImageBuffer = new byte[10000000];
//byte[] auxAudioBuffer = null;
#endregion
#region SETUP
public void RunEvent(EventHandler <SocketArgs> evt, SocketArgs args = null)
{
if (evt != null)
{
evt(this, args);
}
}
private void DisconnectCallback(IAsyncResult ar)
{
Connection.EndDisconnect(ar);
SocketArgs args = new SocketArgs(Connection);
Disconnect?.Invoke(this, args);
}
/// <summary>
/// Disconnect from a certain client reuse is false since the Socket object is removed from the list.
/// </summary>
/// <param name="sock">Socket to disconnect from</param>
public void BeginDisconnect(Socket sock)
{
sock.Disconnect(false);
SocketArgs args = new SocketArgs(sock);
Connections.Remove(sock);
Disconnect?.Invoke(this, args);
}
public void Close(string message)
{
if (m_SocketArgs != null)
{
m_SocketArgs.Close(message);
m_SocketArgs = null;
}
}
void KIVHandleClose(SocketArgs args)
{
args.Close(string.Empty);
if (args != m_SocketArgs)
{
return;
}
Close(string.Empty);
}
void KIVHandleConnected(SocketArgs args, byte[] kiv)
{
if (args != m_SocketArgs)
{
return;
}
args.IsConnected = true;
args.m_Connection = new Connection(args.m_Socket, m_Handler, ConnectionClose, kiv);
args.m_Connection.Initialize();
}
/// <summary>
/// Looks at the current segment and adjusts the SocketArgs buffer to it.
/// </summary>
private void ResetBuffer()
{
// This method is only called when we are sure we have a packet
// waiting to be sent. Otherwise, segment may be null after the
// TryPeek call below.
byte[] segment;
_queue.TryPeek(out segment);
// Since we're sure segment is not null, we can dereference it.
SocketArgs.SetBuffer(segment, _sentBytes, segment.Length - _sentBytes);
}
void OnConnected(SocketArgs args)
{
if (m_SocketArgs != args)
{
return;
}
var kiv = AesKeyIV.GenKeyIV();
AesKeyIV.SendAesKeyIVRsa(args.m_Socket, args.m_RsaPub, kiv);
new AesKeyIVAes(args, KIVHandleConnected, KIVHandleClose, kiv);
}
private void ReadAsync(EventHandler <SocketAsyncEventArgs> callback, object state = null)
{
if (Disposing)
{
return;
}
SocketAsyncState = state;
SocketArgs.SetBuffer(ReceiveData, Index, Remaining);
SocketCallback = callback;
ReceiveAsync();
}
private void Client_OnReceive(object sender, SocketArgs e)
{
//Debug.Log("Client_OnReceive" + e != null ? ": " + e.message : "");
Debug.Log("Client_OnReceive: ");
COMData data = client.infoReceived.Dequeue();
if (data.type == COMData.TYPE.TEXT)
{
COMData_text text = (COMData_text)data;
ProcessMessage(text);
//Log.Debug("Message Received: " + text.GetText());
}
}
private void AcceptCallback(IAsyncResult ar)
{
Socket accepted;
try
{
accepted = Connection.EndAccept(ar);
Connections.Add(accepted);
Connection.BeginAccept(AcceptCallback, null);
SocketArgs args = new SocketArgs(accepted);
Accept?.Invoke(this, args);
accepted.BeginReceive(rcvBuffer, 0, GeneralBufferSize, SocketFlags.None, (ReceiveCallback), accepted);
}
catch
{
return;
}
}
public static SocketArgs GetSendArg()
{
lock (SocketSendArgs)
{
var freeArg = SocketSendArgs.Find(x => x.IsInUse == false);
if (freeArg == null)
{
var newArg = new SocketArgs();
newArg.IsInUse = true;
SocketSendArgs.Add(newArg);
return(newArg);
}
else
{
Array.Clear(freeArg.Buffer, 0, freeArg.Buffer.Length);
freeArg.IsInUse = true;
return(freeArg);
}
}
}
public static SocketArgs GetReceiveArg()
{
lock (SocketReceiveArgs)
{
var freeArg = SocketReceiveArgs.Find(x => x.IsInUse == false);
if (freeArg == null)
{
var newArg = new SocketArgs();
newArg.SetBuffer(new byte[Config.Current.BufferSize], 0, Config.Current.BufferSize);
newArg.IsInUse = true;
SocketReceiveArgs.Add(newArg);
return(newArg);
}
else
{
freeArg.IsInUse = true;
return(freeArg);
}
}
}
private void ResetPositions()
{
SocketArgs.SetBuffer(_receiveBuffer, 0, BufferSize);
}
private void Client_OnConnectionLost(object sender, SocketArgs e)
{
//Debug.Log("Client_OnConnectionLost" + e != null ? ": " + e.message : "");
}
private void Client_OnSendSucess(object sender, SocketArgs e)
{
//Debug.Log("Client_OnSendSucess" + e != null ? ": " + e.message : "");
}
private void Client_OnReceiveFailed(object sender, SocketArgs e)
{
//Debug.Log("Client_OnReceiveFailed" + e != null ? ": " + e.message : "");
}
private static void TcpServer_OnClientAdd(object sender, SocketArgs e)
{
Console.WriteLine($"添加了{e.ClientInfo.id} + {e.ClientInfo.ip}");
}
private void ClearBuffer()
{
_receiveBuffer = null;
SocketArgs.SetBuffer(null, 0, 0);
}
