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