private void Receive(int node, byte[] data)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(data);
bool ret = serializer.Deserialize(ref header);
if (ret == false)
{
Debug.Log("Invalid header data.");
// 패킷으로서 인식할 수 없으므로 폐기한다.
return;
}
int packetId = (int)header.packetId;
if (m_notifier.ContainsKey(packetId) &&
m_notifier[packetId] != null)
{
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
byte[] packetData = new byte[data.Length - headerSize];
Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length);
m_notifier[packetId](node, header.packetId, packetData);
}
}
private bool getPacketContent(byte[] data, out int id, out byte[] outContent)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(data);
serializer.Deserialize(ref header);
int headerSize = 3; // 헤더사이즈 short + byte = 3
int packetContentSize = data.Length - headerSize;
byte[] packetContent = null;
if (packetContentSize > 0) //헤더만 있는 패킷을 대비해서 예외처리, 데이터가 있는 패킷만 데이터를 만든다
{
packetContent = new byte[packetContentSize];
Buffer.BlockCopy(data, headerSize, packetContent, 0, packetContent.Length);
}
else
{
id = header.id;
outContent = null;
return(false);
}
//Debug.Log("받은 패킷 - id : " + header.id + " dataLength : " + packetData.Length);
id = header.id;
outContent = packetContent;
return(true);
}
private void Receive(int node, byte[] data)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(data);
bool ret = serializer.Deserialize(ref header);
if (ret == false)
{
Debug.Log("Invalid header data.");
// 패킷으로서 인식할 수 없으므로 폐기합니다.
return;
}
string str = "";
for (int i = 0; i < 16; ++i)
{
str += data[i] + ":";
}
Debug.Log(str);
int packetId = (int)header.packetId;
if (packetId < m_notifier.Count && m_notifier[packetId] != null)
{
int headerSize = Marshal.SizeOf(typeof(PacketHeader));
byte[] packetData = new byte[data.Length - headerSize];
Buffer.BlockCopy(data, headerSize, packetData, 0, packetData.Length);
m_notifier[packetId](node, packetData);
}
}
// private method
// packet seperater -> header / packet data
private bool SeperatePacket(byte[] originalData, out int packetID, out byte[] seperatedData)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(originalData);
serializer.Deserialize(ref header);
int headerSize = Marshal.SizeOf(header.id) + Marshal.SizeOf(header.length);
int packetDataSize = originalData.Length - headerSize;
byte[] packetData = null;
if (packetDataSize > 0)
{
packetData = new byte[packetDataSize];
Buffer.BlockCopy(originalData, headerSize, packetData, 0, packetData.Length);
}
else
{
packetID = header.id;
seperatedData = null;
return(false);
}
packetID = header.id;
seperatedData = packetData;
return(true);
}
public IEnumerator DataHandle()
{
while (true)
{
yield return(new WaitForSeconds(0.016f));
int readCount = receiveMsgs.Count;
for (int i = 0; i < readCount; i++)
{
//패킷을 Dequeue 한다
//패킷 : 메시지 타입 + 메시지 내용
DataPacket packet;
//lock (receiveLock)
//{
packet = receiveMsgs.Dequeue();
//}
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(packet.msg);
if (packet.endPoint == null)
{
headerSerializer.Deserialize(ref headerData);
DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId, ref packet.msg);
if (server_notifier.TryGetValue(headerData.id, out serverRecvNotifier))
{
serverRecvNotifier(packet);
}
else
{
Debug.Log("DataHandler::Server.TryGetValue 에러 " + headerData.id);
}
}
else
{
headerSerializer.UdpDeserialize(ref headerData);
DataReceiver.ResizeByteArray(0, NetworkManager.packetSource + NetworkManager.packetId + NetworkManager.udpId, ref packet.msg);
if (p2p_notifier.TryGetValue(headerData.id, out p2pRecvNotifier))
{
p2pRecvNotifier(packet, headerData.udpId);
}
else
{
Debug.Log("DataHandler::P2P.TryGetValue 에러 " + headerData.id);
}
}
}
}
}
// private method
// packet seperate id / data
private bool SeperatePacket(byte[] originalData, out int packetID, out byte[] seperatedData)
{
PacketHeader header = new PacketHeader();
HeaderSerializer serializer = new HeaderSerializer();
serializer.SetDeserializedData(originalData);
serializer.Deserialize(ref header);
seperatedData = null;
packetID = 0;
return(true);
}
//Tcp 데이터 수신
void TcpReceiveDataCallback(IAsyncResult asyncResult)
{
AsyncData asyncData = (AsyncData)asyncResult.AsyncState;
Socket tcpSock = asyncData.sock;
try
{
asyncData.msgSize = (short)tcpSock.EndReceive(asyncResult);
}
catch
{
Debug.Log("NetworkManager::HandleAsyncDataReceive.EndReceive 에러");
tcpSock.Close();
return;
}
if (asyncData.msgSize >= NetworkManager.packetId)
{
Array.Resize(ref asyncData.msg, asyncData.msgSize + NetworkManager.packetSource + NetworkManager.packetId);
Debug.Log(asyncData.msg.Length);
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(asyncData.msg);
headerSerializer.Deserialize(ref headerData);
DataPacket packet = new DataPacket(headerData, asyncData.msg);
lock (receiveLock)
{
try
{ //큐에 삽입
Debug.Log("Enqueue Message Length : " + packet.msg.Length);
msgs.Enqueue(packet);
}
catch
{
Console.WriteLine("NetworkManager::HandleAsyncDataReceive.Enqueue 에러");
}
}
}
//재 수신
asyncData = new AsyncData(tcpSock);
tcpSock.BeginReceive(asyncData.msg, 0, NetworkManager.packetLength, SocketFlags.None, new AsyncCallback(TcpReceiveLengthCallback), asyncData);
}
public void DataHandle()
{
while (true)
{
if (receiveMsgs.Count > 0)
{
DataPacket packet = new DataPacket();
//패킷을 Dequeue 한다 패킷 : 메시지 타입 + 메시지 내용, 소켓
lock (receiveLock)
{
try
{
packet = receiveMsgs.Dequeue();
}
catch
{
Console.WriteLine("DataHandler::DataHandle.Dequeue 에러");
}
}
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(packet.msg);
headerSerializer.Deserialize(ref headerData);
ResizeByteArray(0, UnityServer.packetSource + UnityServer.packetId, ref packet.msg);
//Dictionary에 등록된 델리게이트 메소드에서 PacketId를 반환받는다.
if (m_notifier.TryGetValue(headerData.id, out recvNotifier))
{
recvNotifier(packet);
}
else
{
Console.WriteLine("DataHandler::DataHandle.TryGetValue 에러 ");
Console.WriteLine("패킷 출처 : " + headerData.source);
Console.WriteLine("패킷 ID : " + headerData.id);
}
}
}
}
//Udp 데이터 수신
public void UdpReceiveDataCallback(IAsyncResult asyncResult)
{
AsyncData asyncData = (AsyncData)asyncResult.AsyncState;
udpSock = asyncData.sock;
try
{
Debug.Log("메시지 받음");
asyncData.msgSize = (short)udpSock.EndReceive(asyncResult);
Debug.Log(asyncData.EP);
}
catch (Exception e)
{
Debug.Log("연결 끊김 :" + e.Message);
udpSock.Close();
}
if (asyncData.msgSize > 0)
{
byte[] msgSize = ResizeByteArray(0, NetworkManager.packetLength, ref asyncData.msg);
Array.Resize(ref asyncData.msg, BitConverter.ToInt16(msgSize, 0) + NetworkManager.packetSource + NetworkManager.packetId);
HeaderData headerData = new HeaderData();
HeaderSerializer headerSerializer = new HeaderSerializer();
headerSerializer.SetDeserializedData(asyncData.msg);
headerSerializer.Deserialize(ref headerData);
DataPacket packet = new DataPacket(headerData, asyncData.msg, asyncData.EP);
lock (receiveLock)
{ //큐에 삽입
Debug.Log("Enqueue Message Length : " + asyncData.msg.Length);
msgs.Enqueue(packet);
}
//다시 수신 준비
asyncData = new AsyncData(udpSock, asyncData.EP);
udpSock.BeginReceiveFrom(asyncData.msg, 0, AsyncData.msgMaxSize, SocketFlags.None, ref asyncData.EP, new AsyncCallback(UdpReceiveDataCallback), asyncData);
}
}
