public string Expect(Regex regex, int timeout = 500)
{
var cancellationToken = new CancellationTokenSource(TimeSpan.FromMilliseconds(timeout)).Token;
while (true)
{
while (ReceiveQueue.Count == 0 && !cancellationToken.IsCancellationRequested)
{
Thread.Sleep(10);
}
if (cancellationToken.IsCancellationRequested)
{
return(null);
}
var readline = ReceiveQueue.Dequeue();
if (!readline.Contains("="))
{
continue;
}
if (!regex.IsMatch(readline))
{
throw new Exception("Expected string matching " + regex + " but got " + readline + ".");
}
return(readline);
}
}
private void ReceiveFromQueue()
{
if (FirmwareVersion == 2)
{
if (ReceiveQueue.Any() && !HasRegValue(_RECEIVE))
{
SetRegValue(_RECEIVE, ReceiveQueue.Dequeue());
RemoveRegValue(_WAITING);
}
}
}
void ReceiveMessage()
{
KeyValuePair <IPEndPoint, DhtMessage> receive = ReceiveQueue.Dequeue();
DhtMessage message = receive.Value;
IPEndPoint source = receive.Key;
var query = default(SendDetails);
try {
Node node = Engine.RoutingTable.FindNode(message.Id);
if (node == null)
{
node = new Node(message.Id, source);
Engine.RoutingTable.Add(node);
}
// If we have received a ResponseMessage corresponding to a query we sent, we should
// remove it from our list before handling it as that could cause an exception to be
// thrown.
if (message is ResponseMessage || message is ErrorMessage)
{
if (!WaitingResponse.TryGetValue(message.TransactionId, out query))
{
return;
}
WaitingResponse.Remove(message.TransactionId);
}
node.Seen();
if (message is ResponseMessage response)
{
response.Handle(Engine, node);
query.CompletionSource?.TrySetResult(new SendQueryEventArgs(node, node.EndPoint, (QueryMessage)query.Message, response));
RaiseMessageSent(node, node.EndPoint, (QueryMessage)query.Message, response);
}
else if (message is ErrorMessage error)
{
query.CompletionSource?.TrySetResult(new SendQueryEventArgs(node, node.EndPoint, (QueryMessage)query.Message, error));
RaiseMessageSent(node, node.EndPoint, (QueryMessage)query.Message, error);
}
} catch (MessageException) {
var error = new ErrorMessage(message.TransactionId, ErrorCode.GenericError, "Unexpected error responding to the message");
query.CompletionSource?.TrySetResult(new SendQueryEventArgs(query.Node, query.Destination, (QueryMessage)query.Message, error));
} catch (Exception) {
var error = new ErrorMessage(message.TransactionId, ErrorCode.GenericError, "Unexpected exception responding to the message");
query.CompletionSource?.TrySetResult(new SendQueryEventArgs(query.Node, query.Destination, (QueryMessage)query.Message, error));
EnqueueSend(error, null, source);
}
}
public void DequeueTest()
{
ReceiveQueue target = new ReceiveQueue(); // TODO: 初始化为适当的值
byte[] byteBuffer = null; // TODO: 初始化为适当的值
byte[] byteBufferExpected = null; // TODO: 初始化为适当的值
long iOffset = 0; // TODO: 初始化为适当的值
long iSize = 0; // TODO: 初始化为适当的值
long expected = 0; // TODO: 初始化为适当的值
long actual;
actual = target.Dequeue(ref byteBuffer, iOffset, iSize);
Assert.AreEqual(byteBufferExpected, byteBuffer);
Assert.AreEqual(expected, actual);
Assert.Inconclusive("验证此测试方法的正确性。");
}
private void ReceiveQueue_NewMessage(object sender, EventArgs e)
{
if (ReceiveQueue.Count == 0)
{
return;
}
Message m = null;
//Trace.WriteLine(String.Format("Acquiring lock - {0}", m));
lock (ReceiveLock)
{
m = ReceiveQueue.Dequeue();
//Trace.WriteLine(string.Format("receive queue has {0} messages after dequeueing {1}", ReceiveQueue.Count, m));
HandleCongestionBackoff();
//Trace.WriteLine(String.Format("Acquiried lock - {0}", m));
UserDefined_ReceiveMessageProcedure(m);
//Trace.WriteLine(String.Format("Releasing lock - {0}", m));
}
//Trace.WriteLine(String.Format("Released lock - {0}", m));
}
private Task processorReceiveData()
{
return(Task.Run(() =>
{
while (m_IsRun)
{
try
{
if (ReceiveQueue.Count > 0)
{
WHQueueModel vReceiveData = ReceiveQueue.Dequeue();
switch (vReceiveData.Data[11])
{
//处理接收到的电源状态数据
case (byte)PowerDataPack_Receive_CommandEnum.RunningStatus:
PowerDataPack_Receive_RunningStatus vDataPack1 = NetHelper.ByteToStructure <PowerDataPack_Receive_RunningStatus>(vReceiveData.Data);
processorData_RunningStatus(vDataPack1, vReceiveData.IPAddress);
break;
case (byte)PowerDataPack_Receive_CommandEnum.SwitchStatus: //处理接收到回复电源开关状态数据
case (byte)PowerDataPack_Receive_CommandEnum.SetTime: //设置时间
case (byte)PowerDataPack_Receive_CommandEnum.SetSwitchParam: //开关参数设置
case (byte)PowerDataPack_Receive_CommandEnum.Timing: //定时设置
case (byte)PowerDataPack_Receive_CommandEnum.SetIPAddress: //设置IP地址
PowerDataPack_Receive_ReplyCMD vDataPack2 = NetHelper.ByteToStructure <PowerDataPack_Receive_ReplyCMD>(vReceiveData.Data);
processorData_ReplyCMD(vReceiveData.Data[11], vDataPack2);
break;
//电源上报事件
case (byte)PowerDataPack_Receive_CommandEnum.Event:
PowerDataPack_Receive_Event vDataPack3 = NetHelper.ByteToStructure <PowerDataPack_Receive_Event>(vReceiveData.Data);
processorData_Event(vDataPack3, vReceiveData.IPAddress);
break;
//获取IP地址
case (byte)PowerDataPack_Receive_CommandEnum.GetIPAddress:
PowerDataPack_Receive_GetIPAddress vDataPack4 = NetHelper.ByteToStructure <PowerDataPack_Receive_GetIPAddress>(vReceiveData.Data);
processorData_GetIPAddress(vDataPack4);
break;
//获取开关参数设置
case (byte)PowerDataPack_Receive_CommandEnum.GetSwitchParam:
PowerDataPack_Receive_GetSwitchParam vDataPack5 = NetHelper.ByteToStructure <PowerDataPack_Receive_GetSwitchParam>(vReceiveData.Data);
processorData_GetSwitchParam(vDataPack5);
break;
//获取电源时间
case (byte)PowerDataPack_Receive_CommandEnum.GetTime:
PowerDataPack_Receive_GetTime vDataPack6 = NetHelper.ByteToStructure <PowerDataPack_Receive_GetTime>(vReceiveData.Data);
processorData_GetTime(vDataPack6);
break;
//获取设备信息
case (byte)PowerDataPack_Receive_CommandEnum.GetControlInfo:
PowerDataPack_Receive_GetControlInfo vDataPack7 = NetHelper.ByteToStructure <PowerDataPack_Receive_GetControlInfo>(vReceiveData.Data);
processorData_GetControlInfo(vDataPack7);
break;
}
}
Thread.Sleep(100);
}
catch (Exception ex)
{
string vOutInfo = string.Format("电源处理数据报文发生异常,错误信息{0}", ex.Message);
Console.WriteLine(vOutInfo);
LogHelper.WriteLog_Error(typeof(PowerControl), vOutInfo);
}
}
}));
}
/// <summary>
///
/// </summary>
/// <param name="netState"></param>
internal static void MessagePump_ProcessReceive(object sender, NetStateEventArgs eventArgs)
{
LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...){0}", Thread.CurrentThread.Name);
if (eventArgs.NetState == null)
{
Debug.WriteLine("ProcessNet.EventDelegateProcessReceive(...) - netState == null error!");
return;
}
ReceiveQueue l_ReceiveQueueBuffer = eventArgs.NetState.ReceiveBuffer;
if (l_ReceiveQueueBuffer == null)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - byteQueueBuffer == null error!");
return;
}
LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...)-Length={0},{1}", l_ReceiveQueueBuffer.Length, Thread.CurrentThread.Name);
if (l_ReceiveQueueBuffer.Length < PACKAGE_HEAD)
{
// 等待数据包的完整
return;
}
long l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; // 隔段时间就会有数据过来，所以可以不用锁定的，锁定了也没用,很难保证多线程中处理了所有的数据
while (l_iReceiveBufferLength >= PACKAGE_HEAD)
{
// ReceiveQueue内部已经有锁定
long l_iPacketSize = l_ReceiveQueueBuffer.GetPacketLength();
if (l_iPacketSize < PACKAGE_HEAD)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iPacketSize <= 0 error!");
eventArgs.NetState.Dispose(); // 断开
return;
}
if (l_iReceiveBufferLength < l_iPacketSize)
{
// 等待数据包的完整
break;
}
if (l_iPacketSize > BUFFER_SIZE) // 数据包过大
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iPacketSize > BUFFER_SIZE error!");
eventArgs.NetState.Dispose(); // 断开
return;
}
// 获取空数据
byte[] l_PacketBuffer = m_ProcessorBuffers.AcquireBuffer();
// ReceiveQueue内部已经有锁定
long l_iReturnPacketSize = l_ReceiveQueueBuffer.Dequeue(ref l_PacketBuffer, 0, l_iPacketSize);
// 获取的数据不相同
if (l_iReturnPacketSize != l_iPacketSize)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iReturnPacketSize != iPacketSize error!");
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
//////////////////////////////////////////////////////////////////////////
using (StreamWriter streamWriter = new StreamWriter("PreIn_Packets.log", true))
{
byte[] byteBuffer = l_PacketBuffer;
if (byteBuffer.Length > 0)
{
streamWriter.WriteLine("客户端: {0} 未经解密过的信息包 长度 = 0x{1:X4} ID = Unknown", eventArgs.NetState, l_iPacketSize);
streamWriter.WriteLine("--------------------------------------------------------------------------");
}
using (MemoryStream memoryStream = new MemoryStream(byteBuffer))
Utility.FormatBuffer(streamWriter, memoryStream, l_iPacketSize);
streamWriter.WriteLine();
streamWriter.WriteLine();
}
//////////////////////////////////////////////////////////////////////////
try
{
// 解密数据包
ROSECrypt.CryptPacket(ref l_PacketBuffer, eventArgs.NetState.EncoderSeed);
}
catch
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - ROSECrypt.CryptPacket(...) Exception error!");
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 读取的数据包
PacketReader l_PacketReader = new PacketReader(l_PacketBuffer, l_iPacketSize, PACKAGE_HEAD /*包的长度大小-2个字节、ID大小-2个字节、未用数据大小-2个字节, 6个字节跳过*/);
//////////////////////////////////////////////////////////////////////////
using (StreamWriter streamWriter = new StreamWriter("In_Packets.log", true))
{
byte[] byteBuffer = l_PacketBuffer;
if (byteBuffer.Length > 0)
{
streamWriter.WriteLine("客户端: {0} 经解密过的信息包 长度 = 0x{1:X4} ID = 0x{2:X4}", eventArgs.NetState, l_iPacketSize, l_PacketReader.GetPacketID());
streamWriter.WriteLine("--------------------------------------------------------------------------");
}
using (MemoryStream memoryStream = new MemoryStream(byteBuffer))
Utility.FormatBuffer(streamWriter, memoryStream, l_iPacketSize);
streamWriter.WriteLine();
streamWriter.WriteLine();
}
//////////////////////////////////////////////////////////////////////////
// 获取数据包命令的ID
long l_iPacketID = l_PacketReader.GetPacketID();
LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...)-Packet ID = 0x{0:X4}", l_iPacketID);
// 获取处理数据包的实例
PacketHandler l_PacketHandler = PacketHandlers.GetHandler(l_iPacketID);
if (l_PacketHandler == null) // 说明还没有解开当前的数据包内容
{
l_PacketReader.Trace(eventArgs.NetState);
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
// 获取剩下的数据长度
l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length;
continue;
}
// 当前需处理的数据包的大小
long l_iPacketHandlerLength = l_PacketHandler.Length;
if (l_iPacketHandlerLength > l_iReturnPacketSize) // 包需求的数据大小大于得到的数据大小
{
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
PacketProfile l_PacketProfile = PacketProfile.GetIncomingProfile(l_iPacketID);
DateTime dateTimeStart = (l_PacketProfile == null ? DateTime.MinValue : DateTime.Now);
{
l_PacketHandler.OnReceive(eventArgs.NetState, l_PacketReader);
}
if (l_PacketProfile != null)
{
l_PacketProfile.Record(l_iPacketHandlerLength, DateTime.Now - dateTimeStart);
}
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
// 获取剩下的数据长度
l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length;
}
}
/// <summary>
///
/// </summary>
/// <param name="netState"></param>
internal void ConnecterProcessReceive(object sender, NetStateEventArgs eventArgs)
{
if (eventArgs.NetState == null)
{
throw new Exception("Domain.ConnecterProcessReceive(...) - netState == null error!");
}
if (eventArgs.NetState.ReceiveBuffer == null)
{
throw new Exception("Domain.ConnecterProcessReceive(...) - eventArgs.NetState.ReceiveBuffer == null error!");
}
ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer;
if (receiveQueueBuffer.Length < PACKAGE_HEAD)
{
// 等待数据包的完整
return;
}
long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来，所以可以不用锁定的，锁定了也没用,很难保证多线程中处理了所有的数据
while (iReceiveBufferLength >= PACKAGE_HEAD)
{
// ReceiveQueue内部已经有锁定
long iPacketSize = receiveQueueBuffer.GetPacketLength();
if (iPacketSize < PACKAGE_HEAD)
{
LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ConnecterProcessReceive(...) - iPacketSize < PACKAGE_HEAD error!");
eventArgs.NetState.Dispose(); // 断开
return;
}
if (iReceiveBufferLength < iPacketSize)
{
// 等待数据包的完整
break;
}
if (iPacketSize > BUFFER_SIZE) // 数据包过大
{
LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ConnecterProcessReceive(...) - iPacketSize > BUFFER_SIZE error!");
eventArgs.NetState.Dispose(); // 断开
return;
}
// 获取空数据
byte[] packetBuffer = m_ProcessorBuffers.AcquireBuffer();
// ReceiveQueue内部已经有锁定
long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, iPacketSize);
// 获取的数据不相同
if (iReturnPacketSize != iPacketSize)
{
LOGs.WriteLine(LogMessageType.MSG_ERROR, "Domain.ConnecterProcessReceive(...) - iReturnPacketSize != iPacketSize error!");
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 读取的数据包
PacketReader packetReader = new PacketReader(packetBuffer, iPacketSize,
PACKAGE_HEAD /*包的长度大小-2个字节、ID大小-2个字节, 4个字节跳过*/,
new EventHandler <PacketIdInfoEventArgs>(this.GetPacketID));
// 获取数据包命令的ID
long iPacketID = packetReader.GetPacketID();
// 获取处理数据包的实例
PacketHandler packetHandler = DomainPacketHandlers.GetHandler(iPacketID);
if (packetHandler == null) // 说明还没有解开当前的数据包内容
{
packetReader.Trace(eventArgs.NetState);
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
continue;
}
// 当前需处理的数据包的大小
long iPacketHandlerLength = packetHandler.Length;
if (iPacketHandlerLength > iReturnPacketSize) // 包需求的数据大小大于得到的数据大小
{
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 处理数据
packetHandler.OnReceive(eventArgs.NetState, packetReader);
// 返回内存池
m_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
}
}
/// <summary>
///
/// </summary>
/// <param name="netState"></param>
internal static void RealmProcessReceive(object sender, NetStateEventArgs eventArgs)
{
LOGs.WriteLine(LogMessageType.MSG_HACK, "Realm_ProcessReceive...... 0 = {0}", eventArgs.NetState.ReceiveBuffer.Length);
if (eventArgs.NetState == null)
{
Debug.WriteLine("ProcessNet.RealmList_ProcessReceive(...) - eventArgs.NetState == null error!");
return;
}
ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer;
if (receiveQueueBuffer == null)
{
Debug.WriteLine("ProcessNet.RealmList_ProcessReceive(...) - receiveQueueBuffer == null error!");
return;
}
if (receiveQueueBuffer.Length < REALM_HEAD_SIZE)
{
// 等待数据包的完整
return;
}
long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来，所以可以不用锁定的，锁定了也没用,很难保证多线程中处理了所有的数据
while (iReceiveBufferLength >= REALM_HEAD_SIZE)
{
// 获取包的 ID
long iPacketID = receiveQueueBuffer.GetPacketID();
// 获取包的长度
long iPacketLength = receiveQueueBuffer.Length;
if (iPacketLength > BUFFER_SIZE) // 数据包过大
{
Debug.WriteLine("ProcessNet.RealmList_ProcessReceive(...) - iPacketLength > BUFFER_SIZE error!");
eventArgs.NetState.Dispose(); // 断开
return;
}
// 获取空数据
byte[] packetBuffer = s_ProcessorBuffers.AcquireBuffer();
// 获取数据内容
long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, iPacketLength);
// 获取的数据不相同
if (iReturnPacketSize != iPacketLength)
{
Debug.WriteLine("ProcessNet.RealmList_ProcessReceive(...) - iReturnPacketSize != iPacketLength error!");
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
//////////////////////////////////////////////////////////////////////////
// 输出信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketLength, "Realm_In_Packets.log", eventArgs.NetState.ToString(), iPacketID, RealmOpCodeName.GetRealmOpCodeName(iPacketID));
//////////////////////////////////////////////////////////////////////////
// 读取的数据包
PacketReader packetReader = new PacketReader(packetBuffer, iPacketLength, REALM_HEAD_SIZE /*包的ID大小-1个字节、长度大小-2个字节, 3个字节跳过*/);
// 获取处理数据包的实例
PacketHandler packetHandler = ProcessServer.RealmPacketHandlers.GetHandler(iPacketID);
if (packetHandler == null) // 说明还没有解开当前的数据包内容
{
//////////////////////////////////////////////////////////////////////////
// 输出未知信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketLength, "Realm_In_Unknown_Packets.log", eventArgs.NetState.ToString(), iPacketID, RealmOpCodeName.GetRealmOpCodeName(iPacketID));
//////////////////////////////////////////////////////////////////////////
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
continue;
}
// 当前需处理的数据包的大小
long iPacketHandlerLength = packetHandler.Length;
if (iPacketHandlerLength > iReturnPacketSize) // 包需求的数据大小大于得到的数据大小
{
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 处理数据
packetHandler.OnReceive(eventArgs.NetState, packetReader);
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
}
}
/// <summary>
///
/// </summary>
/// <param name="netState"></param>
internal static void WorldProcessReceive(object sender, NetStateEventArgs eventArgs)
{
LOGs.WriteLine(LogMessageType.MSG_HACK, "World_ProcessReceive...... 0 = {0}", eventArgs.NetState.ReceiveBuffer.Length);
if (eventArgs.NetState == null)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - eventArgs.NetState == null error!");
return;
}
ReceiveQueue receiveQueueBuffer = eventArgs.NetState.ReceiveBuffer;
if (receiveQueueBuffer == null)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - receiveQueueBuffer == null error!");
return;
}
WorldExtendData extendData = eventArgs.NetState.GetComponent <WorldExtendData>(WorldExtendData.COMPONENT_ID);
if (extendData == null)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - extendData == null error!");
return;
}
if (receiveQueueBuffer.Length < extendData.ProcessReceiveData.Remaining)
{
// 等待数据包的完整(Remaining 默认的大小为WORLD_HEAD_SIZE)
return;
}
long iReceiveBufferLength = receiveQueueBuffer.Length; // 隔段时间就会有数据过来，所以可以不用锁定的，锁定了也没用,很难保证多线程中处理了所有的数据(指 Length)
while (iReceiveBufferLength >= extendData.ProcessReceiveData.Remaining)
{
if (extendData.ProcessReceiveData.PacketBuffer == null) // 如果空 代表是需要获取新的数据包和包头(Remaining == WORLD_HEAD_SIZE)
{
// 获取空数据
byte[] packetBuffer = s_ProcessorBuffers.AcquireBuffer();
// 获取数据包头的内容
long iReturnPacketHeadSize = receiveQueueBuffer.Dequeue(ref packetBuffer, 0, WORLD_HEAD_SIZE);
// 获取的数据不相同
if (iReturnPacketHeadSize != WORLD_HEAD_SIZE)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketHeadSize != WORLD_HEAD_SIZE error!");
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
IPacketEncoder packetEncoder = eventArgs.NetState.PacketEncoder as IPacketEncoder;
if (packetEncoder == null)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - packetEncoder == null error!");
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 解密数据包头
long iClientPacketHeader = WORLD_HEAD_SIZE;
packetEncoder.DecodeIncomingPacket(eventArgs.NetState, ref packetBuffer, ref iClientPacketHeader);
// 给出数据信息头
WOWClientPacketHeader clientPacketHeader = WOWClientPacketHeader.GetClientPacketHeader(packetBuffer);
int iRemaining = clientPacketHeader.PacketSize - 4; // -4 是代表剩余的数据包大小(为什么不是减6呢？)
if (receiveQueueBuffer.Length < iRemaining)
{
// 等待数据包的完整
{
extendData.ProcessReceiveData.PacketBuffer = packetBuffer;
extendData.ProcessReceiveData.Remaining = (uint)iRemaining;
return;
}
}
// 获取信息包数据的剩余内容
long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, WORLD_HEAD_SIZE, iRemaining /*获取剩余数据包大小的字节数*/);
// 获取的数据不相同
if (iReturnPacketSize != iRemaining)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketSize != iRemaining error!");
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 获取包的全部长度
long iPacketFullLength = iRemaining + WORLD_HEAD_SIZE;
// 读取的数据包
PacketReader packetReader = new PacketReader(packetBuffer, iPacketFullLength, WORLD_HEAD_SIZE /*包的ID大小-4个字节、长度大小-2个字节, 6个字节跳过*/);
//////////////////////////////////////////////////////////////////////////
// 输出信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID));
//////////////////////////////////////////////////////////////////////////
// 获取处理数据包的实例
PacketHandler packetHandler = ProcessServer.WorldPacketHandlers.GetHandler(clientPacketHeader.PacketID);
if (packetHandler == null) // 说明还没有解开当前的数据包内容
{
//////////////////////////////////////////////////////////////////////////
// 输出未知信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Unknown_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID));
//////////////////////////////////////////////////////////////////////////
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
continue;
}
// 当前需处理的数据包的大小
long iPacketHandlerLength = packetHandler.Length;
if (iPacketHandlerLength > iPacketFullLength) // 包需求的数据大小大于得到的数据大小
{
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 处理数据
packetHandler.OnReceive(eventArgs.NetState, packetReader);
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
}
else //已有数据包头获取剩余数据
{
byte[] packetBuffer = extendData.ProcessReceiveData.PacketBuffer;
// 获取信息包数据的剩余内容
long iReturnPacketSize = receiveQueueBuffer.Dequeue(ref packetBuffer, WORLD_HEAD_SIZE, extendData.ProcessReceiveData.Remaining /*获取剩余数据包大小的字节数*/);
// 获取的数据不相同
if (iReturnPacketSize != extendData.ProcessReceiveData.Remaining)
{
Debug.WriteLine("ProcessNet.World_ProcessReceive(...) - iReturnPacketSize != Remaining error!");
// 恢复原始数据状态
extendData.ProcessReceiveData.PacketBuffer = null;
extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE;
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 获取包的全部长度
long iPacketFullLength = extendData.ProcessReceiveData.Remaining + WORLD_HEAD_SIZE;
// 读取的数据包
PacketReader packetReader = new PacketReader(extendData.ProcessReceiveData.PacketBuffer, iPacketFullLength, WORLD_HEAD_SIZE /*包的ID大小-4个字节、长度大小-2个字节, 6个字节跳过*/);
// 给出数据信息头
WOWClientPacketHeader clientPacketHeader = WOWClientPacketHeader.GetClientPacketHeader(extendData.ProcessReceiveData.PacketBuffer);
//////////////////////////////////////////////////////////////////////////
// 输出信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID));
//////////////////////////////////////////////////////////////////////////
// 获取处理数据包的实例
PacketHandler packetHandler = ProcessServer.WorldPacketHandlers.GetHandler(clientPacketHeader.PacketID);
if (packetHandler == null) // 说明还没有解开当前的数据包内容
{
//////////////////////////////////////////////////////////////////////////
// 输出未知信息包的日志
//////////////////////////////////////////////////////////////////////////
ProcessNet.LogServerPack(packetBuffer, iPacketFullLength, "World_In_Unknown_Packets.log", eventArgs.NetState.ToString(), clientPacketHeader.PacketID, WordOpCodeName.GetWordOpCodeName(clientPacketHeader.PacketID));
//////////////////////////////////////////////////////////////////////////
// 恢复原始数据状态
extendData.ProcessReceiveData.PacketBuffer = null;
extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE;
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
continue;
}
// 当前需处理的数据包的大小
long iPacketHandlerLength = packetHandler.Length;
if (iPacketHandlerLength > iPacketFullLength) // 包需求的数据大小大于得到的数据大小
{
// 恢复原始数据状态
extendData.ProcessReceiveData.PacketBuffer = null;
extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE;
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(packetBuffer);
eventArgs.NetState.Dispose(); // 断开
return;
}
// 处理数据
packetHandler.OnReceive(eventArgs.NetState, packetReader);
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(extendData.ProcessReceiveData.PacketBuffer);
// 恢复原始数据状态
extendData.ProcessReceiveData.PacketBuffer = null;
extendData.ProcessReceiveData.Remaining = WORLD_HEAD_SIZE;
// 获取剩下的数据长度
iReceiveBufferLength = receiveQueueBuffer.Length;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="netState"></param>
internal static void Zone_ProcessReceive(object sender, NetStateEventArgs eventArgs)
{
LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...) {0}", Thread.CurrentThread.Name);
if (eventArgs.NetState == null)
{
Debug.WriteLine("ProcessNet.EventDelegateProcessReceive(...) - netState == null error!");
return;
}
ZoneExtendData l_ExtendData = null;
if (eventArgs.NetState.ExtendData == null)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - eventArgs.NetState.ExtendData == null error!");
eventArgs.NetState.Dispose(false);
return;
}
else
{
l_ExtendData = eventArgs.NetState.ExtendData as ZoneExtendData;
if (l_ExtendData == null)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - l_ExtendData == null error!");
eventArgs.NetState.Dispose(false);
return;
}
}
ReceiveQueue l_ReceiveQueueBuffer = eventArgs.NetState.ReceiveBuffer;
if (l_ReceiveQueueBuffer == null)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - byteQueueBuffer == null error!");
return;
}
LOGs.WriteLine(LogMessageType.MSG_HACK, "ProcessNet.MessagePump_ProcessReceive(...) Length = {0},{1}", l_ReceiveQueueBuffer.Length, Thread.CurrentThread.Name);
long l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length; // 隔段时间就会有数据过来，所以可以不用锁定的，锁定了也没用,很难保证多线程中处理了所有的数据
while (l_iReceiveBufferLength > 0)
{
// 获取空数据
byte[] l_PacketBuffer = s_ProcessorBuffers.AcquireBuffer();
// ReceiveQueue内部已经有锁定
long l_iReturnPacketSize = l_ReceiveQueueBuffer.Dequeue(ref l_PacketBuffer, 0, l_iReceiveBufferLength);
// 获取的数据不相同
if (l_iReturnPacketSize != l_iReceiveBufferLength)
{
Debug.WriteLine("ProcessNet.MessagePump_ProcessReceive(...) - iReturnPacketSize != iPacketSize error!");
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
eventArgs.NetState.Dispose(false); // 断开
return;
}
// 发送数据
l_ExtendData.SendToZoneClusterServer(l_PacketBuffer, l_iReturnPacketSize);
// 返回内存池
s_ProcessorBuffers.ReleaseBuffer(l_PacketBuffer);
// 获取剩下的数据长度
l_iReceiveBufferLength = l_ReceiveQueueBuffer.Length;
}
}
protected override object ReceiveThreadProcess(object o)
{
Byte[] bytes = new Byte[this.BufferSize];
int byteIndex = 0;
while (this.ProgramRunning && this.Status == SocketStatus.SOCKET_STATUS_CONNECTED)
{
try
{
byte b = ReceiveQueue.Dequeue();
// If find byte = CR
if (b == 13)
{
// check the next byte may also be 13 in which this one maybe the checksum
if (ReceiveQueue.Peek() == 13)
{
b = ReceiveQueue.Dequeue();
bytes[byteIndex] = b;
byteIndex++;
}
// Copy bytes to new array with length of packet and ignoring the CR.
Byte[] copiedBytes = new Byte[byteIndex];
Array.Copy(bytes, copiedBytes, byteIndex);
byteIndex = 0;
int chk = 0;
for (int i = 1; i < (copiedBytes.Length - 1); i++)
{
chk = chk ^ copiedBytes[i];
}
#if DEBUG
CrestronConsole.Print("NEC Rx: ");
Tools.PrintBytes(copiedBytes, copiedBytes.Length, false);
#endif
if (copiedBytes.Length > 0 && chk == (int)copiedBytes.Last())
{
if (this.ReceivedData != null)
{
this.ReceivedData(this, copiedBytes);
}
}
else if (copiedBytes.Length > 0)
{
ErrorLog.Warn("NEC Display Rx: \"{0}\"", Tools.GetBytesAsReadableString(copiedBytes, copiedBytes.Length, true));
ErrorLog.Warn("NEC Display Rx - Checksum Error, chk = 0x{0}, byteIndex = {1}, copiedBytes.Length = {2}",
chk.ToString("X2"), byteIndex, copiedBytes.Length);
#if DEBUG
CrestronConsole.PrintLine("NEC Display Rx - Checksum Error, chk = 0x{0}, byteIndex = {1}, copiedBytes.Length = {2}",
chk.ToString("X2"), byteIndex, copiedBytes.Length);
CrestronConsole.PrintLine("rxQueue.Peek() = {0}", ReceiveQueue.Peek());
#endif
}
if (ReceiveQueue.IsEmpty)
{
break;
}
}
else
{
bytes[byteIndex] = b;
byteIndex++;
}
CrestronEnvironment.AllowOtherAppsToRun();
Thread.Sleep(0);
}
catch (Exception e)
{
ErrorLog.Error("{0} - Error in ReceiveThreadProcess, {1}", this.GetType().Name, e.Message);
break;
}
}
return(null);
}
protected override object ReceiveThreadProcess(object o)
{
#if DEBUG
CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() Start", this.GetType().Name);
#endif
int index = 0;
byte[] bytes = new Byte[this.BufferSize];
while (this.ProgramRunning && this.Status == SocketStatus.SOCKET_STATUS_CONNECTED)
{
byte b = ReceiveQueue.Dequeue();
// if find '<' char reset the count
if (b == 0x3c)
{
index = 0;
bytes[index] = b;
index++;
}
// if find '>' char we have a string
else if (b == 0x3e)
{
bytes[index] = b;
index++;
// Copy bytes to new array with length of packet and ignoring the CR.
Byte[] copiedBytes = new Byte[index];
Array.Copy(bytes, copiedBytes, index);
index = 0;
if (ReceivedData != null)
{
ReceivedData(this, copiedBytes);
}
if (ReceiveQueue.IsEmpty)
{
break;
}
}
else if (b > 0 && b <= 127)
{
if (index < this.BufferSize)
{
bytes[index] = b;
index++;
}
else
{
#if DEBUG
CrestronConsole.PrintLine("Buffer overflow, index = {0}, b = {1}", index, b);
#endif
ErrorLog.Error("{0}.ReceiveThreadProcess - Buffer overflow error", this.GetType().Name);
index = 0;
break;
}
}
CrestronEnvironment.AllowOtherAppsToRun();
Thread.Sleep(0);
}
#if DEBUG
CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() End", this.GetType().Name);
#endif
return(null);
}
protected override object ReceiveThreadProcess(object o)
{
#if DEBUG
//CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() Start", this.GetType().Name);
#endif
int index = 0;
byte[] bytes = new Byte[this.BufferSize];
while (this.ProgramRunning && this.Status == SocketStatus.SOCKET_STATUS_CONNECTED)
{
byte b = ReceiveQueue.Dequeue();
if (b == 13)
{
}
// skip
else if (b == 10)
{
// Copy bytes to new array with length of packet and ignoring the CR.
Byte[] copiedBytes = new Byte[index];
Array.Copy(bytes, copiedBytes, index);
index = 0;
if (ReceivedData != null)
{
ReceivedData(this, copiedBytes);
}
if (Encoding.ASCII.GetString(copiedBytes, 0, copiedBytes.Length) != "cgpa")
{
if (ReceivedControlResponse != null)
{
ReceivedControlResponse(this, copiedBytes);
}
#if DEBUG
CrestronConsole.PrintLine("{0} Processed reply: {1}", this.GetType().Name, Encoding.ASCII.GetString(copiedBytes, 0, copiedBytes.Length));
#endif
}
if (ReceiveQueue.IsEmpty)
{
break;
}
}
else
{
if (index < bytes.Length)
{
bytes[index] = b;
index++;
}
else
{
#if DEBUG
CrestronConsole.PrintLine("Buffer overflow, index = {0}, b = {1}", index, b);
#endif
ErrorLog.Error("{0}.ReceiveThreadProcess - Buffer overflow error", this.GetType().Name);
index = 0;
break;
}
}
CrestronEnvironment.AllowOtherAppsToRun();
Thread.Sleep(0);
}
#if DEBUG
//CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() End", this.GetType().Name);
#endif
return(null);
}
protected override object ReceiveThreadProcess(object o)
{
#if DEBUG
CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() Start", this.GetType().Name);
#endif
int index = 0;
byte[] bytes = new Byte[this.BufferSize];
int dataLength = 0;
while (this.ProgramRunning && this.Status == SocketStatus.SOCKET_STATUS_CONNECTED)
{
try
{
byte b = ReceiveQueue.Dequeue();
if (b == 0xAA)
{
index = 0;
dataLength = 0;
}
else if (index < this.BufferSize)
{
index++;
}
else
{
#if DEBUG
CrestronConsole.PrintLine("Buffer overflow, index = {0}, b = {1}", index, b);
#endif
ErrorLog.Error("{0}.ReceiveThreadProcess - Buffer overflow error", this.GetType().Name);
index = 0;
break;
}
bytes[index] = b;
if (index == 3)
{
dataLength = bytes[index];
}
if (index == (dataLength + 4))
{
int chk = bytes[index];
int test = 0;
for (int i = 1; i < index; i++)
{
test = test + bytes[i];
}
if (chk == (byte)test)
{
byte[] copiedBytes = new byte[index];
Array.Copy(bytes, copiedBytes, index);
if (ReceivedData != null)
{
ReceivedData(this, copiedBytes);
}
if (ReceiveQueue.IsEmpty)
{
break;
}
}
}
}
catch (Exception e)
{
if (e.Message != "ThreadAbortException")
{
ErrorLog.Exception(string.Format("{0} - Exception in thread", this.GetType().Name), e);
}
}
CrestronEnvironment.AllowOtherAppsToRun();
Thread.Sleep(0);
}
#if DEBUG
CrestronConsole.PrintLine("{0}.ReceiveThreadProcess() End", this.GetType().Name);
#endif
return(null);
}
