public virtual void ProcessPacketStream(SocketStateObject state, PacketIdentifier packetId, DataStream packetStream) { if (Handler.Contains(packetId) || CompleteHandler.Contains(packetId)) { GamePacket packet; if (!PacketsRegistry.TryGetPacket(packetId, out packet)) { packet = new BasePacket(); } packet.Deserialize(packetStream); var args = Handler.HandlePacket(packetId, packet); if (args == null || !args.Cancel) { if (args == null) { Send(state, packetId.PacketId, packetStream.Reset()); } else { Send(state, packetId, packet); } CompleteHandler.HandlePacket(packetId, packet); } } else { Send(state, packetId.PacketId, packetStream); } }
/// <summary> /// Builds a packet from the incoming buffer + offset. If a packet can be built, it is returned else null. /// </summary> /// <param name="offset">Current offset in buffer.</param> /// <param name="buffer">Incoming buffer.</param> /// <returns>Returns either a BasePacket or null if not enough data.</returns> public BasePacket BuildPacket(ref int offset, byte[] buffer, int bytesRead) { BasePacket newPacket = null; //Too small to even get length if (bytesRead <= offset) { return(null); } ushort packetSize = BitConverter.ToUInt16(buffer, offset); //Too small to whole packet if (bytesRead < offset + packetSize) { return(null); } if (buffer.Length < offset + packetSize) { return(null); } try { newPacket = new BasePacket(buffer, ref offset); } catch (OverflowException) { return(null); } return(newPacket); }
private void PacketReceiver_OnDataInvoke(ulong Id, BasePacket basePacket) { if (basePacket.packetType == PacketType.ConnectionStat) { ConnectionPacket cp = (ConnectionPacket)basePacket; if (cp.IsConnecting == true) { PrintStatusLabel("Connected"); SceneManager.LoadScene("MainScene", LoadSceneMode.Single); } else { if (cp.HasError == true) { socketClient.ErrorStop(); PrintStatusLabel("Already Connected"); } else { socketClient.Stop(); SceneManager.LoadScene("ConnectScene", LoadSceneMode.Single); } } } OnDataInvoke?.Invoke(basePacket); }
/// <summary> /// Receives bytes from the ByteReceivedQueue and deserializes them into packets for later processing. /// </summary> public void Receive() { while (ByteReceivedQueue.Count > 0) { // If there is not enough data left to read the size of the next packet, do other game updates if (ByteReceivedQueue.Count < PacketUtil.PACK_HEAD_SIZE) { break; } // Get packet size byte[] headerByteBuf = ByteReceivedQueue.GetRange(0, PacketUtil.PACK_HEAD_SIZE).ToArray(); int packetSize = BitConverter.ToInt32(headerByteBuf, 1); // If there is not enough data left to read the next packet, do other game updates if (ByteReceivedQueue.Count < packetSize + PacketUtil.PACK_HEAD_SIZE) { break; } // Get full packet and add it to the queue byte[] packetData = ByteReceivedQueue.GetRange(PacketUtil.PACK_HEAD_SIZE, packetSize).ToArray(); byte[] fullPacket = headerByteBuf.Concat(packetData).ToArray(); BasePacket packet = PacketUtil.Deserialize(fullPacket); PacketQueue.Add(packet); // Remove the read data lock (ByteReceivedQueue) { ByteReceivedQueue.RemoveRange(0, packetSize + PacketUtil.PACK_HEAD_SIZE); } } }
internal static void TestProtoPacketsPerf() { short psize; PUserLogin p = new PUserLogin { UserName = "******", Password = "******" }; p.Setup(); byte[] ps = p.Serialize(); BasePacket.Deserialize(ps, ps.Length, 0, out psize); HRTimer timer = HRTimer.CreateAndStart(); Parallel.For(0, ITERATIONS_COUNT, i => // for (int i = 0; i < ITERATIONS_COUNT; i++) { p.Setup(); ps = p.Serialize(); BasePacket.Deserialize(ps, ps.Length, 0, out psize); }); // } System.Console.WriteLine(timer.StopWatch()); }
public override BasePacket getInitPackets(uint playerActorId) { SetActorPropetyPacket initProperties = new SetActorPropetyPacket("/_init"); initProperties.addTarget(); return(BasePacket.createPacket(initProperties.buildPacket(playerActorId, actorId), true, false)); }
public void Validate(BasePacket packet) { Parallel.ForEach(this, v => { v.Validate(packet); }); }
public void Send(BasePacket packet) { lock (packetLock) { outgoingPackets.Enqueue(packet); } }
private void doWeather(ConnectedPlayer client, string weatherID, string value) { ushort weather = Convert.ToUInt16(weatherID); if (client != null) { client.queuePacket(BasePacket.createPacket(SetWeatherPacket.buildPacket(client.actorID, weather, Convert.ToUInt16(value)), true, false)); } /* * WIP: Change weather serverside, currently only clientside * * uint currentZoneID; * if (client != null) * { * currentZoneID = client.getActor().zoneId; * * foreach (KeyValuePair<uint, ConnectedPlayer> entry in mConnectedPlayerList) * { * // Change the weather for everyone in the same zone * if (currentZoneID == entry.Value.getActor().zoneId) * { * BasePacket weatherPacket = BasePacket.createPacket(SetWeatherPacket.buildPacket(entry.Value.actorID, weather), true, false); * entry.Value.queuePacket(weatherPacket); * } * } * } */ }
public void doMusic(ConnectedPlayer client, string music) { ushort musicId; if (music.ToLower().StartsWith("0x")) { musicId = Convert.ToUInt16(music, 16); } else { musicId = Convert.ToUInt16(music); } if (client != null) { client.queuePacket(BasePacket.createPacket(SetMusicPacket.buildPacket(client.actorID, musicId, 1), true, false)); } else { foreach (KeyValuePair <uint, ConnectedPlayer> entry in mConnectedPlayerList) { BasePacket musicPacket = BasePacket.createPacket(SetMusicPacket.buildPacket(entry.Value.actorID, musicId, 1), true, false); entry.Value.queuePacket(musicPacket); } } }
public void doWarp(ConnectedPlayer client, uint zoneId, string privateArea, byte spawnType, float x, float y, float z, float r) { WorldManager worldManager = Server.GetWorldManager(); if (worldManager.GetZone(zoneId) == null) { if (client != null) { client.queuePacket(BasePacket.createPacket(SendMessagePacket.buildPacket(client.actorID, client.actorID, SendMessagePacket.MESSAGE_TYPE_GENERAL_INFO, "", "Zone does not exist or setting isn't valid."), true, false)); } Log.error("Zone does not exist or setting isn't valid."); } if (client != null) { worldManager.DoZoneChange(client.getActor(), zoneId, privateArea, spawnType, x, y, z, r); } else { foreach (KeyValuePair <uint, ConnectedPlayer> entry in mConnectedPlayerList) { worldManager.DoZoneChange(entry.Value.getActor(), zoneId, privateArea, spawnType, x, y, z, r); } } }
public void ProcessUnloggedIn(BasePacket packet) { var packetType = packet.PacketType; if (packetType == PacketType.LoginCredentials) { LoginCredentials lc = packet as LoginCredentials; //credentialsReceived = true; //SendInitData(this); } else if (packetType == PacketType.LoginClientReady) { LoginClientReady lc = packet as LoginClientReady; loginComplete = true; // signal game server that player has logged in. // Also, all other servers should be signalled. Once we have a real login server, then the gateway will not need to do any of this. } else if (packetType == PacketType.ClientGameInfoResponse) { ClientGameInfoResponse lc = packet as ClientGameInfoResponse; gameId = lc.GameId; } IntrepidSerialize.ReturnToPool(packet); }
private void ProcessServerPacket(BasePacket packet) { switch ((MessageType)packet.MessageType) { case MessageType.Server_Disconnect: OnServerForcedDisconnect(); break; case MessageType.GI_ServerSend_LoadNewGame: { OnLoadNewGame(packet); break; } case MessageType.GI_ServerSend_GameOver: { OnGameOver(packet); break; } default: { // Let the current scene handle the message if (_currentScene != null) { _currentScene.RecieveServerResponse(packet); } break; } } }
private void ProcessServerResponse() { try { using (_stream) { while (true) { BasePacket packet = Serializer.DeserializeWithLengthPrefix <BasePacket>(_stream, PrefixStyle.Base128); if (packet != null) { ProcessServerPacket(packet); } } } } catch (Exception e) { Console.WriteLine("Error occured: " + e.Message); } finally { CleanUp(); } }
private void ProcessPacket(BasePacket packet) { // first packet doesn't follow the standard structure if (packet is ClientFirstPacket) { ProcessFirstPacket(packet); return; } if (packet.Size == 0u) { ProcessPingPacket(); return; } byte[] payload = packet.Data; if ((packet.Flags & PacketFlag.Encrypted) != 0) { payload = decryptor.Decrypt(payload); } if ((packet.Flags & PacketFlag.Raw) != 0) { ProcessRawPacket(payload); } else { ProcessObjectPacket(payload); } }
// Test to ensure server is recieving the packets and keeping the recieve order public void Test2LoginProcesses() { var tcpH = Server.TcpHandler; _client.Send(new LoginPacket() { Login = "******", Password = "******" }); _client.Send(new LoginPacket() { Login = "******", Password = "******" }); Waiter.WaitUntil(() => Server.PacketsToProccess.Count == 2); // Get the packets that the server recieved, in order and // check if its the correct packets BasePacket packet = null; Server.PacketsToProccess.TryDequeue(out packet); var loginPacket = (LoginPacket)packet; Assert.AreEqual("admin", loginPacket.Login); Assert.AreEqual("wololo", loginPacket.Password); Server.PacketsToProccess.TryDequeue(out packet); loginPacket = (LoginPacket)packet; Assert.AreEqual("admin2", loginPacket.Login); Assert.AreEqual("wololo2", loginPacket.Password); }
public void SendWorldUpdateToAllClients() { List <GameObjectServer> gameObjects = GameServer.instance.GetInteractableObjects(); List <byte> allPackets = new List <byte>(); for (int i = 0; i < gameObjects.Count; i++) { GameObjectServer objectToSend = gameObjects[i]; //Send an update if the object is not a leaf or if the leaf has been modified. if ((objectToSend is LeafServer && objectToSend.Modified) || (objectToSend is PlayerServer)) { objectToSend.Modified = false; BasePacket packetToSend = ServerPacketFactory.CreateUpdatePacket(gameObjects[i]); allPackets.AddRange(PacketUtil.Serialize(packetToSend)); } } SendAll(allPackets.ToArray()); List <byte> destroyPackets = new List <byte>(); lock (GameServer.instance.toDestroyQueue) { foreach (var gameObj in GameServer.instance.toDestroyQueue) { BasePacket packet = PacketFactory.NewDestroyPacket(gameObj); destroyPackets.AddRange(PacketUtil.Serialize(packet)); } } SendAll(destroyPackets.ToArray()); }
private void DoAuthenticationChecks(BasePacket receivedPacket, SubPacket subPacket) { if (isAuthenticated && !receivedPacket.isAuthenticated() && subPacket.gameMessage.opcode != (ushort)GamePacketOpCode.RegisterSuccess) { isAuthenticated = false; } }
public override void ProcessPacket(BasePacket packet) { PacketEnum.ProcessType processType = packet.ProcessType; switch (processType) { case PacketEnum.ProcessType.Connect: { MNetworkPlayer player = new MNetworkPlayer(packet.Serial); NetworkLobby.AddPlayer(player); player.PlayerState = MNetworkPlayer.MPlayerState.Connected; Debug.Log($"S:[{packet.Serial}] Connected"); break; } case PacketEnum.ProcessType.Disconnect: { NetworkLobby.DeletePlayer(packet.Serial); Debug.Log($"S:[{packet.Serial}] Disconnected"); break; } case PacketEnum.ProcessType.Data: { OnMessage(packet); break; } } }
public async Task CheckAsync(BasePacket packet) { using (var context = new MikiContext()) { Achievement a = await context.Achievements.FindAsync(packet.discordUser.Id.ToDbLong(), Name); if (a == null) { if (await Achievements[0].CheckAsync(context, packet)) { await Achievements[0].UnlockAsync(context, packet.discordChannel, packet.discordUser); await AchievementManager.Instance.CallAchievementUnlockEventAsync(Achievements[0], packet.discordUser, packet.discordChannel); } return; } if (a.Rank >= Achievements.Count - 1) { return; } if (await Achievements[a.Rank + 1].CheckAsync(context, packet)) { await Achievements[a.Rank + 1].UnlockAsync(context, packet.discordChannel, packet.discordUser, a.Rank + 1); await AchievementManager.Instance.CallAchievementUnlockEventAsync(Achievements[a.Rank + 1], packet.discordUser, packet.discordChannel); } } }
protected virtual void Socket_OnPacketsReceived(IPacketSend externalSocket, Queue <BasePacket> packets) { if (packets.Count == 1) { BasePacket packet = packets.Dequeue(); if (packet is ServerDisconnectPacket) { socket?.Disconnect(); return; } if (packet is KeepAliveResponse) { KeepAliveReceived(); } else { lock (packetLock) { deserializedPackets.Add(packet); } } } else { lock (packetLock) { deserializedPackets.AddRange(packets); } } }
public void SendLocationAndState(BasePacket packet) { if (settings.Enabled) { var id = imeiList.GetId(packet.IMEI); if (id != null) { try { byte[] messageBytes = builder.CreateLocationAndStateMessage(packet, id); messages.Enqueue(messageBytes); this.log.InfoFormat( packet.isSOS() ? "ALARM = SOS, IMEI={0}, geo={1}, {2}, speed={3}, direction={4}, altitude={5}, state={6}, id={7}" : "IMEI={0}, geo={1}, {2}, speed={3}, direction={4}, altitude={5}, state={6}, id={7}", packet.IMEI, packet.Latitude, packet.Longitude, packet.Speed, packet.Direction, packet.Altitude, packet.State, id); } catch (Exception ex) { this.log.Error("UnifiedProtocolSink.SendLocationAndState: " + this.settings.Url + ": " + ex.ToString()); } } } }
private BaseResponse PlayerMove(int clientId, BasePacket packet) { PPlayerMove pPlayerMove = (PPlayerMove)packet; PlayerDataEx playerData = World.PlayerDataGet(pPlayerMove.SessionToken); if (playerData == null) { ThrowSessionError(packet.Type, packet.SessionToken); return(null); } if (playerData.Player.Position != pPlayerMove.Position || playerData.Player.Direction != pPlayerMove.Direction) { _vCheckPosition.Validate(packet); if (pPlayerMove.Direction == Direction.None) { playerData.StopMoving(pPlayerMove.Position); } else { playerData.StartMoving(pPlayerMove.Position, pPlayerMove.Direction); } RegisterWorldResponseForNearest(playerData, new RPlayerMove { PlayerId = playerData.Player.Id, Position = pPlayerMove.Position, Direction = pPlayerMove.Direction, }); } return(null); }
private void ProcessSelectCharacter(ClientConnection client, SubPacket packet) { SelectCharacterPacket selectCharRequest = new SelectCharacterPacket(packet.data); Program.Log.Info("{0} => Select character id {1}", client.currentUserId == 0 ? client.GetAddress() : "User " + client.currentUserId, selectCharRequest.characterId); Character chara = Database.GetCharacter(client.currentUserId, selectCharRequest.characterId); World world = null; if (chara != null) { world = Database.GetServer(chara.serverId); } if (world == null) { ErrorPacket errorPacket = new ErrorPacket(selectCharRequest.sequence, 0, 0, 13001, "World Does not exist or is inactive."); SubPacket subpacket = errorPacket.BuildPacket(); BasePacket basePacket = BasePacket.CreatePacket(subpacket, true, false); BasePacket.EncryptPacket(client.blowfish, basePacket); client.QueuePacket(basePacket); return; } SelectCharacterConfirmPacket connectCharacter = new SelectCharacterConfirmPacket(selectCharRequest.sequence, selectCharRequest.characterId, client.currentSessionToken, world.address, world.port, selectCharRequest.ticket); BasePacket outgoingPacket = BasePacket.CreatePacket(connectCharacter.BuildPackets(), true, false); BasePacket.EncryptPacket(client.blowfish, outgoingPacket); client.QueuePacket(outgoingPacket); }
public void ProcessPacket(BasePacket packet, PPType type) { if (packet.header.isCompressed == 0x01) { BasePacket.DecompressPacket(ref packet); } List <SubPacket> subPackets = packet.GetSubpackets(); foreach (SubPacket subpacket in subPackets) { //Normal Game Opcode if (subpacket.header.type == 0x03) { switch (type) { case PPType.Recv: HandleRecv(subpacket); break; case PPType.Send: HandleSend(subpacket); break; } } } }
private async Task InternalCheckAsync(BasePacket packet) { long userId = packet.discordUser.Id.ToDbLong(); using (var context = new MikiContext()) { Achievement a = await DatabaseHelpers.GetAchievementAsync(context, userId, Name); if (a == null) { if (await Achievements[0].CheckAsync(packet)) { await AchievementManager.Instance.UnlockAsync(Achievements[0], packet.discordChannel, packet.discordUser); await AchievementManager.Instance.CallAchievementUnlockEventAsync(Achievements[0], packet.discordUser, packet.discordChannel); } return; } if (a.Rank >= Achievements.Count - 1) { return; } if (await Achievements[a.Rank + 1].CheckAsync(packet)) { await AchievementManager.Instance.UnlockAsync(Achievements[a.Rank + 1], packet.discordChannel, packet.discordUser, a.Rank + 1); await AchievementManager.Instance.CallAchievementUnlockEventAsync(Achievements[a.Rank + 1], packet.discordUser, packet.discordChannel); } } }
private void OnReceiveComplate(object sender, SocketAsyncEventArgs e) { Socket client = sender as Socket; if (client.Connected && e.BytesTransferred > 0) { BasePacket packet = defaultEngine.packetDistinctioner.Distinction(e.Buffer); if (packet != null) { defaultEngine.Dispatcher.Dispatch(packet); client.ReceiveAsync(e); } } else { if (MNetworkEntry.Instance.TCPNetwork != null) { MNetworkEntry.Instance.TCPNetwork.Callback.HandleDisconnect(); } client = null; } }
public static BasePacket buildPacket(uint actorID, uint time) { byte[] data = new byte[0x18]; using (MemoryStream mem = new MemoryStream(data)) { using (BinaryWriter binWriter = new BinaryWriter(mem)) { try { binWriter.Write((short)0x18); binWriter.Write((short)0x8); binWriter.Write((uint)0); binWriter.Write((uint)0); binWriter.Write((uint)0xFFFFFD7F); binWriter.Write((uint)actorID); binWriter.Write((uint)time); } catch (Exception) { } } } return(BasePacket.createPacket(data, false, false)); }
//패널이바뀔때마다 로딩해야되나 체크하고 //로딩해야되면 로딩하는 방식 //screenName: 유저 아이디가 넘어옴 public void LoadUser(string screenName) { //이전에 로딩한 정보와 동일, 첫로딩 후 아이디를 저장하기에 자기 정보도 최초 로딩은 하게 됨 if (screenName == this.screenName) { return; } this.screenName = screenName; userList.Clear(); BasePacket parameter = null; if (epanel == eUserPanel.eFollower || epanel == eUserPanel.eUserFollwer) { PacketFollowerList param = new PacketFollowerList(); param.screen_name = screenName; parameter = param; } else { PacketFollowingList param = new PacketFollowingList(); param.screen_name = screenName; parameter = param; } ThreadPool.QueueUserWorkItem(LoadUser, parameter); }
/// <summary> /// Protocol 0001 /// </summary> /// <param name="session"></param> /// <param name="packet"></param> /// <returns></returns> public void VersionCheck(EcoSession session, BasePacket packet) { try { //Logger.Debug($"Send Packet:{loginServerAck.ToHexString()}"); session.Send(firstAck); //byte[] front_word = new byte[4]; //byte[] back_word = new byte[4]; //rng.GetBytes(front_word); //rng.GetBytes(back_word); //front_word[0] = 0; //back_word[0] = 0; //session.FrontWord = front_word.ToUInt32(); //session.BackWord = back_word.ToUInt32(); //var pass_hash = new BasePacket(0x001e, front_word.Concat(back_word).ToArray()).ToBytes(); session.FrontWord = 1111; session.BackWord = 1111; var pass_hash = new BasePacket(0x001e, session.FrontWord.ToBytes().Concat(session.BackWord.ToBytes()).ToArray()).ToBytes(); session.Send(pass_hash); session.Send(new BasePacket(0x0002, packet.Data)); } catch (Exception e) { Logger.Error(e); } }
public static void sendMessage(AsyncTcpSession client, BasePacket packet) { // using (MemoryStream sendStream = new MemoryStream()) { // CodedOutputStream os = CodedOutputStream.CreateInstance(sendStream); // WriteMessageNoTag equivalent to WriteVarint32, WriteByte (byte []) // that is: variable length message header + message body // os.WriteMessageNoTag(request); // os.WriteRawBytes(bytes); // os.Flush(); MemoryStream sendStream = new MemoryStream(); packet.WriteTo(sendStream); byte[] bytes = sendStream.ToArray(); client.Send(new ArraySegment<byte>(bytes)); // } }