public static V6Packet BuildConnectionPacket(MIMCUser user)
{
logger.DebugFormat("{0} User BuildConnectionPacket", user.AppAccount);
V6Packet v6Packet = new V6Packet();
V6Body v6Body = new V6Body();
XMMsgConn xMMsgConn = new XMMsgConn();
xMMsgConn.os = "macOS";
xMMsgConn.udid = user.Connection.Udid;
xMMsgConn.version = Constant.CONN_BIN_PROTO_VERSION;
ClientHeader clientHeader = MIMCUtil.CreateClientHeader(user, Constant.CMD_CONN, Constant.CIPHER_NONE, MIMCUtil.CreateMsgId(user));
v6Body.PayloadType = Constant.PAYLOAD_TYPE;
v6Body.ClientHeader = clientHeader;
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, xMMsgConn);
byte[] payload = ms.ToArray();
v6Body.Payload = payload;
v6Packet.Body = v6Body;
}
return(v6Packet);
}
public MIMCDemo()
{
user5566 = new MIMCUser(appAccount1);
user5566.RegisterMIMCTokenFetcher(new MIMCCaseTokenFetcher(appId, appKey, appSecret, url, appAccount1));
user5566.stateChangeEvent += HandleStatusChange;
user5566.messageEvent += HandleMessage;
user5566.messageTimeOutEvent += HandleMessageTimeout;
user5566.groupMessageEvent += HandleGroupMessage;
user5566.groupMessageTimeoutEvent += HandleGroupMessageTimeout;
user5566.serverACKEvent += HandleServerACK;
user5566.unlimitedGroupMessageEvent += HandleUnlimitedGroupMessage;
user5566.unlimitedGroupMessageTimeoutEvent += HandleUnlimitedGroupMessageTimeout;
user5566.joinUnlimitedGroupEvent += HandleJoinUnlimitedGroup;
user5566.quitUnlimitedGroupEvent += HandleQuitUnlimitedGroup;
user5566.dismissUnlimitedGroupEvent += HandleDismissUnlimitedGroup;
user9527 = new MIMCUser(appAccount2);
user9527.RegisterMIMCTokenFetcher(new MIMCCaseTokenFetcher(appId, appKey, appSecret, url, appAccount2));
user9527.stateChangeEvent += HandleStatusChange;
user9527.messageEvent += HandleMessage;
user9527.messageTimeOutEvent += HandleMessageTimeout;
user9527.groupMessageEvent += HandleGroupMessage;
user9527.groupMessageTimeoutEvent += HandleGroupMessageTimeout;
user9527.serverACKEvent += HandleServerACK;
user9527.unlimitedGroupMessageEvent += HandleUnlimitedGroupMessage;
user9527.unlimitedGroupMessageTimeoutEvent += HandleUnlimitedGroupMessageTimeout;
user9527.joinUnlimitedGroupEvent += HandleJoinUnlimitedGroup;
user9527.quitUnlimitedGroupEvent += HandleQuitUnlimitedGroup;
user9527.dismissUnlimitedGroupEvent += HandleDismissUnlimitedGroup;
}
public static byte[] Encode(MIMCConnection connection, V6Packet v6Packet)
{
if (connection == null || v6Packet == null)
{
logger.WarnFormat("V6PacketEncoder encode fail! connection:{0},v6Packet:{1} ", connection, v6Packet);
return(null);
}
MIMCUser user = connection.User;
if (v6Packet.Body != null && Constant.CMD_SECMSG == v6Packet.Body.ClientHeader.cmd)
{
if (null == user)
{
logger.WarnFormat("V6PacketEncoder encode fail! user is null");
return(null);
}
byte[] payloadKey = RC4Cryption.GenerateKeyForRC4(user.SecurityKey, v6Packet.Body.ClientHeader.id);
return(v6Packet.ToByteArray(connection.Rc4Key, payloadKey, user));
}
else
{
byte[] v6Bins = v6Packet.ToByteArray(connection.Rc4Key, null, user);
return(v6Bins);
}
}
public MIMCDemo()
{
leijun = new MIMCUser(appAccount1);
leijun.RegisterMIMCTokenFetcher(new MIMCCaseTokenFetcher(appId, appKey, appSecret, url, appAccount1));
leijun.stateChangeEvent += HandleStatusChange;
leijun.messageEvent += HandleMessage;
leijun.messageTimeOutEvent += HandleMessageTimeout;
leijun.groupMessageEvent += HandleGroupMessage;
leijun.groupMessageTimeoutEvent += HandleGroupMessageTimeout;
leijun.serverACKEvent += HandleServerACK;
leijun.unlimitedGroupMessageEvent += HandleUnlimitedGroupMessage;
leijun.unlimitedGroupMessageTimeoutEvent += HandleUnlimitedGroupMessageTimeout;
leijun.joinUnlimitedGroupEvent += HandleJoinUnlimitedGroup;
leijun.quitUnlimitedGroupEvent += HandleQuitUnlimitedGroup;
leijun.dismissUnlimitedGroupEvent += HandleDismissUnlimitedGroup;
linbin = new MIMCUser(appAccount2);
linbin.RegisterMIMCTokenFetcher(new MIMCCaseTokenFetcher(appId, appKey, appSecret, url, appAccount2));
linbin.stateChangeEvent += HandleStatusChange;
linbin.messageEvent += HandleMessage;
linbin.messageTimeOutEvent += HandleMessageTimeout;
linbin.groupMessageEvent += HandleGroupMessage;
linbin.groupMessageTimeoutEvent += HandleGroupMessageTimeout;
linbin.serverACKEvent += HandleServerACK;
linbin.unlimitedGroupMessageEvent += HandleUnlimitedGroupMessage;
linbin.unlimitedGroupMessageTimeoutEvent += HandleUnlimitedGroupMessageTimeout;
linbin.joinUnlimitedGroupEvent += HandleJoinUnlimitedGroup;
linbin.quitUnlimitedGroupEvent += HandleQuitUnlimitedGroup;
linbin.dismissUnlimitedGroupEvent += HandleDismissUnlimitedGroup;
}
public StateChangeEventArgs(MIMCUser user, bool isOnline, string errType, string errReason, string errDescription)
{
this.user = user;
this.isOnline = isOnline;
this.errType = errType;
this.errReason = errReason;
this.errDescription = errDescription;
}
public byte[] ToByteArray(byte[] v6bodyKey, byte[] payloadKey, MIMCUser user)
{
//Ping packet
if (v6BodyBin == null && Body == null)
{
ByteBuffer v6PingByteBuffer = ByteBuffer.Allocate(Constant.V6_HEAD_LENGTH + Constant.CRC_LEN);
v6PingByteBuffer.putChar(Constant.MAGIC);
v6PingByteBuffer.putChar(Constant.V6_VERSION);
v6PingByteBuffer.putInt(0);
uint pingcrc = Adler32.checkCRC(v6PingByteBuffer.ToArray(), 0, Constant.V6_HEAD_LENGTH);
v6PingByteBuffer.putUint(pingcrc);
logger.InfoFormat("---> send v6 packet Ping appAccount:{0}", user.AppAccount);
return(v6PingByteBuffer.ToArray());
}
ByteBuffer bodyBuffer = null;
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, Body.ClientHeader);
byte[] clientHeaderBins = ms.ToArray();
short clientHeaderLen = (short)clientHeaderBins.Length;
int payloadLen = (Body.Payload == null || Body.Payload.Length == 0) ? 0 : Body.Payload.Length;
bodyBuffer = ByteBuffer.Allocate(Constant.V6_BODY_HEADER_LENGTH + clientHeaderLen + payloadLen);
bodyBuffer.putShort(Constant.PAYLOAD_TYPE);
bodyBuffer.putShort(clientHeaderLen);
bodyBuffer.putInt(payloadLen);
bodyBuffer.putBytes(clientHeaderBins);
}
if (Body.Payload != null)
{
bodyBuffer.putBytes(payloadKey != null ? RC4Cryption.DoEncrypt(payloadKey, Body.Payload) : Body.Payload);
}
v6BodyBin = bodyBuffer.ToArray();
int v6BodyLen = (v6BodyBin == null || v6BodyBin.Length == 0) ? 0 : v6BodyBin.Length;
if (!Constant.CMD_CONN.ToUpper().Equals(Body.ClientHeader.cmd.ToUpper()))
{
v6BodyBin = RC4Cryption.DoEncrypt(v6bodyKey, v6BodyBin);
}
ByteBuffer v6ByteBuffer = ByteBuffer.Allocate(Constant.V6_HEAD_LENGTH + v6BodyLen + Constant.CRC_LEN);
v6ByteBuffer.putChar(Constant.MAGIC);
v6ByteBuffer.putChar(Constant.V6_VERSION);
v6ByteBuffer.putInt(v6BodyLen);
v6ByteBuffer.putBytes(v6BodyBin);
uint crc = Adler32.checkCRC(v6ByteBuffer.ToArray(), 0, Constant.V6_HEAD_LENGTH + v6BodyLen);
v6ByteBuffer.putUint(crc);
logger.InfoFormat("---> send v6 packet cmd:{0},appAccount:{1}", Body.ClientHeader.cmd, user.AppAccount);
return(v6ByteBuffer.ToArray());
}
public static V6Packet BuildUnBindPacket(MIMCUser user)
{
logger.DebugFormat("{0} User BuildUnBindPacket", user.AppAccount);
ClientHeader clientHeader = MIMCUtil.CreateClientHeader(user, Constant.CMD_UNBIND, Constant.CIPHER_NONE, MIMCUtil.CreateMsgId(user));
V6Packet v6Packet = new V6Packet();
V6Body v6Body = new V6Body();
v6Body.PayloadType = Constant.PAYLOAD_TYPE;
v6Body.ClientHeader = clientHeader;
v6Packet.Body = v6Body;
return(v6Packet);
}
public static ClientHeader CreateClientHeader(MIMCUser user, String cmd, int cipher, String msgId)
{
logger.DebugFormat("{0} CreateClientHeader cmd:{1},msgId:{2}", user.AppAccount, cmd, msgId);
ClientHeader clientHeader = new ClientHeader();
clientHeader.id = msgId;
clientHeader.uuid = (long)user.Uuid;
clientHeader.chid = Constant.MIMC_CHID;
clientHeader.resource = user.Resource;
clientHeader.cmd = cmd;
clientHeader.server = Constant.SERVER;
clientHeader.cipher = cipher;
clientHeader.dir_flag = ClientHeader.MSG_DIR_FLAG.CS_REQ;
return(clientHeader);
}
public static V6Packet BuildSecMsgPacket(MIMCUser user, string packetId, byte[] packetBin)
{
logger.DebugFormat("{0} User BuildSecMsgPacket", user.AppAccount);
ClientHeader clientHeader = MIMCUtil.CreateClientHeader(user, Constant.CMD_SECMSG, Constant.CIPHER_RC4, packetId);
V6Packet v6Packet = new V6Packet();
V6Body v6Body = new V6Body();
v6Body.PayloadType = Constant.PAYLOAD_TYPE;
v6Body.ClientHeader = clientHeader;
v6Body.Payload = packetBin;
v6Packet.Body = v6Body;
return(v6Packet);
}
public static V6Packet BuildBindPacket(MIMCUser user)
{
if (string.IsNullOrEmpty(user.Token))
{
logger.DebugFormat("{0} User BuildBindPacket fail Token is null,wait ...", user.AppAccount);
return(null);
}
logger.DebugFormat("{0} User BuildBindPacket", user.AppAccount);
ClientHeader clientHeader = MIMCUtil.CreateClientHeader(user, Constant.CMD_BIND, Constant.CIPHER_NONE, MIMCUtil.CreateMsgId(user));
XMMsgBind xMMsgBind = new XMMsgBind();
xMMsgBind.token = user.Token;
xMMsgBind.method = Constant.METHOD;
xMMsgBind.client_attrs = user.ClientAttrs;
xMMsgBind.cloud_attrs = user.CloudAttrs;
xMMsgBind.kick = Constant.NO_KICK;
string sign = MIMCUtil.GenerateSig(clientHeader, xMMsgBind, user.Connection.Challenge, user.SecurityKey);
if (String.IsNullOrEmpty(sign))
{
logger.WarnFormat("GenerateSig fail sign is null");
return(null);
}
xMMsgBind.sig = sign;
V6Packet v6Packet = new V6Packet();
V6Body v6Body = new V6Body();
v6Body.PayloadType = Constant.PAYLOAD_TYPE;
v6Body.ClientHeader = clientHeader;
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, xMMsgBind);
byte[] payload = ms.ToArray();
v6Body.Payload = payload;
v6Packet.Body = v6Body;
}
return(v6Packet);
}
public static V6Packet BuildSequenceAckPacket(MIMCUser user, MIMCPacketList packetList)
{
logger.DebugFormat("{0} User BuildSequenceAckPacket", user.AppAccount);
MIMCPacket packet = new MIMCPacket();
packet.packetId = MIMCUtil.CreateMsgId(user);
packet.package = user.AppPackage;
packet.type = MIMC_MSG_TYPE.SEQUENCE_ACK;
MIMCSequenceAck sequenceAck = new MIMCSequenceAck();
sequenceAck.uuid = packetList.uuid;
sequenceAck.resource = packetList.resource;
sequenceAck.sequence = packetList.maxSequence;
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, sequenceAck);
byte[] sequenceAckBin = ms.ToArray();
packet.payload = sequenceAckBin;
}
byte[] mimcBins = null;
using (MemoryStream mimcStream = new MemoryStream())
{
Serializer.Serialize(mimcStream, packet);
mimcBins = mimcStream.ToArray();
}
ClientHeader clientHeader = MIMCUtil.CreateClientHeader(user, Constant.CMD_SECMSG, Constant.CIPHER_RC4, packet.packetId);
V6Packet v6Packet = new V6Packet();
V6Body v6Body = new V6Body();
v6Body.PayloadType = Constant.PAYLOAD_TYPE;
v6Body.ClientHeader = clientHeader;
v6Body.Payload = mimcBins;
v6Packet.Body = v6Body;
return(v6Packet);
}
public static V6Packet DecodeV6(byte[] v6HeaderBins, byte[] v6BodyBins, byte[] crcBins, byte[] bodyKey, MIMCUser user)
{
byte[] v6Bins = new byte[v6HeaderBins.Length + v6BodyBins.Length + crcBins.Length];
//logger.DebugFormat("decodeV6 ============== v6BodyBins.Length:{0}", v6BodyBins.Length);
v6HeaderBins.CopyTo(v6Bins, 0);
v6BodyBins.CopyTo(v6Bins, v6HeaderBins.Length);
crcBins.CopyTo(v6Bins, v6HeaderBins.Length + v6BodyBins.Length);
//logger.DebugFormat("decodeV6 ============== data v6HeaderBins :{0}", BitConverter.ToString(v6HeaderBins));
//logger.DebugFormat("decodeV6 ============== data v6BodyBins:{0}", BitConverter.ToString(v6BodyBins));
//logger.DebugFormat("decodeV6 ============== data crcBins:{0}", BitConverter.ToString(crcBins));
//logger.DebugFormat("decodeV6 ============== data v6Bins:{0}", BitConverter.ToString(v6Bins));
uint fecrc = GetUint(crcBins, 0);
uint crc = Adler32.checkCRC(v6Bins, 0, v6Bins.Length - 4);
if (fecrc != crc)
{
logger.WarnFormat("decodeV6, INVALID_CRC, {0}!={1}", fecrc, crc);
return(null);
}
V6Packet v6Packet = new V6Packet();
v6Packet.Magic = V6PacketDecoder.GetChar(v6HeaderBins, 0);
v6Packet.Version = V6PacketDecoder.GetChar(v6HeaderBins, 2);
v6Packet.PacketLen = (int)V6PacketDecoder.GetUint(v6HeaderBins, 4);
if (v6Packet.PacketLen == 0)
{
return(v6Packet);
}
if (bodyKey != null && bodyKey.Length > 0 && v6BodyBins != null && v6BodyBins.Length > 0)
{
v6BodyBins = RC4Cryption.DoEncrypt(bodyKey, v6BodyBins);
}
v6Packet.PacketLen = v6BodyBins == null ? 0 : v6BodyBins.Length;
short payloadType = GetShort(v6BodyBins, 0);
short clientHeaderLen = GetShort(v6BodyBins, 2);
uint v6PayloadLen = GetUint(v6BodyBins, 4);
if (payloadType != Constant.PAYLOAD_TYPE || clientHeaderLen < 0 || v6PayloadLen < 0)
{
logger.WarnFormat("decodeV6, INVALID_HEADER, payloadType:{0}, clientHeaderLen:{1}, v6PayloadLen:{2}",
payloadType, clientHeaderLen, v6PayloadLen);
return(null);
}
byte[] clientHeaderBins = new byte[clientHeaderLen];
Array.Copy(v6BodyBins, Constant.V6_BODY_HEADER_LENGTH, clientHeaderBins, 0, clientHeaderLen);
byte[] v6PayloadBins = new byte[v6PayloadLen];
Array.Copy(v6BodyBins, Constant.V6_BODY_HEADER_LENGTH + clientHeaderLen, v6PayloadBins, 0, v6PayloadLen);
ClientHeader clientHeader = null;
using (MemoryStream ms = new MemoryStream(clientHeaderBins))
{
clientHeader = Serializer.Deserialize <ClientHeader>(ms);
}
//logger.InfoFormat("receive v6 packet cmd:{0}, user:{1}", clientHeader.cmd, user.AppAccount());
if (Constant.CMD_SECMSG == clientHeader.cmd)
{
byte[] payloadKey = RC4Cryption.GenerateKeyForRC4(user.SecurityKey, clientHeader.id);
v6PayloadBins = RC4Cryption.DoEncrypt(payloadKey, v6PayloadBins);
}
v6Packet.V6BodyBin = v6BodyBins;
V6Packet.V6Body v6Body = new V6Packet.V6Body();
v6Body.PayloadType = payloadType;
v6Body.ClientHeaderLen = clientHeaderLen;
v6Body.PayloadLen = (int)v6PayloadLen;
v6Body.ClientHeader = clientHeader;
v6Body.Payload = v6PayloadBins;
v6Packet.Body = v6Body;
return(v6Packet);
}
public ServerACKEventArgs(MIMCUser user, ServerAck serverAck)
{
this.user = user;
this.serverAck = serverAck;
}
public SendUnlimitedGroupMessageTimeoutEventArgs(MIMCUser user, P2UMessage packet)
{
this.Packet = packet;
}
public QuitUnlimitedGroupEventArgs(MIMCUser user, UCQuitResp packet)
{
this.user = user;
this.packet = packet;
}
public DismissUnlimitedGroupEventArgs(MIMCUser user, UCPacket packet)
{
this.user = user;
this.packet = packet;
}
public QueryUnlimitedGroupsThread(MIMCUser user)
{
this.user = user;
thread = new Thread(new ThreadStart(run));
}
public JoinUnlimitedGroupEventArgs(MIMCUser user, UCJoinResp packet)
{
this.user = user;
this.packet = packet;
}
public MessageEventArgs(MIMCUser user, List <P2PMessage> packets)
{
this.user = user;
this.packets = packets;
}
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.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;
}
List <P2UMessage> p2uMessagesList = new List <P2UMessage>();
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;
}
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, null,
ucMessage.group.topicId, ucMessage.payload, 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)
{
logger.DebugFormat("HandleDismissUnlimitedGroup UC_MSG_TYPE.DISMISS：{0}", ucPacket.type);
user.HandleDismissUnlimitedGroup(ucPacket);
}
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);
MIMCObject miObj = new MIMCObject();
miObj.Type = Constant.MIMC_C2S_SINGLE_DIRECTION;
miObj.Packet = mimcSequenceAckPacket;
user.Connection.PacketWaitToSend.Enqueue(miObj);
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.payload, 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,
p2tMessage.to.topicId, p2tMessage.payload, 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);
}
}
}
public SendMessageTimeoutEventArgs(MIMCUser user, P2PMessage p2PMessage)
{
this.user = user;
this.p2PMessage = p2PMessage;
}
public UnlimitedGroupMessageEventArgs(MIMCUser user, List <P2UMessage> p2uMessagesList)
{
this.user = user ?? throw new ArgumentNullException(nameof(user));
this.p2uMessagesList = p2uMessagesList ?? throw new ArgumentNullException(nameof(p2uMessagesList));
}
public static string CreateMsgId(MIMCUser user)
{
return(MIMCUtil.GetRandomString(15, true, true, false, false, null) + "-" + user.Atomic.IncrementAndGet());
}
public SendGroupMessageTimeoutEventArgs(MIMCUser user, P2TMessage p2tMessage)
{
this.user = user;
this.p2tMessage = p2tMessage;
}
