project-meteor-server/FFXIVClassic World Server/Server.cs

using FFXIVClassic.Common;
using FFXIVClassic_World_Server.DataObjects;
using FFXIVClassic_World_Server.DataObjects.Group;
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>();

        //World Scope Group Management
        private Object mGroupLock = new object();
        private ulong mRunningGroupIndex = 1;
        private Dictionary<ulong, Group> mCurrentWorldGroups = new Dictionary<ulong, Group>();

        private PartyManager mPartyManager;
        private RetainerGroupManager mRetainerGroupManager;
        private LinkshellManager mLinkshellManager;
        private RelationGroupManager mRelationGroupManager;

        public Server()
        {
            mSelf = this;
            mPartyManager = new PartyManager(this, mGroupLock, mCurrentWorldGroups);
            mLinkshellManager = new LinkshellManager(this, mGroupLock, mCurrentWorldGroups);
            mRetainerGroupManager = new RetainerGroupManager(this, mGroupLock, mCurrentWorldGroups);
            mRelationGroupManager = new RelationGroupManager(this, mGroupLock, mCurrentWorldGroups);
        }

        public static Server GetServer()
        {
            return mSelf;
        }

        public bool StartServer()
        {
            mPacketProcessor = new PacketProcessor(this);
            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;

            if (subpacket.gameMessage.opcode >= 0x1000)
            {
                subpacket.DebugPrintSubPacket();
                uint targetSession = subpacket.header.targetId;
                Session session = GetSession(targetSession);

                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);
                        SendGroupData(session, getGroupPacket.groupId);
                        break;
                    //Group delete request
                    case 0x1021:
                        DeleteGroupPacket deleteGroupPacket = new DeleteGroupPacket(subpacket.data);
                        DeleteGroup(deleteGroupPacket.groupId);
                        break;
                    //Linkshell create request
                    case 0x1023:
                        CreateLinkshellPacket createLinkshellpacket = new CreateLinkshellPacket(subpacket.data);
                        mLinkshellManager.CreateLinkshell(createLinkshellpacket.name, createLinkshellpacket.crestid, createLinkshellpacket.master);
                        break;
                    //Linkshell modify request
                    case 0x1024:
                        ModifyLinkshellPacket modifyLinkshellpacket = new ModifyLinkshellPacket(subpacket.data);
                        mLinkshellManager.ModifyLinkshell();
                        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;  
        }

        private void SendGroupData(Session session, ulong groupId)
        {
            if (mCurrentWorldGroups.ContainsKey(groupId))
            {
                Group group = mCurrentWorldGroups[groupId];
                
            }
        }

        private void SendGroupDataToAllMembers(ulong groupId)
        {
            if (mCurrentWorldGroups.ContainsKey(groupId))
            {
                Group group = mCurrentWorldGroups[groupId];
                
            }
        }

        public void GetGroup(Group group)
        {
            if (group is Party)
            { 
                
            }
            else if (group is RetainerGroup)
            {

            }
            else if (group is Linkshell)
            {

            }
            else if (group is Relation)
            {

            }
        }

        public void DeleteGroup(ulong id)
        {
            if (!mCurrentWorldGroups.ContainsKey(id))
                return;
            Group group = mCurrentWorldGroups[id];
            if (group is Party)            
                mPartyManager.DeleteParty(group.groupIndex);            
            else if (group is Linkshell)            
                mLinkshellManager.DeleteLinkshell(group.groupIndex);            
            else if (group is Relation)           
                mRelationGroupManager.DeleteRelationGroup(group.groupIndex);           
        }

        public void IncrementGroupIndex()
        {
            mRunningGroupIndex++;
        }

        public ulong GetGroupIndex()
        {
            return mRunningGroupIndex;
        }

    }
}