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