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; }