mirror of
https://bitbucket.org/Ioncannon/project-meteor-server.git
synced 2025-04-22 12:47:46 +00:00
395 lines
16 KiB
C#
395 lines
16 KiB
C#
using FFXIVClassic.Common;
|
|
using FFXIVClassic_World_Server.DataObjects;
|
|
using FFXIVClassic_World_Server.DataObjects.Group;
|
|
using FFXIVClassic_World_Server.Packets.Receive.Subpackets;
|
|
using FFXIVClassic_World_Server.Packets.Send.Subpackets.Groups;
|
|
using FFXIVClassic_World_Server.Packets.WorldPackets.Receive;
|
|
using FFXIVClassic_World_Server.Packets.WorldPackets.Receive.Group;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Net;
|
|
using System.Net.Sockets;
|
|
|
|
namespace FFXIVClassic_World_Server
|
|
{
|
|
class Server
|
|
{
|
|
public const int FFXIV_MAP_PORT = 54992;
|
|
public const int BUFFER_SIZE = 0xFFFF; //Max basepacket size is 0xFFFF
|
|
public const int BACKLOG = 100;
|
|
private static Server mSelf;
|
|
|
|
//Connections
|
|
private Socket mServerSocket;
|
|
WorldManager mWorldManager;
|
|
PacketProcessor mPacketProcessor;
|
|
|
|
//Preloaded Maps
|
|
private Dictionary<uint, string> mIdToNameMap = new Dictionary<uint, string>();
|
|
|
|
//Session Management
|
|
private List<ClientConnection> mConnectionList = new List<ClientConnection>();
|
|
private Dictionary<uint, Session> mZoneSessionList = new Dictionary<uint, Session>();
|
|
private Dictionary<uint, Session> mChatSessionList = new Dictionary<uint, Session>();
|
|
|
|
public Server()
|
|
{
|
|
mSelf = this;
|
|
}
|
|
|
|
public static Server GetServer()
|
|
{
|
|
return mSelf;
|
|
}
|
|
|
|
public bool StartServer()
|
|
{
|
|
mPacketProcessor = new PacketProcessor(this);
|
|
|
|
LoadCharaNames();
|
|
|
|
mWorldManager = new WorldManager(this);
|
|
mWorldManager.LoadZoneServerList();
|
|
mWorldManager.LoadZoneEntranceList();
|
|
mWorldManager.ConnectToZoneServers();
|
|
|
|
IPEndPoint serverEndPoint = new System.Net.IPEndPoint(IPAddress.Parse(ConfigConstants.OPTIONS_BINDIP), int.Parse(ConfigConstants.OPTIONS_PORT));
|
|
|
|
try
|
|
{
|
|
mServerSocket = new System.Net.Sockets.Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new ApplicationException("Could not Create socket, check to make sure not duplicating port", e);
|
|
}
|
|
try
|
|
{
|
|
mServerSocket.Bind(serverEndPoint);
|
|
mServerSocket.Listen(BACKLOG);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new ApplicationException("Error occured while binding socket, check inner exception", e);
|
|
}
|
|
try
|
|
{
|
|
mServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), mServerSocket);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new ApplicationException("Error occured starting listeners, check inner exception", e);
|
|
}
|
|
|
|
Console.ForegroundColor = ConsoleColor.White;
|
|
Program.Log.Info("World Server accepting connections @ {0}:{1}", (mServerSocket.LocalEndPoint as IPEndPoint).Address, (mServerSocket.LocalEndPoint as IPEndPoint).Port);
|
|
Console.ForegroundColor = ConsoleColor.Gray;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void AddSession(ClientConnection connection, Session.Channel type, uint id)
|
|
{
|
|
Session session = new Session(id, connection, type);
|
|
|
|
switch (type)
|
|
{
|
|
case Session.Channel.ZONE:
|
|
//New character since world server loaded
|
|
if (!mIdToNameMap.ContainsKey(id))
|
|
AddNameToMap(id, session.characterName);
|
|
|
|
if (!mZoneSessionList.ContainsKey(id))
|
|
mZoneSessionList.Add(id, session);
|
|
break;
|
|
case Session.Channel.CHAT:
|
|
if (!mChatSessionList.ContainsKey(id))
|
|
mChatSessionList.Add(id, session);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void RemoveSession(Session.Channel type, uint id)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Session.Channel.ZONE:
|
|
if (mZoneSessionList.ContainsKey(id))
|
|
{
|
|
mZoneSessionList[id].clientConnection.Disconnect();
|
|
mConnectionList.Remove(mZoneSessionList[id].clientConnection);
|
|
mZoneSessionList.Remove(id);
|
|
}
|
|
break;
|
|
case Session.Channel.CHAT:
|
|
if (mChatSessionList.ContainsKey(id))
|
|
{
|
|
mChatSessionList[id].clientConnection.Disconnect();
|
|
mConnectionList.Remove(mChatSessionList[id].clientConnection);
|
|
mChatSessionList.Remove(id);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
public Session GetSession(uint targetSession, Session.Channel type = Session.Channel.ZONE)
|
|
{
|
|
switch (type)
|
|
{
|
|
case Session.Channel.ZONE:
|
|
if (mZoneSessionList.ContainsKey(targetSession))
|
|
return mZoneSessionList[targetSession];
|
|
break;
|
|
case Session.Channel.CHAT:
|
|
if (mChatSessionList.ContainsKey(targetSession))
|
|
return mChatSessionList[targetSession];
|
|
break;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void OnReceiveSubPacketFromZone(ZoneServer zoneServer, SubPacket subpacket)
|
|
{
|
|
uint sessionId = subpacket.header.targetId;
|
|
Session session = GetSession(sessionId);
|
|
|
|
if (subpacket.gameMessage.opcode >= 0x1000)
|
|
{
|
|
subpacket.DebugPrintSubPacket();
|
|
|
|
switch (subpacket.gameMessage.opcode)
|
|
{
|
|
//Session Begin Confirm
|
|
case 0x1000:
|
|
SessionBeginConfirmPacket beginConfirmPacket = new SessionBeginConfirmPacket(subpacket.data);
|
|
|
|
if (beginConfirmPacket.invalidPacket || beginConfirmPacket.errorCode == 0)
|
|
Program.Log.Error("Session {0} had a error beginning session.", beginConfirmPacket.sessionId);
|
|
|
|
break;
|
|
//Session End Confirm
|
|
case 0x1001:
|
|
SessionEndConfirmPacket endConfirmPacket = new SessionEndConfirmPacket(subpacket.data);
|
|
|
|
if (!endConfirmPacket.invalidPacket && endConfirmPacket.errorCode == 0)
|
|
{
|
|
//Check destination, if != 0, update route and start new session
|
|
if (endConfirmPacket.destinationZone != 0)
|
|
{
|
|
session.routing1 = Server.GetServer().GetWorldManager().GetZoneServer(endConfirmPacket.destinationZone);
|
|
session.routing1.SendSessionStart(session);
|
|
}
|
|
else
|
|
{
|
|
RemoveSession(Session.Channel.ZONE, endConfirmPacket.sessionId);
|
|
RemoveSession(Session.Channel.CHAT, endConfirmPacket.sessionId);
|
|
}
|
|
}
|
|
else
|
|
Program.Log.Error("Session {0} had an error ending session.", endConfirmPacket.sessionId);
|
|
|
|
break;
|
|
//Zone Change Request
|
|
case 0x1002:
|
|
WorldRequestZoneChangePacket zoneChangePacket = new WorldRequestZoneChangePacket(subpacket.data);
|
|
|
|
if (!zoneChangePacket.invalidPacket)
|
|
{
|
|
GetWorldManager().DoZoneServerChange(session, zoneChangePacket.destinationZoneId, "", zoneChangePacket.destinationSpawnType, zoneChangePacket.destinationX, zoneChangePacket.destinationY, zoneChangePacket.destinationZ, zoneChangePacket.destinationRot);
|
|
}
|
|
|
|
break;
|
|
//Group get data request
|
|
case 0x1020:
|
|
GetGroupPacket getGroupPacket = new GetGroupPacket(subpacket.data);
|
|
mWorldManager.SendGroupData(session, getGroupPacket.groupId);
|
|
break;
|
|
//Group delete request
|
|
case 0x1021:
|
|
FFXIVClassic_World_Server.Packets.WorldPackets.Receive.Group.DeleteGroupPacket deleteGroupPacket = new FFXIVClassic_World_Server.Packets.WorldPackets.Receive.Group.DeleteGroupPacket(subpacket.data);
|
|
mWorldManager.DeleteGroup(deleteGroupPacket.groupId);
|
|
break;
|
|
//Linkshell create request
|
|
case 0x1023:
|
|
CreateLinkshellPacket createLinkshellpacket = new CreateLinkshellPacket(subpacket.data);
|
|
mWorldManager.GetLinkshellManager().CreateLinkshell(createLinkshellpacket.name, createLinkshellpacket.crestid, createLinkshellpacket.master);
|
|
break;
|
|
//Linkshell modify request
|
|
case 0x1024:
|
|
ModifyLinkshellPacket modifyLinkshellpacket = new ModifyLinkshellPacket(subpacket.data);
|
|
|
|
if (modifyLinkshellpacket.argCode == 0)
|
|
mWorldManager.GetLinkshellManager().ChangeLinkshellCrest(modifyLinkshellpacket.currentName, modifyLinkshellpacket.crestid);
|
|
break;
|
|
//Group Add/Remove Member
|
|
case 0x1022:
|
|
GroupMemberChangePacket gMemberChangePacket = new GroupMemberChangePacket(subpacket.data);
|
|
break;
|
|
}
|
|
}
|
|
else if (mZoneSessionList.ContainsKey(sessionId))
|
|
{
|
|
ClientConnection conn = mZoneSessionList[sessionId].clientConnection;
|
|
conn.QueuePacket(subpacket, true, false);
|
|
conn.FlushQueuedSendPackets();
|
|
}
|
|
|
|
}
|
|
|
|
public WorldManager GetWorldManager()
|
|
{
|
|
return mWorldManager;
|
|
}
|
|
|
|
#region Socket Handling
|
|
private void AcceptCallback(IAsyncResult result)
|
|
{
|
|
ClientConnection conn = null;
|
|
Socket socket = (System.Net.Sockets.Socket)result.AsyncState;
|
|
|
|
try
|
|
{
|
|
conn = new ClientConnection();
|
|
conn.socket = socket.EndAccept(result);
|
|
conn.buffer = new byte[BUFFER_SIZE];
|
|
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Add(conn);
|
|
}
|
|
|
|
Program.Log.Info("Connection {0}:{1} has connected.", (conn.socket.RemoteEndPoint as IPEndPoint).Address, (conn.socket.RemoteEndPoint as IPEndPoint).Port);
|
|
//Queue recieving of data from the connection
|
|
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
|
|
//Queue the accept of the next incomming connection
|
|
mServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), mServerSocket);
|
|
}
|
|
catch (SocketException)
|
|
{
|
|
if (conn != null)
|
|
{
|
|
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Remove(conn);
|
|
}
|
|
}
|
|
mServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), mServerSocket);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
if (conn != null)
|
|
{
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Remove(conn);
|
|
}
|
|
}
|
|
mServerSocket.BeginAccept(new AsyncCallback(AcceptCallback), mServerSocket);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Receive Callback. Reads in incoming data, converting them to base packets. Base packets are sent to be parsed. If not enough data at the end to build a basepacket, move to the beginning and prepend.
|
|
/// </summary>
|
|
/// <param name="result"></param>
|
|
private void ReceiveCallback(IAsyncResult result)
|
|
{
|
|
ClientConnection conn = (ClientConnection)result.AsyncState;
|
|
|
|
//Check if disconnected
|
|
if ((conn.socket.Poll(1, SelectMode.SelectRead) && conn.socket.Available == 0))
|
|
{
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Remove(conn);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
int bytesRead = conn.socket.EndReceive(result);
|
|
|
|
bytesRead += conn.lastPartialSize;
|
|
|
|
if (bytesRead >= 0)
|
|
{
|
|
int offset = 0;
|
|
|
|
//Build packets until can no longer or out of data
|
|
while (true)
|
|
{
|
|
BasePacket basePacket = BasePacket.CreatePacket(ref offset, conn.buffer, bytesRead);
|
|
|
|
//If can't build packet, break, else process another
|
|
if (basePacket == null)
|
|
break;
|
|
else
|
|
{
|
|
mPacketProcessor.ProcessPacket(conn, basePacket);
|
|
}
|
|
|
|
}
|
|
|
|
//Not all bytes consumed, transfer leftover to beginning
|
|
if (offset < bytesRead)
|
|
Array.Copy(conn.buffer, offset, conn.buffer, 0, bytesRead - offset);
|
|
|
|
conn.lastPartialSize = bytesRead - offset;
|
|
|
|
//Build any queued subpackets into basepackets and send
|
|
conn.FlushQueuedSendPackets();
|
|
|
|
if (offset < bytesRead)
|
|
//Need offset since not all bytes consumed
|
|
conn.socket.BeginReceive(conn.buffer, bytesRead - offset, conn.buffer.Length - (bytesRead - offset), SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
|
|
else
|
|
//All bytes consumed, full buffer available
|
|
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
|
|
}
|
|
else
|
|
{
|
|
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Remove(conn);
|
|
}
|
|
}
|
|
}
|
|
catch (SocketException)
|
|
{
|
|
if (conn.socket != null)
|
|
{
|
|
|
|
lock (mConnectionList)
|
|
{
|
|
mConnectionList.Remove(conn);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
public void LoadCharaNames()
|
|
{
|
|
Database.GetAllCharaNames(mIdToNameMap);
|
|
}
|
|
|
|
public void AddNameToMap(uint charaId, string name)
|
|
{
|
|
mIdToNameMap.Add(charaId, name);
|
|
}
|
|
|
|
public string GetNameForId(uint charaId)
|
|
{
|
|
if (mIdToNameMap.ContainsKey(charaId))
|
|
return mIdToNameMap[charaId];
|
|
return null;
|
|
}
|
|
|
|
}
|
|
}
|