private static void RecvCallbackFromDevice(IAsyncResult ar)
{
RecvState state = (RecvState)ar.AsyncState;
try
{
// Retrieve the state object and the client socket
// from the asynchronous state object.
// can get the disconnected socket status
if (state.m_Socket.Connected == false)
{
return;
}
// Read data from the remote device.
int bytesRead = state.m_Socket.EndReceive(ar);
ParseBuffer(state, bytesRead);
}
catch (ObjectDisposedException)
{
// DisposedException is received if the current host initiated
// a disconnection. In this case - do nothing.
}
catch (Exception e)
{
state.m_OnExcp(e);
}
}
bool tryHandleNextPacket()
{
if (recvState == RecvState.RecvPayloadLen)
{
if (tcpClient.Available < 4)
{
return(false);
}
tcpClient.Client.Receive(recvPayloadLenBuff);
recvPayloadLen = BitConverter.ToUInt32(recvPayloadLenBuff, 0);
recvState = RecvState.RecvPayload;
//Debug.Log ("Packet payload length: " + recvPayloadLen);
}
// recvState == RecvState.RecvPayload
if (tcpClient.Available < recvPayloadLen)
{
return(false);
}
tcpClient.Client.Receive(payloadBuff, (int)recvPayloadLen, SocketFlags.None);
recvState = RecvState.RecvPayloadLen;
int payloadLen = (int)recvPayloadLen;
recvPayloadLen = 0;
handlePacket(payloadBuff, payloadLen);
return(true);
}
private void RecvCallBack(IAsyncResult result)
{
RecvState state = result.AsyncState as RecvState;
if (m_socket != state.WorkSocket)
{
return;
}
try
{
if (state.WorkSocket.EndReceive(result) != state.RecvLength)
{
throw new Exception("recv failure.");
}
lock (m_recevQueue)
{
m_recevQueue.Enqueue(state.Bytes);
}
RecvState recvState = new RecvState(state.WorkSocket, Define.BODY_HEAD_LENGTH);
state.WorkSocket.BeginReceive(recvState.Bytes, 0, recvState.RecvLength, SocketFlags.None, ReadHeadCallBack, recvState);
}
catch (Exception e)
{
UnityEngine.Debug.Log("recv failure：" + e.Message);
State = EConnectionState.RECV_ERROR;
Disconnect();
}
}
private void ConnectCallBack(IAsyncResult result)
{
ConnectState state = result.AsyncState as ConnectState;
if (m_socket != state.WorkSocket)
{
return;
}
try
{
state.WorkSocket.EndConnect(result);
if (!state.WorkSocket.Connected)
{
throw new Exception("connect failure.");
}
State = EConnectionState.CONNECTED;
if (null != m_connectedCallBack)
{
m_connectedCallBack.Invoke();
m_connectedCallBack = null;
}
RecvState recvState = new RecvState(state.WorkSocket, Define.BODY_HEAD_LENGTH);
state.WorkSocket.BeginReceive(recvState.Bytes, 0, recvState.RecvLength, SocketFlags.None, ReadHeadCallBack, recvState);
}
catch (Exception e)
{
UnityEngine.Debug.Log("connect failure :" + e.Message);
State = EConnectionState.CONNECTING_ERROR;
Disconnect();
}
}
void BeginRecv( byte[] buffer, int offset )
{
lock (Lock) try {
var state = new RecvState() { Buffer = buffer, Offset = offset };
Client.Client.BeginReceive( buffer, offset, buffer.Length-offset, SocketFlags.Partial, out state.Error, OnRecv, state );
} catch ( Exception e ) {
Handle(e);
}
}
void Awake()
{
Debug.Log("GameClient is awake ...");
manager = GetComponent <GoWorldManager> ();
recvState = RecvState.RecvPayloadLen;
recvPayloadLenBuff = new byte[SIZE_FIELD_SIZE];
payloadBuff = new byte[MAX_PAYLOAD_LEN];
tcpClient = new TcpClient();
// BitConverter.IsLittleEndian = true;
}
public ClientConnection(Socket socket, Action <ClientConnection> onclose)
{
m_socket = socket;
m_onSocketClose = onclose;
m_recevQueue = new Queue <byte[]>();
State = EConnectionState.CONNECTED;
RecvState recvState = new RecvState(m_socket, Define.BODY_HEAD_LENGTH);
m_socket.BeginReceive(recvState.Bytes, 0, recvState.RecvLength, SocketFlags.None, ReadHeadCallBack, recvState);
}
private void ReadHeadCallBack(IAsyncResult result)
{
RecvState state = result.AsyncState as RecvState;
if (m_socket != state.WorkSocket)
{
return;
}
try
{
if (state.WorkSocket.EndReceive(result) != state.RecvLength)
{
throw new Exception("recv failure.");
}
int offset = 0;
int bodyLength = 0;
byte[] bodyBytes = null;
if (state.Bytes[0] <= 127)
{
bodyLength = state.Bytes[0];
bodyBytes = new byte[bodyLength];
bodyBytes[0] = state.Bytes[1];
bodyBytes[1] = state.Bytes[2];
offset = 2;
}
else if (state.Bytes[1] <= 127)
{
bodyLength = ((int)(state.Bytes[1]) << 7) | ((int)(state.Bytes[0]) & 0x7f);
bodyBytes = new byte[bodyLength];
bodyBytes[0] = state.Bytes[2];
offset = 1;
}
else
{
bodyLength = ((int)(state.Bytes[2]) << 14) | (((int)(state.Bytes[1]) & 0x7f) << 7) | ((int)(state.Bytes[0]) & 0x7f);
bodyBytes = new byte[bodyLength];
offset = 0;
}
if (bodyLength > Define.BODY_MAX_LENGTH)
{
throw new Exception("recv too large.");
}
RecvState recvState = new RecvState(state.WorkSocket, bodyLength - offset, bodyBytes);
state.WorkSocket.BeginReceive(recvState.Bytes, offset, bodyLength - offset, SocketFlags.None, RecvCallBack, recvState);
}
catch (Exception e)
{
UnityEngine.Debug.Log("recv failure：" + e.Message);
State = EConnectionState.RECV_ERROR;
Disconnect();
}
}
//
// NOTE NOTE NOTE:
//
// BeginReceive() receives a callback which will be called upon completion of the action.
// The callback might be called from a different thread - OR -
// it can be called in this thread from within the BeginReceive() function.
// Keep that in mind: You should not change or rely on any state after you call this function,
// otherwise you might get some serious bugs in your system.
//
private static void StartRecvPacket(RecvState state)
{
// Begin receiving the data from the remote device, read buf len
if (state.m_Socket.Connected)
{
state.m_Socket.BeginReceive(
state.m_buf,
0, //offset
state.m_buf.Length, //len of len (start with 1 byte, if needed we'll read more later)
0, //flags
new AsyncCallback(RecvCallbackFromDevice),
state);
}
}
private static void Receive(Socket IPSocket)
{
try
{
RecvState State = new RecvState();
State.IPSocket = IPSocket;
IPSocket.BeginReceive(State.RecvBuffer, 0, RecvState.BufferSize, SocketFlags.None, new AsyncCallback(RecvCallback), State);
}
catch (Exception ex)
{
LastSocketOperation = "Receive";
LastSocketError = ex;
}
}
// Equivalent to ServerAcceptCallback
private static void ClientConnectCallback(IAsyncResult ar)
{
Socket client = (Socket)ar.AsyncState;
client.EndConnect(ar);
SendState ss = new SendState();
ss.workSocket = client;
sendState = ss;
RecvState rs = new RecvState();
rs.workSocket = client;
recvState = rs;
NetworkClock.StartCommunication();
}
// When a connection is accepted, initialize state objects then start queuing data for sending (and get ready to receive)
private static void ServerAcceptCallback(IAsyncResult ar)
{
connectionFound = true;
Socket listener = (Socket)ar.AsyncState;
Socket handler = listener.EndAccept(ar);
SendState ss = new SendState();
ss.workSocket = handler;
sendState = ss;
RecvState rs = new RecvState();
rs.workSocket = handler;
recvState = rs;
NetworkClock.StartCommunication();
}
// Check if message is valid. If so, distribute messages to their appropriate network identities. Else, get the rest if the message.
private static void ReceiveCallback(IAsyncResult ar)
{
RecvState state = (RecvState)ar.AsyncState;
int bytesRead = state.workSocket.EndReceive(ar);
ushort messageLength = BitConverter.ToUInt16(state.recvBuffer, 0);
bool hasTerminator = state.recvBuffer[messageLength] == 255 && state.recvBuffer[messageLength + 1] == 255 && state.recvBuffer[messageLength + 2] == 255;
if (bytesRead > 2 && hasTerminator)
{
NetworkSerializer.DistributeMessages(state.recvBuffer);
state.recvBuffer = new byte[RECV_BUFFER_SIZE];
}
else
{
state.workSocket.BeginReceive(state.recvBuffer, 0, RECV_BUFFER_SIZE, 0, new AsyncCallback(ReceiveCallback), state);
}
}
internal Packet RecvPacket()
{
if (this.tcpClient.Available == 0)
{
return(null);
}
int nr;
if (this.recvState == RecvState.receivingPayloadLen)
{
if (tcpClient.Available < Proto.SIZE_FIELD_SIZE)
{
return(null);
}
nr = tcpClient.Client.Receive(this.recvPayloadLenBuff);
Debug.Assert(nr == Proto.SIZE_FIELD_SIZE);
this.recvPayloadLen = BitConverter.ToUInt32(recvPayloadLenBuff, 0);
if (this.recvPayloadLen < 2 || this.recvPayloadLen > Proto.MAX_PAYLOAD_LEN)
{
GoWorldLogger.Error("PacketReceiver", "Invalid Packet Payload Length: " + this.recvPayloadLen);
this.tcpClient.Close();
return(null);
}
this.recvState = RecvState.receivingPayload;
this.recvPayloadBuff = new byte[this.recvPayloadLen];
}
if (tcpClient.Available < this.recvPayloadLen)
{
return(null);
}
nr = tcpClient.Client.Receive(this.recvPayloadBuff);
Debug.Assert(nr == this.recvPayloadLen);
this.recvState = RecvState.receivingPayloadLen;
byte[] payload = this.recvPayloadBuff;
this.recvPayloadBuff = null;
return(new Packet(payload));
}
public static void Recv(Socket socket, OnRecvDlgt onRecv, OnExcpDlgt onExcp, OnRecvProgressDlgt onRecvProgress, int reciveBufferSize, bool recvLoop)
{
try
{
// Create the state object.
RecvState state = new RecvState();
state.m_Socket = socket;
state.m_OnRecv = onRecv;
state.m_OnRecvProgress = onRecvProgress;
state.m_OnExcp = onExcp;
state.m_recvLoop = recvLoop;
state.m_buf = (recvLoop ? new byte[reciveBufferSize] : new byte[1]);
StartRecvPacket(state);
}
catch (Exception e)
{
if (!(e is System.ObjectDisposedException))
{
}
}
}
private static void RecvCallback(IAsyncResult asyncResult)
{
try
{
RecvState State = (RecvState)asyncResult.AsyncState;
Socket IPSocket = State.IPSocket;
int bytesRead = IPSocket.EndReceive(asyncResult);
for (int i = 0; ((i < bytesRead) && (i < RecvState.BufferSize)); i++)
{
InBuffer.Enqueue(State.RecvBuffer[i]);
}
}
catch (Exception ex)
{
LastSocketOperation = "Recevie data";
LastSocketError = ex;
return;
}
finally
{
receiveDone.Set();
}
}
public void Reset()
{
recv.Clear();
state = RecvState.Searching;
}
public void setRemote(ChabuSetupInfo info)
{
infoRemote = info;
this.recvSetupCompleted = RecvState.RECVED;
}
public void setRemoteAcceptReceived()
{
Utils.ensure(!isRemoteAcceptReceived(), ChabuErrorCode.PROTOCOL_ACCEPT_TWICE, "Recveived ACCEPT twice");
recvAccepted = RecvState.RECVED;
}
public byte[] Process(byte[] buf, int length)
{
for (int i = 0; i < length; ++i)
{
switch (state)
{
case RecvState.Searching:
if (buf[i] == PacketConstants.Start)
{
state = RecvState.GettingPacket;
recv.Clear();
}
else
{
Console.WriteLine("Unexpected byte while seaching");
}
break;
case RecvState.GettingPacket:
if (buf[i] == PacketConstants.Stop)
{
state = RecvState.GettingChecksum1;
}
else
{
recv.Add(buf[i]);
}
break;
case RecvState.GettingChecksum1:
checksum[0] = buf[i];
state = RecvState.GettingChecksum2;
break;
case RecvState.GettingChecksum2:
checksum[1] = buf[i];
packet = recv.ToArray();
Console.WriteLine("Done getting checksum, packet {0} checksum {1}", Encoding.ASCII.GetString(packet),
Encoding.ASCII.GetString(checksum));
if (PacketUtils.VerifyChecksum(packet, checksum))
{
byte[] SendPacket = processor.ProcessPacket(packet);
sendData = new byte[SendPacket.Length + 5];
sendData[0] = PacketConstants.RecvOK;
sendData[1] = PacketConstants.Start;
SendPacket.CopyTo(sendData, 2);
sendData[sendData.Length - 3] = PacketConstants.Stop;
byte[] PacketChecksum = PacketUtils.GenerateChecksum(SendPacket);
PacketChecksum.CopyTo(sendData, sendData.Length - 2);
state = RecvState.SendingPacket;
Console.WriteLine("Sending {0}", Encoding.ASCII.GetString(sendData));
return sendData;
}
else
{
Console.WriteLine("Invalid checksum, requesting resend");
byte[] resendPacket = new byte[1];
resendPacket[0] = PacketConstants.Resend;
state = RecvState.Searching;
return resendPacket;
}
break;
case RecvState.SendingPacket:
if (buf[i] == PacketConstants.Resend)
{
return sendData;
}
else if (buf[i] == PacketConstants.RecvOK)
{
state = RecvState.Searching;
}
else
{
Console.WriteLine("Unexpected byte while sending");
}
break;
}
}
return null;
}
public byte[] Process(byte[] buf, int length)
{
for (int i = 0; i < length; ++i)
{
switch (state)
{
case RecvState.Searching:
if (buf[i] == PacketConstants.Start)
{
state = RecvState.GettingPacket;
recv.Clear();
}
else
{
Console.WriteLine("Unexpected byte while seaching");
}
break;
case RecvState.GettingPacket:
if (buf[i] == PacketConstants.Stop)
{
state = RecvState.GettingChecksum1;
}
else
{
recv.Add(buf[i]);
}
break;
case RecvState.GettingChecksum1:
checksum[0] = buf[i];
state = RecvState.GettingChecksum2;
break;
case RecvState.GettingChecksum2:
checksum[1] = buf[i];
packet = recv.ToArray();
Console.WriteLine("Done getting checksum, packet {0} checksum {1}", Encoding.ASCII.GetString(packet),
Encoding.ASCII.GetString(checksum));
if (PacketUtils.VerifyChecksum(packet, checksum))
{
byte[] SendPacket = processor.ProcessPacket(packet);
sendData = new byte[SendPacket.Length + 5];
sendData[0] = PacketConstants.RecvOK;
sendData[1] = PacketConstants.Start;
SendPacket.CopyTo(sendData, 2);
sendData[sendData.Length - 3] = PacketConstants.Stop;
byte[] PacketChecksum = PacketUtils.GenerateChecksum(SendPacket);
PacketChecksum.CopyTo(sendData, sendData.Length - 2);
state = RecvState.SendingPacket;
Console.WriteLine("Sending {0}", Encoding.ASCII.GetString(sendData));
return(sendData);
}
else
{
Console.WriteLine("Invalid checksum, requesting resend");
byte[] resendPacket = new byte[1];
resendPacket[0] = PacketConstants.Resend;
state = RecvState.Searching;
return(resendPacket);
}
break;
case RecvState.SendingPacket:
if (buf[i] == PacketConstants.Resend)
{
return(sendData);
}
else if (buf[i] == PacketConstants.RecvOK)
{
state = RecvState.Searching;
}
else
{
Console.WriteLine("Unexpected byte while sending");
}
break;
}
}
return(null);
}
public void Reset()
{
recv.Clear();
state = RecvState.Searching;
}
private static void ParseBuffer(RecvState state, int dataLength)
{
if (dataLength == 0)
{
return;
}
byte[] workingBuf;
if (state.m_PrevLeftoverBuf != null)
{
workingBuf = new byte[dataLength + state.m_PrevLeftoverBuf.Length];
Buffer.BlockCopy(state.m_PrevLeftoverBuf, 0, workingBuf, 0, state.m_PrevLeftoverBuf.Length);
Buffer.BlockCopy(state.m_buf, 0, workingBuf, state.m_PrevLeftoverBuf.Length, dataLength);
state.m_PrevLeftoverBuf = null;
dataLength = workingBuf.Length;
}
else
{
workingBuf = state.m_buf;
}
int expectedTotalPacketLen = 0;
int packetLenBytes = 0;
for (int i = 0; i < dataLength;)
{
/********************************************************************/
// Read packet length
/********************************************************************/
packetLenBytes = 1;
state.m_bytesLenBuf = 1;
expectedTotalPacketLen = workingBuf[i] & 0x7F;
while ((workingBuf[i] & 0x80) == 0x80)
{
i++;
if (i < dataLength)
{
expectedTotalPacketLen <<= 7;
expectedTotalPacketLen += workingBuf[i] & 0x7F;
packetLenBytes++;
state.m_bytesLenBuf = packetLenBytes;
}
else
{
state.m_PrevLeftoverBuf = new byte[packetLenBytes];
Buffer.BlockCopy(workingBuf, i - packetLenBytes, state.m_PrevLeftoverBuf, 0, packetLenBytes);
StartRecvPacket(state);
return;
}
}
/********************************************************************/
// End Read packet length
/********************************************************************/
i++;
int packetBytesRecived = Math.Min(expectedTotalPacketLen, dataLength - i);
if (packetBytesRecived < expectedTotalPacketLen)
{
state.m_PrevLeftoverBuf = new byte[packetBytesRecived + packetLenBytes];
Array.Copy(workingBuf, i - packetLenBytes, state.m_PrevLeftoverBuf, 0, packetBytesRecived + packetLenBytes);
if (!state.m_recvLoop)
{
state.m_buf = new byte[expectedTotalPacketLen - packetBytesRecived];
}
state.m_OnRecvProgress?.Invoke(packetBytesRecived, expectedTotalPacketLen);
StartRecvPacket(state);
return;
}
byte[] data = new byte[packetBytesRecived];
Array.Copy(workingBuf, i, data, 0, packetBytesRecived);
state.m_OnRecv(data, data.Length + state.m_bytesLenBuf);
i += packetBytesRecived;
}
if (state.m_recvLoop)
{
StartRecvPacket(state);
}
}
private void onReceive()
{
//接受数据的函数
FuncReceive receive = delegate(byte[] buffer, int len) {
if (DATA_MAX_LENGTH < len)
{
len = DATA_MAX_LENGTH;
}
int ret = TCPSocket.Receive(buffer, len);
return(ret);
};
//状态切换函数
System.Action switch_idle = delegate() {
status = RecvState.idle;
receiveLen = 0;
};
System.Action switch_head = delegate() {
status = RecvState.head;
receiveLen = LENGTH_HEAD;
};
System.Action switch_die = delegate() {
status = RecvState.die;
receiveLen = 0;
};
System.Action <int> switch_body = delegate(int len) {
status = RecvState.body;
receiveLen = len;
};
//状态操作函数
System.Action idle_func = delegate() {
switch_head();
};
//接收包头
System.Action head_func = delegate() {
byte[] buffer = new byte[receiveLen];;
int ret = receive(buffer, receiveLen);
if (-1 == ret)
{
switch_die();
return;
}
if (ret <= 0)
{
return;
}
int bodyLen = Function.Byte4ToInt(buffer);
if (DATA_MAX_LENGTH < bodyLen)
{
Debug.LogError("Client.onReceive body data is too long!");
}
switch_body(bodyLen);
};
//接受数据
System.Action body_func = delegate() {
byte[] buffer = new byte[receiveLen];
int ret = receive(buffer, receiveLen);
if (-1 == ret)
{
switch_die();
return;
}
if (ret <= 0)
{
return;
}
if (null != lastBuffer && 0 < lastBuffer.Length)
{
//需要拼接数据
lastBuffer = Function.MergeArray <byte>(lastBuffer, buffer);
}
else
{
lastBuffer = buffer;
}
if (ret < receiveLen)
{
//数据没有接收完
switch_body(receiveLen - ret);
}
else
{
//数据接收完成
try
{
receiveData(lastBuffer);
}
finally
{
lastBuffer = null;
switch_idle();
}
}
};
System.Action die_func = delegate() {
//pass
};
//start
switch (status)
{
case RecvState.idle:
idle_func(); break;
case RecvState.head:
head_func(); break;
case RecvState.body:
body_func(); break;
case RecvState.die:
head_func(); break;
default:
idle_func(); break;
}
}
