private int PackSort(PacketWrapper x, PacketWrapper y)
{
if (x.tcpPacket.SequenceNumber > y.tcpPacket.SequenceNumber)
{
return(1);
}
else
{
return(-1);
}
}
public byte[] SerializePacket <T>(NetworkPacket <T> networkPacket, uint senderID = 0, uint objectID = 0,
ReliablePacketHeader reliablePacketHeader = null)
{
byte[] data = null;
PacketWrapper packetWrapper = new PacketWrapper();
MemoryStream memoryStream = new MemoryStream();
PacketHeader packetHeader = new PacketHeader();
packetHeader.ProtocolID = ProtocolID;
packetHeader.PacketTypeIndex = networkPacket.PacketTypeIndex;
packetHeader.Serialize(memoryStream);
if ((PacketType)networkPacket.PacketTypeIndex == PacketType.User)
{
UserNetworkPacket <T> userNetworkPacket = networkPacket as UserNetworkPacket <T>;
UserPacketHeader userPacketHeader = new UserPacketHeader();
userPacketHeader.UserPacketTypeIndex = userNetworkPacket.UserPacketTypeIndex;
userPacketHeader.SenderID = senderID;
userPacketHeader.ObjectID = objectID;
userPacketHeader.Reliable = (reliablePacketHeader != null);
userPacketHeader.Serialize(memoryStream);
if (reliablePacketHeader != null)
{
reliablePacketHeader.Serialize(memoryStream);
}
}
networkPacket.Serialize(memoryStream);
memoryStream.Close();
data = memoryStream.ToArray();
packetWrapper.Crc = crcCalculator.ComputeCrc32(data);
packetWrapper.PacketData = data;
memoryStream = new MemoryStream();
packetWrapper.Serialize(memoryStream);
memoryStream.Close();
data = memoryStream.ToArray();
return(data);
}
private void BackgroundThreadFunc()
{
while (!_backgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (_packetQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else
{
List <RawCapture> ourQueue;
lock (QueueLock)
{
ourQueue = _packetQueue;
_packetQueue = new List <RawCapture>();
}
foreach (var packet in ourQueue)
{
// Здесь мы можем обрабатывать пакеты свободно, не занимая перехватываемое устройство
var packetWrapper = new PacketWrapper(_packetCount, packet);
packetStrings.Enqueue(packetWrapper);
_packetCount++;
}
_view.BeginInvoke(bs, packetStrings);
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
}
}
bool DeserializePacket(byte[] data, out MemoryStream memoryStream, out PacketHeader packetHeader,
ref UserPacketHeader userPacketHeader, ref ReliablePacketHeader reliablePacketHeader)
{
bool isFaultless;
PacketWrapper packetWrapper = new PacketWrapper();
memoryStream = new MemoryStream(data);
packetHeader = new PacketHeader();
packetWrapper.Deserialize(memoryStream);
memoryStream.Close();
isFaultless = crcCalculator.PerformCrcCheck(packetWrapper.PacketData, packetWrapper.Crc);
if (isFaultless)
{
memoryStream = new MemoryStream(packetWrapper.PacketData);
packetHeader.Deserialize(memoryStream);
if ((PacketType)packetHeader.PacketTypeIndex == PacketType.User)
{
userPacketHeader = new UserPacketHeader();
userPacketHeader.Deserialize(memoryStream);
if (userPacketHeader.Reliable)
{
reliablePacketHeader = new ReliablePacketHeader();
reliablePacketHeader.Deserialize(memoryStream);
}
}
}
return(isFaultless);
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List <RawCapture> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List <RawCapture>();
}
Console.WriteLine("BackgroundThread: ourQueue.Count is {0}", ourQueue.Count);
foreach (var packet in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
var packetWrapper = new PacketWrapper(packetCount, packet);
this.BeginInvoke(new MethodInvoker(delegate
{
packetStrings.Enqueue(packetWrapper);
}
));
packetCount++;
var time = packet.Timeval.Date;
var len = packet.Data.Length;
Console.WriteLine("BackgroundThread: {0}:{1}:{2},{3} Len={4}",
time.Hour, time.Minute, time.Second, time.Millisecond, len);
}
this.BeginInvoke(new MethodInvoker(delegate
{
bs.DataSource = packetStrings.Reverse();
}
));
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
}
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List <RawCapture> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List <RawCapture>();
}
ProcessQueueTick?.Invoke(this, new L2RProcessQueueTickEventArgs(ourQueue.Count));
foreach (RawCapture packet in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
try
{
PacketWrapper packetWrapper = new PacketWrapper(packetCount, packet);
Packet parsepacket = Packet.ParsePacket(packet.LinkLayerType, packet.Data);
TcpPacket tcpPacket = (TcpPacket)parsepacket.Extract(typeof(TcpPacket));
if (tcpPacket != null)
{
byte[] packetData = tcpPacket.PayloadData;
if (packetData != null)
{
ProcessPackets(packetData);
}
packetCount++;
}
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
catch (Exception ex)
{
PacketError?.Invoke(this, new L2RPacketErrorEventArgs(ex, packet));
throw;
}
}
}
}
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List<RawCapture> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List<RawCapture>();
}
Console.WriteLine("BackgroundThread: ourQueue.Count is {0}", ourQueue.Count);
foreach (var packet in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
var packetWrapper = new PacketWrapper(packetCount, packet);
this.BeginInvoke(new MethodInvoker(delegate
{
packetStrings.Enqueue(packetWrapper);
}
));
packetCount++;
var time = packet.Timeval.Date;
var len = packet.Data.Length;
Console.WriteLine("BackgroundThread: {0}:{1}:{2},{3} Len={4}",
time.Hour, time.Minute, time.Second, time.Millisecond, len);
}
this.BeginInvoke(new MethodInvoker(delegate
{
bs.DataSource = packetStrings.Reverse();
}
));
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
}
}
public PacketWrapper(PacketWrapper envelope)
{
if (envelope == null)
return;
_isPseudoPacket = envelope._isPseudoPacket;
_packetNumber = envelope._packetNumber;
_timestamp = envelope._timestamp;
_elapsedMs = envelope._elapsedMs;
_readerIndex = envelope._readerIndex;
_readerName = envelope._readerName;
_packetType = envelope._packetType;
_packet = envelope._packet;
_rawPacket = (byte[])(envelope._rawPacket == null ? null : envelope._rawPacket.Clone());
_requestNumber = envelope._requestNumber;
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List <CaptureEventArgs> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List <CaptureEventArgs>();
}
Console.WriteLine("BackgroundThread: ourQueue.Count is {0}", ourQueue.Count);
foreach (var packetQueue in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
var packet = PacketDotNet.Packet.ParsePacket(packetQueue.Packet.LinkLayerType, packetQueue.Packet.Data);
var tcpPacket = packet.Extract <PacketDotNet.TcpPacket>();
if (tcpPacket != null)
{
var ipPacket = (PacketDotNet.IPPacket)tcpPacket.ParentPacket;
System.Net.IPAddress srcIp = ipPacket.SourceAddress;
System.Net.IPAddress dstIp = ipPacket.DestinationAddress;
int srcPort = tcpPacket.SourcePort;
int dstPort = tcpPacket.DestinationPort;
byte[] payload = tcpPacket.PayloadData;
int packetLength = tcpPacket.PayloadData.Length;
uint sequenceNumber = tcpPacket.SequenceNumber;
if (textBoxCaptureServerIpAddress.Text == srcIp.ToString() && textBoxCaptureServerPortNumber.Text.ToString() == srcPort.ToString())
{
var packetWrapper = new PacketWrapper(packetCount, packetQueue.Packet, srcIp, dstIp, srcPort, dstPort, payload, packetLength, sequenceNumber);
this.BeginInvoke(new MethodInvoker(delegate
{
packetStrings.Enqueue(packetWrapper);
}
));
packetCount++;
var time = packetQueue.Packet.Timeval.Date;
var len = packetQueue.Packet.Data.Length;
Console.WriteLine("BackgroundThread: {0}:{1}:{2},{3} Len={4}",
time.Hour, time.Minute, time.Second, time.Millisecond, len);
}
}
}
this.BeginInvoke(new MethodInvoker(delegate
{
bs.DataSource = packetStrings.Reverse();
}
));
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
}
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
try
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List <RawCapture> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List <RawCapture>();
}
logWriting(string.Format("BackgroundThread: ourQueue.Count is {0}", ourQueue.Count));
try
{
foreach (var packet in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
var packetWrapper = new PacketWrapper(packetCount, packet);
var pack = Packet.ParsePacket(packetWrapper.p.LinkLayerType, packetWrapper.p.Data);
var eth = (PacketDotNet.EthernetPacket)pack.Extract(typeof(PacketDotNet.EthernetPacket));
if (eth != null)
{
packetWrapper.Type = eth.Type;
}
var ip = (PacketDotNet.IPPacket)pack.Extract(typeof(PacketDotNet.IPPacket));
if (ip != null)
{
packetWrapper.SourceIP = ip.SourceAddress;
packetWrapper.DestinationIP = ip.DestinationAddress;
}
// filter
this.BeginInvoke(new MethodInvoker(delegate
{
try
{
if (Filter.OutThis(textBoxFilterSourceIP,
textBoxFilterDestinationIP,
textBoxFilterType,
packetWrapper,
packetStrings))
{
packetStrings.Enqueue(packetWrapper);
}
}
catch (Exception)
{
// ignore null
}
}));
packetCount++;
var time = packet.Timeval.Date;
var len = packet.Data.Length;
logWriting(string.Format("BackgroundThread: {0}:{1}:{2},{3} Len={4}",
time.Hour, time.Minute, time.Second, time.Millisecond, len));
}
}
catch (Exception ex)
{
logWriting(string.Format("{0}:\n{1}", "Error BackgroundThread", ex.ToString()));
}
this.BeginInvoke(new MethodInvoker(delegate
{
bs.DataSource = packetStrings.Reverse();
}));
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
}
}
catch (Exception ex)
{
logWriting(string.Format("{0}:\n{1}", "Error BackgroundThread", ex.ToString()));
}
}
private void OnPacketArrival(object sender, CaptureEventArgs e)
{
PacketWrapper packetWrapper = new PacketWrapper(packetId++, e.Packet);
uint ackn = packetWrapper.tcpPacket.AcknowledgmentNumber;
if (!packDic.ContainsKey(ackn))
{
packDic.Add(ackn, new List <PacketWrapper>());
packTimeRest.Add(ackn, new int[] { packTimeMax });
}
packDic[ackn].Add(packetWrapper);
List <uint> nd = new List <uint>();
foreach (var p in packTimeRest)
{
packTimeRest[p.Key][0]--;
if (packTimeRest[p.Key][0] <= 0)
{
nd.Add(p.Key);
}
}
foreach (var p in nd)
{
packTimeRest.Remove(p);
packDic.Remove(p);
}
if (!packetWrapper.tcpPacket.Psh)
{
return;
}
byte[] data = CombinePacket(ackn);
if (data == null)
{
return;
}
string s = Encoding.UTF8.GetString(data);
int index = s.IndexOf("\r\n\r\n");
if (index < 0)
{
return;
}
index += 4;
string header = s.Substring(0, index);
if (!HttpCheck(header))
{
return;
}
onNewHttpAdd?.Invoke(s);
if (!LLHttpCheck(header))
{
return;
}
Console.WriteLine("datalen" + data.Length);
string body = s.Substring(index);
if (body.Length < 10)
{
return;
}
if (header.IndexOf("POST") == 0)
{
int lk = body.IndexOf("{");
int rk = body.LastIndexOf("}");
body = body.Substring(lk, rk - lk + 1);
string sj = Utils.FormatJsonString(body);
onNewHttpLLAdd?.Invoke(header + "\r\n\r\n\r\n" + sj);
onNewJsonAdd?.Invoke(sj);
return;
}
byte[] bodyBytes = null;
for (int i = 0; i < data.Length - 1; i++)
{
if (data[i] == 13 && data[i + 2] == 13 && data[i + 1] == 10 && data[i + 3] == 10)
{
i += 4;
bodyBytes = new byte[data.Length - i];
for (int t = 0; t < bodyBytes.Length; t++, i++)
{
bodyBytes[t] = data[i];
}
break;
}
}
if (bodyBytes == null)
{
return;
}
byte[] bodyUncompressedBytes = Utils.Decompress(bodyBytes);
if (bodyUncompressedBytes == null)
{
return;
}
string json = Encoding.UTF8.GetString(bodyUncompressedBytes);
if (!json.Contains("{"))
{
return;
}
json = Utils.Unicode2String(json);
json = Utils.FormatJsonString(json);
onNewHttpLLAdd?.Invoke(header + "\r\n\r\n\r\n" + json);
onNewJsonAdd?.Invoke(json);
}
/// <summary>
/// Checks for queued packets. If any exist it locks the QueueLock, saves a
/// reference of the current queue for itself, puts a new queue back into
/// place into PacketQueue and unlocks QueueLock. This is a minimal amount of
/// work done while the queue is locked.
///
/// The background thread can then process queue that it saved without holding
/// the queue lock.
/// </summary>
private void BackgroundThread()
{
while (!BackgroundThreadStop)
{
bool shouldSleep = true;
lock (QueueLock)
{
if (PacketQueue.Count != 0)
{
shouldSleep = false;
}
}
if (shouldSleep)
{
System.Threading.Thread.Sleep(250);
}
else // should process the queue
{
List <RawCapture> ourQueue;
lock (QueueLock)
{
// swap queues, giving the capture callback a new one
ourQueue = PacketQueue;
PacketQueue = new List <RawCapture>();
}
Console.WriteLine("BackgroundThread: ourQueue.Count is {0}", ourQueue.Count);
foreach (RawCapture packet in ourQueue)
{
// Here is where we can process our packets freely without
// holding off packet capture.
//
// NOTE: If the incoming packet rate is greater than
// the packet processing rate these queues will grow
// to enormous sizes. Packets should be dropped in these
// cases
try
{
PacketWrapper packetWrapper = new PacketWrapper(packetCount, packet);
Packet parsepacket = PacketDotNet.Packet.ParsePacket(packet.LinkLayerType, packet.Data);
TcpPacket tcpPacket = (PacketDotNet.TcpPacket)parsepacket.Extract(typeof(PacketDotNet.TcpPacket));
if (tcpPacket != null)
{
byte[] packetData = tcpPacket.PayloadData;
if (packetData != null)
{
ProcessPackets(packetData);
}
packetCount++;
DateTime time = packet.Timeval.Date;
int len = packet.Data.Length;
//Console.WriteLine("BackgroundThread: {0}:{1}:{2},{3} Len={4}",
// time.Hour, time.Minute, time.Second, time.Millisecond, len);
}
if (statisticsUiNeedsUpdate)
{
UpdateCaptureStatistics();
statisticsUiNeedsUpdate = false;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
throw;
}
}
//this.BeginInvoke(new MethodInvoker(delegate
//{
// //bs.DataSource = packetQue.Reverse();
//}
//));
}
}
}
internal void HandleSecMsg(MIMCUser user, V6Packet feV6Packet)
{
if (feV6Packet == null || feV6Packet.Body.Payload == null || feV6Packet.Body.Payload.Length == 0)
{
logger.WarnFormat("HandleSecMsg fail, invalid packet");
return;
}
MIMCPacket packet = null;
using (MemoryStream ms = new MemoryStream(feV6Packet.Body.Payload))
{
packet = Serializer.Deserialize <MIMCPacket>(ms);
}
if (packet == null)
{
logger.WarnFormat("{0} HandleSecMsg fail, parse MIMCPacket fail", user.AppAccount);
return;
}
logger.InfoFormat("HandleSecMsg, type:{0} , uuid:{1}, packetId:{2}, chid:{3}",
packet.type, user.Uuid, packet.packetId, user.Chid);
if (packet.type == MIMC_MSG_TYPE.PACKET_ACK)
{
logger.DebugFormat("{0} <--- receive PACKET_ACK :{1}", user.AppAccount, packet.packetId);
MIMCPacketAck packetAck = null;
using (MemoryStream ackStream = new MemoryStream(packet.payload))
{
packetAck = Serializer.Deserialize <MIMCPacketAck>(ackStream);
}
if (packetAck == null)
{
logger.WarnFormat("{0} HandleSecMsg parse MIMCPacketAck fail", user.AppAccount);
return;
}
user.HandleServerACK(new ServerAck(packetAck.packetId, packetAck.sequence, packetAck.timestamp, packetAck.code, packetAck.errorMsg));
logger.DebugFormat("{0} HandleSecMsg MIMCPacketAck packetId:{1}, msg：{2}", user.AppAccount, packetAck.packetId, packetAck.errorMsg);
logger.DebugFormat("{0} HandleSecMsg timeoutPackets TimeoutPackets before size :{1}", user.AppAccount, user.TimeoutPackets.Count);
TimeoutPacket timeoutPacket = new TimeoutPacket(packet, MIMCUtil.CurrentTimeMillis());
if (user.TimeoutPackets.TryRemove(packetAck.packetId, out timeoutPacket))
{
logger.DebugFormat("{0} HandleSecMsg timeoutPackets TryRemove sucess,packetId:{1}", user.AppAccount, packetAck.packetId);
}
else
{
logger.WarnFormat("{0} HandleSecMsg timeoutPackets TryRemove fail,packetId:{1}", user.AppAccount, packetAck.packetId);
}
logger.DebugFormat("{0} HandleSecMsg timeoutPackets TimeoutPackets after size :{1}", user.AppAccount, user.TimeoutPackets.Count);
return;
}
if (packet.type == MIMC_MSG_TYPE.UC_PACKET)
{
logger.DebugFormat(" UC_PACKET packetId:{0}", packet.packetId);
UCPacket ucPacket = null;
using (MemoryStream ucStream = new MemoryStream(packet.payload))
{
ucPacket = Serializer.Deserialize <UCPacket>(ucStream);
}
if (ucPacket == null)
{
logger.WarnFormat("HandleSecMsg p2tMessage is null");
}
logger.DebugFormat("UC_PACKET UC_MSG_TYPE：{0}", ucPacket.type);
if (ucPacket.type == UC_MSG_TYPE.MESSAGE_LIST)
{
UCMessageList messageList = null;
using (MemoryStream stream = new MemoryStream(ucPacket.payload))
{
messageList = Serializer.Deserialize <UCMessageList>(stream);
}
if (messageList == null || messageList.message.Count == 0 || messageList.message == null)
{
logger.WarnFormat("HandleUnlimitedGroupMessage messageList is null");
return;
}
List <P2UMessage> p2uMessagesList = new List <P2UMessage>();
foreach (UCMessage ucMessage in messageList.message)
{
logger.DebugFormat("HandleSecMsg UC_MSG_TYPE.MESSAGE_LIST：{0},size:{1}", ucPacket.type, messageList.message.Count);
p2uMessagesList.Add(new P2UMessage(ucMessage.packetId, ucMessage.sequence,
ucMessage.user.appAccount, ucMessage.user.resource,
(long)ucMessage.group.topicId, ucMessage.payload, ucMessage.bizType, ucMessage.timestamp));
continue;
}
if (p2uMessagesList.Count > 0)
{
user.HandleUnlimitedGroupMessage(p2uMessagesList, messageList.group, messageList.maxSequence);
}
}
if (ucPacket.type == UC_MSG_TYPE.JOIN_RESP)
{
logger.DebugFormat("HandleJoinUnlimitedGroup UC_MSG_TYPE.JOIN_RESP：{0}", ucPacket.type);
user.HandleJoinUnlimitedGroup(ucPacket);
}
if (ucPacket.type == UC_MSG_TYPE.QUIT_RESP)
{
logger.DebugFormat("HandleQuitUnlimitedGroup UC_MSG_TYPE.QUIT_RESP：{0}", ucPacket.type);
user.HandleQuitUnlimitedGroup(ucPacket);
}
if (ucPacket.type == UC_MSG_TYPE.DISMISS)
{
UCDismiss ucDismiss = null;
using (MemoryStream ucStream = new MemoryStream(ucPacket.payload))
{
ucDismiss = Serializer.Deserialize <UCDismiss>(ucStream);
}
logger.DebugFormat("HandleDismissUnlimitedGroup UC_MSG_TYPE.DISMISS：{0}", ucPacket.type);
user.HandleDismissUnlimitedGroup(new DismissUnlimitedGroupEventArgs(ucDismiss.group.topicId));
}
else if (ucPacket.type == UC_MSG_TYPE.PONG)
{
logger.DebugFormat("HandleSecMsg UC_MSG_TYPE.PONG：{0}", ucPacket.type);
}
}
if (packet.type == MIMC_MSG_TYPE.COMPOUND)
{
MIMCPacketList packetList = null;
using (MemoryStream comStream = new MemoryStream(packet.payload))
{
packetList = Serializer.Deserialize <MIMCPacketList>(comStream);
}
if (packetList == null || packetList.packets.ToArray().Length == 0)
{
logger.WarnFormat("HandleSecMsg parse MIMCPacketList fail ,packetList:{0}, packetList.packets.ToArray().Length:{1}", packetList, packetList.packets.ToArray().Length);
return;
}
logger.DebugFormat("HandleSecMsg MIMCPacketList resource:{0}", user.Resource);
if (user.Resource != packetList.resource)
{
logger.WarnFormat("HandleSecMsg MIMCPacketList parse fail,resource not match,{0}!={1}", user.Resource, packetList.resource);
return;
}
V6Packet mimcSequenceAckPacket = MIMCUtil.BuildSequenceAckPacket(user, packetList);
PacketWrapper packetWrapper = new PacketWrapper(Constant.MIMC_C2S_SINGLE_DIRECTION, mimcSequenceAckPacket);
user.Connection.PacketWaitToSend.Enqueue(packetWrapper);
int packetListNum = packetList.packets.Count;
List <P2PMessage> p2pMessagesList = new List <P2PMessage>();
List <P2TMessage> p2tMessagesList = new List <P2TMessage>();
logger.DebugFormat("{0} HandleSecMsg MIMCPacketList packetListNum:{1}", user.AppAccount, packetListNum);
foreach (MIMCPacket p in packetList.packets)
{
if (p == null)
{
logger.WarnFormat("{0} HandleSecMsg packet is null", user.AppAccount);
continue;
}
logger.DebugFormat("HandleSecMsg MIMC_MSG_TYPE:{0}", p.type);
if (p.type == MIMC_MSG_TYPE.P2P_MESSAGE)
{
logger.DebugFormat("HandleSecMsg P2P_MESSAGE packetId:{0}", p.packetId);
MIMCP2PMessage p2pMessage = null;
using (MemoryStream p2pStream = new MemoryStream(p.payload))
{
p2pMessage = Serializer.Deserialize <MIMCP2PMessage>(p2pStream);
}
if (p2pMessage == null)
{
logger.WarnFormat("HandleSecMsg p2pMessage is null");
continue;
}
p2pMessagesList.Add(new P2PMessage(p.packetId, p.sequence,
p2pMessage.from.appAccount, p2pMessage.from.resource,
p2pMessage.to.appAccount, p2pMessage.to.resource, p2pMessage.payload, p2pMessage.bizType, p.timestamp));
logger.DebugFormat("HandleSecMsg P2P_MESSAGE packetId:{0}", p2pMessagesList[0]);
continue;
}
if (p.type == MIMC_MSG_TYPE.P2T_MESSAGE)
{
logger.DebugFormat("HandleSecMsg P2T_MESSAGE packetId:{0}", p.packetId);
MIMCP2TMessage p2tMessage = null;
using (MemoryStream p2tStream = new MemoryStream(p.payload))
{
p2tMessage = Serializer.Deserialize <MIMCP2TMessage>(p2tStream);
}
if (p2tMessage == null)
{
logger.WarnFormat("HandleSecMsg p2tMessage is null");
continue;
}
p2tMessagesList.Add(new P2TMessage(p.packetId, p.sequence,
p2tMessage.from.appAccount, p2tMessage.from.resource,
(long)p2tMessage.to.topicId, p2tMessage.payload, p2tMessage.bizType, p.timestamp));
continue;
}
logger.WarnFormat("HandleSecMsg RECV_MIMC_PACKET ,invalid type, Type：{0}", p.type);
}
if (p2pMessagesList.Count > 0)
{
user.HandleMessage(p2pMessagesList);
}
if (p2tMessagesList.Count > 0)
{
user.HandleGroupMessage(p2tMessagesList);
}
}
}
