protected void WorkThreadOperateLoop()
{
var deltaTime = UDPBoxUtility.GetDeltaTime(mLastWorkThreadTime);
if (mRefreshDelayTimer <= 0)
{
for (int i = mLargePackageInfoList.Count - 1; i >= 0; i--)
{
var largePackageInfo = mLargePackageInfoList[i];
largePackageInfo.RecycleTimer -= deltaTime;
if (largePackageInfo.RecycleTimer <= 0f)
{
mLargePackageInfoList.RemoveAt(i);
}
}
mRefreshDelayTimer = REFRESH_DELAY;
}
else
{
mRefreshDelayTimer -= deltaTime;
}
mLastWorkThreadTime = DateTime.Now.Ticks;
}
public void ProcessPackage(byte[] bytes, IPEndPoint ipEndPoint)
{
Logger.Log("Process Package Begin: " + bytes.Length + " ipEndPoint: " + ipEndPoint, EUDPBoxLogType.Log);
if (StatisticsTotalPackageCount == uint.MaxValue)
{
StatisticsBadPackageCount = 0;
StatisticsTotalPackageCount = 0;
}
StatisticsTotalPackageCount++;
if (UDPBoxUtility.PackageIsBroken(bytes, mPackageHeadBytes))
{
StatisticsBadPackageCount++;
Logger.Log("Package Is Broken!", EUDPBoxLogType.Warning);
return;
}
var flag = false;
for (int i = 0, iMax = mMessageInterceptList.Count; i < iMax; i++)
{
var item = mMessageInterceptList[i];
flag = item(new MessageInterceptInfo()
{
Bytes = bytes, IPEndPoint = ipEndPoint
});
if (flag)
{
Logger.Log("Message Intercepted: " + item + " bytes: " + bytes.Length + " ipEndPoint: " + ipEndPoint, EUDPBoxLogType.Log);
}
}
if (flag)
{
return;
}
var targetHandler = default(HandlerBase);
for (int i = 0, iMax = mHandlerList.Count; i < iMax; i++)
{
var item = mHandlerList[i];
if (UDPBoxUtility.ComparePackageID(bytes, mPackageHeadBytes, item.ProcessableID))
{
targetHandler = item;
break;
}
}
Logger.Log("Process Package: " + targetHandler, EUDPBoxLogType.Log);
if (targetHandler != null)
{
targetHandler.Process(this, bytes, ipEndPoint);
}
}
public void Initialization(UDPBox_UDPClient[] udpClientsArray, string packageHead)
{
mUdpClientsList = new List <UDPBox_UDPClient>(udpClientsArray);
mPackageHeadBytes = UDPBoxUtility.ToBuffer(packageHead);
RegistHandler(new PingPongHandler(mPackageHeadBytes));
RegistHandler(new LargePackageHandler(mPackageHeadBytes));
}
public static UDPBoxBroadcast GenerateStandardUDPBoxBroadcastAndSetup(
UDPBox_UDPClient udpClient
, int broadcastSendPort
, string netPrefixIP
, UDPBoxContainer container)
{
var broadcast = new UDPBoxBroadcast(udpClient, broadcastSendPort);
var broadcastPackage = new BroadcastPackage(container.PackageHeadBytes);
if (container.IsMaster)
{
broadcast.ListenBroadcast((bytes, endPoint) =>
{
if (UDPBoxUtility.PackageIsBroken(bytes, container.PackageHeadBytes))
{
return;
}
if (!UDPBoxUtility.ComparePackageID(bytes, container.PackageHeadBytes, broadcastPackage.ID))
{
return;
}
if (!broadcastPackage.Deserialize(bytes))
{
return;
}
var ipEndPoint = new IPEndPoint(IPAddress.Parse(broadcastPackage.IpAddress), broadcastPackage.BeginPort);
if (ipEndPoint.Address.Equals(container.SelfIPAddress) &&
ipEndPoint.Port < container.UdpBoxEndPort && ipEndPoint.Port >= container.UdpBoxBeginPort)
{
return;
}
//Avoid self connect to the self.
var establishConnectPackage = new EstablishConnectPackage(container.PackageHeadBytes);
establishConnectPackage.SenderType = EstablishConnectPackage.ESenderType.Server;
establishConnectPackage.IpAddress = container.SelfIPAddress.ToString();
establishConnectPackage.BeginPort = container.UdpBoxBeginPort;
establishConnectPackage.EndPort = container.UdpBoxEndPort;
establishConnectPackage.IsReceipt = false;
container.SendUDPMessage(establishConnectPackage.Serialize(), ipEndPoint);
//Server notify to client.
});
}
else
{
broadcastPackage.IpAddress = container.SelfIPAddress.ToString();
broadcastPackage.BeginPort = container.UdpBoxBeginPort;
broadcastPackage.EndPort = container.UdpBoxEndPort;
broadcast.StartBroadcast(broadcastPackage.Serialize(), netPrefixIP);
//Client through broadcast notify to server.
}
return(broadcast);
}
public void Initialization(string packageHead, bool useInternalBroadcastLogic)
{
mUseInternalBroadcastLogic = useInternalBroadcastLogic;
var udpClientArray = new UDPBox_UDPClient[UdpBoxEndPort - UdpBoxBeginPort];
for (int i = 0, port = UdpBoxBeginPort; port < UdpBoxEndPort; i++, port++)
{
udpClientArray[i] = UDPBoxFactory.GeterateUdpClient(port);
}
UDPBox.Initialization(udpClientArray, packageHead);
mEstablishConnectPackage = new EstablishConnectPackage(PackageHeadBytes);
mPingPongPackageTemplate = new PingPongPackage(PackageHeadBytes);
SelfIPAddress = SelfIPAddress ?? UDPBoxUtility.GetSelfIP(BroadcastNetPrefixIP);
}
public virtual bool Deserialize(byte[] bytes)
{
if (!UDPBoxUtility.CheckByteHead(bytes, HeadBytes))
{
return(false);
}
var memoryStream = new MemoryStream(bytes);
var binaryReader = new BinaryReader(memoryStream);
binaryReader.ReadBytes(HeadBytes.Length);
Type = binaryReader.ReadInt16();
MagicNumber = binaryReader.ReadUInt16();
ID = binaryReader.ReadInt16();
ContentLength = binaryReader.ReadUInt32();
var argLength = binaryReader.ReadInt32();
if (Args == null)
{
throw new System.NotSupportedException("需要预先把参数创建出来才可反序列化！应从模板类中进行处理！");
}
if (EnabledCompress)
{
var bytesLength_Compress = binaryReader.ReadInt32();
var compressed_bytes = binaryReader.ReadBytes(bytesLength_Compress);
var uncompress_bytes = CompressHelper.ZipBytesDecompress(compressed_bytes);
var memoryStream_uncompress = new MemoryStream(uncompress_bytes);
var binaryReader_uncompress = new BinaryReader(memoryStream_uncompress);
for (int i = 0, iMax = argLength; i < iMax; i++)
{
Args[i].Deserialize(binaryReader_uncompress);
}
}
else
{
for (int i = 0, iMax = argLength; i < iMax; i++)
{
Args[i].Deserialize(binaryReader);
}
}
return(true);
}
void OnGUI()
{
GUILayout.Space(200);
if (GUILayout.Button("Send large package to master"))
{
var largeTestPackage = new LargePackageTestPackage(udpBoxContainer_Mono.PackageHeadBytes);
largeTestPackage.byteList.AddRange(new byte[8 * 2]);
var bytes = UDPBoxUtility.ConvertToLargePackageBytes(largeTestPackage, 8);
for (int i = 0; i < bytes.Length; i++)
{
var bytes_singleChunk = bytes[i];
//var id = UDPBoxUtility.GetPackageID(bytes_singleChunk, udpBoxContainer_Mono.PackageHeadBytes);
//Debug.Log("id: " + id);
udpBoxContainer_Mono.SendUDPMessageToRandomPort(bytes_singleChunk, udpBoxContainer_Mono.MasterIPConnectInfo);
}
}
}
void OnSendMessage(byte[] bytes, IPEndPoint ipEndPoint)
{
short package_type = 0;
ushort package_magicNumber = 0;
short package_id = 0;
UDPBoxUtility.GetPackageBaseInfo(bytes, mUdpBox.PackageHeadBytes
, out package_type, out package_magicNumber, out package_id);
if (package_type == (short)EPackageType.Need_Ack_Session)
{
mUdpBox.Logger.Log("Send Need Ack Session Package", EUDPBoxLogType.Log);
var flag = false;
for (int i = 0, iMax = mWaitACKInfoList.Count; i < iMax; i++)
{
var item = mWaitACKInfoList[i];
if (item.PackageID == package_id && item.MagicNumber == package_magicNumber)
{
flag = true;
break;
}
}
if (!flag)
{
mUdpBox.Logger.Log("Add to wait ACK info list, bytes: " + bytes.Length + " package id: " + package_id, EUDPBoxLogType.Log);
mWaitACKInfoList.Add(new WaitACKInfo()
{
Bytes = bytes,
MagicNumber = package_magicNumber,
PackageID = package_id,
IPEndPoint_IPAddress = ipEndPoint.Address.ToString(),
IPEndPoint_Port = ipEndPoint.Port,
Timer = mACKDetectDelayTime,
});
}
}
}
void ACKWaitPackageLogicUpdate()
{
var deltaTime = UDPBoxUtility.GetDeltaTime(mLastTick);
for (int i = 0, iMax = mWaitACKInfoList.Count; i < iMax; i++)
{
var item = mWaitACKInfoList[i];
if (item.Timer <= 0f)
{
mUdpBox.SendMessage(item.Bytes, new IPEndPoint(IPAddress.Parse(item.IPEndPoint_IPAddress), item.IPEndPoint_Port));
item.Timer = mACKDetectDelayTime;
}
else
{
item.Timer -= deltaTime;
}
mWaitACKInfoList[i] = item;
}
mLastTick = DateTime.Now.Ticks;
}
void SendMessageThreadLoop()
{
try
{
var ipEndPoint = new IPEndPoint(IPAddress.Any, 0);
while (!mIsReleased)
{
lock (mSendQueue)
{
for (int i = 0; i < mSendQueue.Count; i++)
{
var item = mSendQueue.Dequeue();
ipEndPoint.Address = IPAddress.Parse(item.IPEndPointAddress_Str);
ipEndPoint.Port = item.IPEndPoint_Port;
short type = 0;
ushort magicNumber = 0;
short id = 0;
UDPBoxUtility.GetPackageBaseInfo(item.Content, PackageHeadBytes, out type, out magicNumber, out id);
Logger.Log("Final Send Msg: " + id + " magic num: " + magicNumber + " type: " + type, EUDPBoxLogType.Log);
GetRandomUDPClient().Send(item.Content, item.Content.Length, ipEndPoint);
}
}
Thread.Sleep(SendMsgThreadSleepTime);
}
}
catch (ThreadAbortException)
{
}
catch (Exception e)
{
OnException?.Invoke(e);
}
}
bool OnACKMessageIntercept(UDPBox.MessageInterceptInfo messageInterceptInfo)
{
var result = false;
short type = 0;
ushort magicNumber = 0;
short id = 0;
UDPBoxUtility.GetPackageBaseInfo(messageInterceptInfo.Bytes, mUdpBox.PackageHeadBytes, out type, out magicNumber, out id);
//--------------------------------------------------------------------
var flag = false;
foreach (var item in mPackageInterceptMarkList)
{
if (item.ID == id && item.MagicNumber == magicNumber)
{
mPackageInterceptMarkList.Remove(item);
flag = true;
break;
}
}
if (flag)
{
return(true);
}
//--------------------------------------------------------------------Package repeat.
if (type == (short)EPackageType.Need_Ack_Session)//Received generic ack package.
{
mUdpBox.Logger.Log("Recv need ack session package: " + id, EUDPBoxLogType.Log);
if (mPackageInterceptMarkList.Count > MAGIC_NUMBER_MARK_COUNT)
{
mPackageInterceptMarkList.RemoveAt(0);
}
mPackageInterceptMarkList.Add(new PackageCompareInfo()
{
ID = id, MagicNumber = magicNumber
});
mACKPackageTemplate.ACK_ID = id;
mACKPackageTemplate.ACK_MagicNumber = magicNumber;
mUdpBox.SendMessage(mACKPackageTemplate.Serialize(), messageInterceptInfo.IPEndPoint);
}
else if (id == UDPBoxUtility.ACK_ID)//Received ack package.
{
mUdpBox.Logger.Log("Recv ack package: " + id, EUDPBoxLogType.Log);
mACKPackageTemplate.Deserialize(messageInterceptInfo.Bytes);
var ack_id = mACKPackageTemplate.ACK_ID;
var ack_MagicNumber = mACKPackageTemplate.ACK_MagicNumber;
for (int i = mWaitACKInfoList.Count - 1; i >= 0; i--)
{
var item = mWaitACKInfoList[i];
if (item.MagicNumber == ack_MagicNumber && item.PackageID == ack_id)
{
mWaitACKInfoList.RemoveAt(i);
break;
}
}
result = true;
}
return(result);
}
bool InterceptAndUpdateConnectState(UDPBox.MessageInterceptInfo messageInterceptInfo)
{
if (UDPBoxUtility.PackageIsBroken(messageInterceptInfo.Bytes, PackageHeadBytes))
{
return(true);
}
var packageID = UDPBoxUtility.GetPackageID(messageInterceptInfo.Bytes, PackageHeadBytes);
if (packageID == UDPBoxUtility.ESTABLISH_CONNECT_ID)
{
if (!mEstablishConnectPackage.Deserialize(messageInterceptInfo.Bytes))
{
return(true);
}
var senderType = mEstablishConnectPackage.SenderType;
var establishIPAddress = mEstablishConnectPackage.IpAddress;
var packageBeginPort = mEstablishConnectPackage.BeginPort;
var packageEndPort = mEstablishConnectPackage.EndPort;
var isReceipt = mEstablishConnectPackage.IsReceipt;
if (senderType == EstablishConnectPackage.ESenderType.Server)
{
MasterIPConnectInfo = new ConnectInfo()
{
IPEndPoint = new IPEndPoint(IPAddress.Parse(establishIPAddress), packageBeginPort),
BeginPort = packageBeginPort,
EndPort = packageEndPort,
};
OnConnectedMaster?.Invoke();
if (!isReceipt)
{
mEstablishConnectPackage.SenderType = EstablishConnectPackage.ESenderType.Client;
mEstablishConnectPackage.IpAddress = SelfIPAddress.ToString();
mEstablishConnectPackage.BeginPort = UdpBoxBeginPort;
mEstablishConnectPackage.EndPort = UdpBoxEndPort;
mEstablishConnectPackage.IsReceipt = true;
SendUDPMessageToRandomPort(mEstablishConnectPackage.Serialize(), packageBeginPort, packageEndPort, IPAddress.Parse(establishIPAddress));
}
}
else if (senderType == EstablishConnectPackage.ESenderType.Client)
{
var connectInfo = new ConnectInfo()
{
IPEndPoint = new IPEndPoint(IPAddress.Parse(establishIPAddress), packageBeginPort),
BeginPort = packageBeginPort,
EndPort = packageEndPort,
};
if (ClientIPConnectList.Count < MAX_CLIENT &&
!ClientIPConnectList.Find(m => m.IsPortAndIPContain(connectInfo.IPEndPoint)).Valid)
{
ClientIPConnectList.Add(connectInfo);
OnConnectedClient?.Invoke();
}
if (!isReceipt)
{
mEstablishConnectPackage.SenderType = EstablishConnectPackage.ESenderType.Server;
mEstablishConnectPackage.IpAddress = SelfIPAddress.ToString();
mEstablishConnectPackage.BeginPort = UdpBoxBeginPort;
mEstablishConnectPackage.EndPort = UdpBoxEndPort;
mEstablishConnectPackage.IsReceipt = true;
SendUDPMessageToRandomPort(mEstablishConnectPackage.Serialize(), packageBeginPort, packageEndPort, IPAddress.Parse(establishIPAddress));
}
}
}
else if (packageID == UDPBoxUtility.PING_PONG_ID)
{
if (!mPingPongPackageTemplate.Deserialize(messageInterceptInfo.Bytes))
{
return(true);
}
if (mPingPongPackageTemplate.PingPong == PingPongPackage.EPingPong.Pong)
{
return(true);
}
if (IsMaster)
{
for (int i = 0, iMax = ClientIPConnectList.Count; i < iMax; i++)
{
var clientEndPoint = ClientIPConnectList[i];
if (clientEndPoint.IsPortAndIPContain(messageInterceptInfo.IPEndPoint))
{
ClientIPConnectList[i] = new ConnectInfo()
{
AliveTimer = 0f,
IPEndPoint = clientEndPoint.IPEndPoint,
BeginPort = clientEndPoint.BeginPort,
EndPort = clientEndPoint.EndPort,
IsClientEstablished = true
};
}
}
}
else
{
if (MasterIPConnectInfo.Valid && MasterIPConnectInfo.IsPortAndIPContain(messageInterceptInfo.IPEndPoint))
{
MasterIPConnectInfo = new ConnectInfo()
{
AliveTimer = 0f,
IPEndPoint = messageInterceptInfo.IPEndPoint,
BeginPort = MasterIPConnectInfo.BeginPort,
EndPort = MasterIPConnectInfo.EndPort,
};
}
}
return(true);
}
return(false);
}
void RefreshConnectStateInWorkThread()
{
var deltaTime = UDPBoxUtility.GetDeltaTime(mLastWorkThreadTime);
if (IsMaster)
{
if (ClientIPConnectList.Count > 0)
{
State = EState.HasClients;
}
else
{
State = EState.NoClients;
}
for (int i = 0, iMax = ClientIPConnectList.Count; i < iMax; i++)
{
var item = ClientIPConnectList[i];
if (!item.Valid)
{
continue;
}
item = new ConnectInfo()
{
AliveTimer = item.AliveTimer + deltaTime,
IPEndPoint = item.IPEndPoint,
BeginPort = item.BeginPort,
EndPort = item.EndPort,
IsClientEstablished = item.IsClientEstablished,
};
ClientIPConnectList[i] = item;
}
}
else
{
if (MasterIPConnectInfo.Valid)
{
State = EState.HasServer;
MasterIPConnectInfo = new ConnectInfo()
{
AliveTimer = MasterIPConnectInfo.AliveTimer + deltaTime,
IPEndPoint = MasterIPConnectInfo.IPEndPoint,
BeginPort = MasterIPConnectInfo.BeginPort,
EndPort = MasterIPConnectInfo.EndPort,
IsClientEstablished = MasterIPConnectInfo.IsClientEstablished,
};
}
else
{
State = EState.NoServer;
}
}
//update ticks.
if (IsMaster)
{
for (int i = ClientIPConnectList.Count - 1; i >= 0; i--)
{
var item = ClientIPConnectList[i];
if (!item.Valid)
{
continue;
}
if (!item.IsClientEstablished && item.AliveTimer > TIME_OUT_NOT_ESTABLISH_CONNECT_FLOAT)
{
ClientIPConnectList.RemoveAt(i);
}
else if (item.AliveTimer > TIME_OUT_CONNECT_FLOAT)
{
ClientIPConnectList.RemoveAt(i);
OnClientTimeOut?.Invoke(item.IPEndPoint);
}
}
}
else
{
if (MasterIPConnectInfo.Valid)
{
if (MasterIPConnectInfo.AliveTimer > TIME_OUT_CONNECT_FLOAT)
{
MasterIPConnectInfo = new ConnectInfo();
OnMasterIPTimeOut?.Invoke();
}
}
}
//update timeout.
if (mPingTargetThreadTimer <= 0f)
{
mPingPongPackageTemplate.PingPong = PingPongPackage.EPingPong.Ping;
if (IsMaster)
{
for (int i = 0, iMax = ClientIPConnectList.Count; i < iMax; i++)
{
var item = ClientIPConnectList[i];
if (item.Valid && item.IsClientEstablished)
{
SendUDPMessageToRandomPort(mPingPongPackageTemplate.Serialize(), item);
}
}
}
else
{
if (MasterIPConnectInfo.Valid)
{
SendUDPMessageToRandomPort(mPingPongPackageTemplate.Serialize(), MasterIPConnectInfo);
}
}
mPingTargetThreadTimer = PING_CONNECT_TIME_FLOAT;
}
else
{
mPingTargetThreadTimer -= deltaTime;
}//ping connect.
mLastWorkThreadTime = DateTime.Now.Ticks;
}
