public void HandleMcpeClientToServerHandshake(McpeClientToServerHandshake message)
{
IServerManager serverManager = _session.Server.ServerManager;
IServer server = serverManager.GetServer();
IMcpeMessageHandler messageHandler = server.CreatePlayer(_session, _playerInfo);
_session.MessageHandler = messageHandler; // Replace current message handler with real one.
if (_playerInfo.ProtocolVersion < 111)
{
Log.Warn($"Wrong version ({_playerInfo.ProtocolVersion}) of Minecraft. Upgrade to join this server.");
_session.Disconnect($"Wrong version ({_playerInfo.ProtocolVersion}) of Minecraft. Upgrade to join this server.");
return;
}
if (Config.GetProperty("ForceXBLAuthentication", false) && _playerInfo.CertificateData.ExtraData.Xuid == null)
{
Log.Warn($"You must authenticate to XBOX Live to join this server.");
_session.Disconnect(Config.GetProperty("ForceXBLLogin", "You must authenticate to XBOX Live to join this server."));
return;
}
_session.MessageHandler.HandleMcpeClientToServerHandshake(null);
}
public void HandleMcpeClientToServerHandshake(McpeClientToServerHandshake message)
{
IServerManager serverManager = _session.Server.ServerManager;
IServer server = serverManager.GetServer();
IMcpeMessageHandler messageHandler = server.CreatePlayer(_session, _playerInfo);
_session.MessageHandler = messageHandler; // Replace current message handler with real one.
_session.MessageHandler.HandleMcpeClientToServerHandshake(null);
}
private void HandlePackage(IMcpeMessageHandler handler, Package message)
{
if (handler is Player)
{
var result = Server.PluginManager.PluginPacketHandler(message, true, (Player)handler);
if (result != message)
{
message.PutPool();
}
message = result;
}
if (message == null)
{
return;
}
else if (typeof(ConnectedPing) == message.GetType())
{
HandleConnectedPing((ConnectedPing)message);
}
else if (typeof(ConnectionRequest) == message.GetType())
{
HandleConnectionRequest((ConnectionRequest)message);
}
else if (typeof(NewIncomingConnection) == message.GetType())
{
HandleNewIncomingConnection((NewIncomingConnection)message);
}
else if (typeof(DisconnectionNotification) == message.GetType())
{
HandleDisconnectionNotification();
}
else if (typeof(McpeClientToServerHandshake) == message.GetType())
{
// Start encrypotion
handler.HandleMcpeClientToServerHandshake((McpeClientToServerHandshake)message);
}
else if (typeof(McpeResourcePackClientResponse) == message.GetType())
{
handler.HandleMcpeResourcePackClientResponse((McpeResourcePackClientResponse)message);
}
else if (typeof(McpeResourcePackChunkRequest) == message.GetType())
{
handler.HandleMcpeResourcePackChunkRequest((McpeResourcePackChunkRequest)message);
}
else if (typeof(McpeUpdateBlock) == message.GetType())
{
// DO NOT USE. Will dissapear from MCPE any release.
// It is a bug that it leaks these messages.
}
else if (typeof(McpeRemoveBlock) == message.GetType())
{
handler.HandleMcpeRemoveBlock((McpeRemoveBlock)message);
}
else if (typeof(McpeLevelSoundEvent) == message.GetType())
{
handler.HandleMcpeLevelSoundEvent((McpeLevelSoundEvent)message);
}
else if (typeof(McpeAnimate) == message.GetType())
{
handler.HandleMcpeAnimate((McpeAnimate)message);
}
else if (typeof(McpeEntityFall) == message.GetType())
{
handler.HandleMcpeEntityFall((McpeEntityFall)message);
}
else if (typeof(McpeUseItem) == message.GetType())
{
handler.HandleMcpeUseItem((McpeUseItem)message);
}
else if (typeof(McpeEntityEvent) == message.GetType())
{
handler.HandleMcpeEntityEvent((McpeEntityEvent)message);
}
else if (typeof(McpeText) == message.GetType())
{
handler.HandleMcpeText((McpeText)message);
}
else if (typeof(McpeRemoveEntity) == message.GetType())
{
// Do nothing right now, but should clear out the entities and stuff
// from this players internal structure.
}
else if (typeof(McpeLogin) == message.GetType())
{
handler.HandleMcpeLogin((McpeLogin)message);
}
else if (typeof(McpeMovePlayer) == message.GetType())
{
handler.HandleMcpeMovePlayer((McpeMovePlayer)message);
}
else if (typeof(McpeCommandStep) == message.GetType())
{
handler.HandleMcpeCommandStep((McpeCommandStep)message);
}
else if (typeof(McpeInteract) == message.GetType())
{
handler.HandleMcpeInteract((McpeInteract)message);
}
else if (typeof(McpeRespawn) == message.GetType())
{
handler.HandleMcpeRespawn((McpeRespawn)message);
}
else if (typeof(McpeBlockEntityData) == message.GetType())
{
handler.HandleMcpeBlockEntityData((McpeBlockEntityData)message);
}
else if (typeof(McpeAdventureSettings) == message.GetType())
{
handler.HandleMcpeAdventureSettings((McpeAdventureSettings)message);
}
else if (typeof(McpePlayerAction) == message.GetType())
{
handler.HandleMcpePlayerAction((McpePlayerAction)message);
}
else if (typeof(McpeDropItem) == message.GetType())
{
handler.HandleMcpeDropItem((McpeDropItem)message);
}
else if (typeof(McpeContainerSetSlot) == message.GetType())
{
handler.HandleMcpeContainerSetSlot((McpeContainerSetSlot)message);
}
else if (typeof(McpeContainerClose) == message.GetType())
{
handler.HandleMcpeContainerClose((McpeContainerClose)message);
}
else if (typeof(McpeMobEquipment) == message.GetType())
{
handler.HandleMcpeMobEquipment((McpeMobEquipment)message);
}
else if (typeof(McpeMobArmorEquipment) == message.GetType())
{
handler.HandleMcpeMobArmorEquipment((McpeMobArmorEquipment)message);
}
else if (typeof(McpeCraftingEvent) == message.GetType())
{
handler.HandleMcpeCraftingEvent((McpeCraftingEvent)message);
}
else if (typeof(McpeRequestChunkRadius) == message.GetType())
{
handler.HandleMcpeRequestChunkRadius((McpeRequestChunkRadius)message);
}
else if (typeof(McpeMapInfoRequest) == message.GetType())
{
handler.HandleMcpeMapInfoRequest((McpeMapInfoRequest)message);
}
else if (typeof(McpeItemFrameDropItem) == message.GetType())
{
handler.HandleMcpeItemFrameDropItem((McpeItemFrameDropItem)message);
}
else if (typeof(McpePlayerInput) == message.GetType())
{
handler.HandleMcpePlayerInput((McpePlayerInput)message);
}
else if (typeof(McpeBlockPickRequest) == message.GetType())
{
handler.HandleMcpeBlockPickRequest((McpeBlockPickRequest)message);
}
else if (typeof(McpeCommandBlockUpdate) == message.GetType())
{
handler.HandleMcpeCommandBlockUpdate((McpeCommandBlockUpdate)message);
}
else
{
Log.Error($"Unhandled package: {message.GetType().Name} 0x{message.Id:X2} for user: {Username}, IP {EndPoint.Address}");
if (Log.IsDebugEnabled)
{
Log.Warn($"Unknown package 0x{message.Id:X2}\n{Package.HexDump(message.Bytes)}");
}
return;
}
if (message.Timer.IsRunning)
{
long elapsedMilliseconds = message.Timer.ElapsedMilliseconds;
if (elapsedMilliseconds > 1000)
{
Log.WarnFormat("Package (0x{1:x2}) handling too long {0}ms for {2}", elapsedMilliseconds, message.Id, Username);
}
}
else
{
Log.WarnFormat("Package (0x{0:x2}) timer not started for {1}.", message.Id, Username);
}
}
private void HandleBedrockMessage(IMcpeMessageHandler handler, Packet message)
{
if (handler is Player player)
{
Packet result = _pluginManager.PluginPacketHandler(message, true, player);
if (result != message)
{
message.PutPool();
}
message = result;
}
if (message == null)
{
return;
}
switch (message)
{
case McpeClientToServerHandshake msg:
// Start encryption
handler.HandleMcpeClientToServerHandshake(msg);
break;
case McpeResourcePackClientResponse msg:
handler.HandleMcpeResourcePackClientResponse(msg);
break;
case McpeResourcePackChunkRequest msg:
handler.HandleMcpeResourcePackChunkRequest(msg);
break;
case McpeSetLocalPlayerAsInitializedPacket msg:
handler.HandleMcpeSetLocalPlayerAsInitializedPacket(msg);
break;
case McpeScriptCustomEventPacket msg:
handler.HandleMcpeScriptCustomEventPacket(msg);
break;
case McpeUpdateBlock _:
// DO NOT USE. Will dissapear from MCPE any release.
// It is a bug that it leaks these messages.
break;
case McpeLevelSoundEvent msg:
handler.HandleMcpeLevelSoundEvent(msg);
break;
case McpeClientCacheStatus msg:
handler.HandleMcpeClientCacheStatus(msg);
break;
case McpeAnimate msg:
handler.HandleMcpeAnimate(msg);
break;
case McpeEntityFall msg:
handler.HandleMcpeEntityFall(msg);
break;
case McpeEntityEvent msg:
handler.HandleMcpeEntityEvent(msg);
break;
case McpeText msg:
handler.HandleMcpeText(msg);
break;
case McpeRemoveEntity _:
// Do nothing right now, but should clear out the entities and stuff
// from this players internal structure.
break;
case McpeLogin msg:
handler.HandleMcpeLogin(msg);
break;
case McpeMovePlayer msg:
handler.HandleMcpeMovePlayer(msg);
break;
case McpeInteract msg:
handler.HandleMcpeInteract(msg);
break;
case McpeRespawn msg:
handler.HandleMcpeRespawn(msg);
break;
case McpeBlockEntityData msg:
handler.HandleMcpeBlockEntityData(msg);
break;
case McpeAdventureSettings msg:
handler.HandleMcpeAdventureSettings(msg);
break;
case McpePlayerAction msg:
handler.HandleMcpePlayerAction(msg);
break;
case McpeContainerClose msg:
handler.HandleMcpeContainerClose(msg);
break;
case McpeMobEquipment msg:
handler.HandleMcpeMobEquipment(msg);
break;
case McpeMobArmorEquipment msg:
handler.HandleMcpeMobArmorEquipment(msg);
break;
case McpeCraftingEvent msg:
handler.HandleMcpeCraftingEvent(msg);
break;
case McpeInventoryTransaction msg:
handler.HandleMcpeInventoryTransaction(msg);
break;
case McpeServerSettingsRequest msg:
handler.HandleMcpeServerSettingsRequest(msg);
break;
case McpeSetPlayerGameType msg:
handler.HandleMcpeSetPlayerGameType(msg);
break;
case McpePlayerHotbar msg:
handler.HandleMcpePlayerHotbar(msg);
break;
case McpeInventoryContent msg:
handler.HandleMcpeInventoryContent(msg);
break;
case McpeRequestChunkRadius msg:
handler.HandleMcpeRequestChunkRadius(msg);
break;
case McpeMapInfoRequest msg:
handler.HandleMcpeMapInfoRequest(msg);
break;
case McpeItemFrameDropItem msg:
handler.HandleMcpeItemFrameDropItem(msg);
break;
case McpePlayerInput msg:
handler.HandleMcpePlayerInput(msg);
break;
case McpeRiderJump msg:
handler.HandleMcpeRiderJump(msg);
break;
case McpeCommandRequest msg:
handler.HandleMcpeCommandRequest(msg);
break;
case McpeBlockPickRequest msg:
handler.HandleMcpeBlockPickRequest(msg);
break;
case McpeEntityPickRequest msg:
handler.HandleMcpeEntityPickRequest(msg);
break;
case McpeModalFormResponse msg:
handler.HandleMcpeModalFormResponse(msg);
break;
case McpeCommandBlockUpdate msg:
handler.HandleMcpeCommandBlockUpdate(msg);
break;
case McpeMoveEntity msg:
handler.HandleMcpeMoveEntity(msg);
break;
case McpeSetEntityMotion msg:
handler.HandleMcpeSetEntityMotion(msg);
break;
case McpePhotoTransfer msg:
handler.HandleMcpePhotoTransfer(msg);
break;
case McpeSetEntityData msg:
handler.HandleMcpeSetEntityData(msg);
break;
case McpeTickSync msg:
handler.HandleMcpeTickSync(msg);
break;
case McpeNpcRequest msg:
handler.HandleMcpeNpcRequest(msg);
break;
case McpeNetworkStackLatencyPacket msg:
handler.HandleMcpeNetworkStackLatencyPacket(msg);
break;
case McpePlayerSkin msg:
handler.HandleMcpePlayerSkin(msg);
break;
default:
{
Log.Error($"Unhandled packet: {message.GetType().Name} 0x{message.Id:X2} for user: {_session.Username}, IP {_session.EndPoint.Address}");
if (Log.IsDebugEnabled)
{
Log.Warn($"Unknown packet 0x{message.Id:X2}\n{Packet.HexDump(message.Bytes)}");
}
break;
}
}
}
public BedrockMessageHandler(RakSession session, IServerManager serverManager, PluginManager pluginManager) : base(session)
{
_pluginManager = pluginManager;
Handler = new LoginMessageHandler(this, session, serverManager);
}
