feat(Core/Shared): added new library - shared (#2416)

src/server/shared/CMakeLists.txt

@@ -0,0 +1,32 @@
+#
+# Copyright (C) 2016+     AzerothCore <www.azerothcore.org>
+#
+
+CollectSourceFiles(
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  PRIVATE_SOURCES)
+
+# Group sources
+GroupSources(${CMAKE_CURRENT_SOURCE_DIR})
+
+add_library(shared 
+  ${PRIVATE_SOURCES})
+
+CollectIncludeDirectories(
+  ${CMAKE_CURRENT_SOURCE_DIR}
+  PUBLIC_INCLUDES)
+
+target_include_directories(shared
+  PUBLIC
+    ${PUBLIC_INCLUDES}
+  PRIVATE
+    ${CMAKE_CURRENT_BINARY_DIR})
+
+target_link_libraries(shared
+  PUBLIC
+    common)
+
+set_target_properties(shared
+  PROPERTIES
+    FOLDER
+      "server")

src/server/shared/Network/RealmSocket.cpp

@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ */
+
+#include <ace/OS_NS_string.h>
+#include <ace/INET_Addr.h>
+#include <ace/SString.h>
+
+#include "RealmSocket.h"
+#include "Log.h"
+
+RealmSocket::Session::Session(void) { }
+
+RealmSocket::Session::~Session(void) { }
+
+RealmSocket::RealmSocket(void) :
+    input_buffer_(4096), session_(NULL),
+    _remoteAddress(), _remotePort(0)
+{
+    reference_counting_policy().value(ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
+
+    msg_queue()->high_water_mark(8 * 1024 * 1024);
+    msg_queue()->low_water_mark(8 * 1024 * 1024);
+}
+
+RealmSocket::~RealmSocket(void)
+{
+    if (msg_queue())
+        msg_queue()->close();
+
+    // delete RealmSocketObject must never be called from our code.
+    closing_ = true;
+
+    delete session_;
+
+    peer().close();
+}
+
+int RealmSocket::open(void * arg)
+{
+    ACE_INET_Addr addr;
+
+    if (peer().get_remote_addr(addr) == -1)
+    {
+        sLog->outError("Error %s while opening realm socket!", ACE_OS::strerror(errno));
+        return -1;
+    }
+
+    _remoteAddress = addr.get_host_addr();
+    _remotePort = addr.get_port_number();
+
+    // Register with ACE Reactor
+    if (Base::open(arg) == -1)
+        return -1;
+
+    if (session_)
+        session_->OnAccept();
+
+    // reactor takes care of the socket from now on
+    remove_reference();
+
+    return 0;
+}
+
+int RealmSocket::close(u_long)
+{
+    shutdown();
+
+    closing_ = true;
+
+    remove_reference();
+
+    return 0;
+}
+
+const std::string& RealmSocket::getRemoteAddress(void) const
+{
+    return _remoteAddress;
+}
+
+uint16 RealmSocket::getRemotePort(void) const
+{
+    return _remotePort;
+}
+
+size_t RealmSocket::recv_len(void) const
+{
+    return input_buffer_.length();
+}
+
+bool RealmSocket::recv_soft(char *buf, size_t len)
+{
+    if (input_buffer_.length() < len)
+        return false;
+
+    ACE_OS::memcpy(buf, input_buffer_.rd_ptr(), len);
+
+    return true;
+}
+
+bool RealmSocket::recv(char *buf, size_t len)
+{
+    bool ret = recv_soft(buf, len);
+
+    if (ret)
+        recv_skip(len);
+
+    return ret;
+}
+
+void RealmSocket::recv_skip(size_t len)
+{
+    input_buffer_.rd_ptr(len);
+}
+
+ssize_t RealmSocket::noblk_send(ACE_Message_Block &message_block)
+{
+    const size_t len = message_block.length();
+
+    if (len == 0)
+        return -1;
+
+    // Try to send the message directly.
+#ifdef MSG_NOSIGNAL
+    ssize_t n = peer().send(message_block.rd_ptr(), len, MSG_NOSIGNAL);
+#else
+    ssize_t n = peer().send(message_block.rd_ptr(), len);
+#endif // MSG_NOSIGNAL
+
+    if (n < 0)
+    {
+        if (errno == EWOULDBLOCK) // Blocking signal
+            return 0;
+        else // Error happened
+            return -1;
+    }
+    else if (n == 0)
+    {
+        // Can this happen ?
+        return -1;
+    }
+
+    // return bytes transmitted
+    return n;
+}
+
+bool RealmSocket::send(const char *buf, size_t len)
+{
+    if (buf == NULL || len == 0)
+        return true;
+
+    ACE_Data_Block db(len, ACE_Message_Block::MB_DATA, (const char*)buf, 0, 0, ACE_Message_Block::DONT_DELETE, 0);
+    ACE_Message_Block message_block(&db, ACE_Message_Block::DONT_DELETE, 0);
+
+    message_block.wr_ptr(len);
+
+    if (msg_queue()->is_empty())
+    {
+        // Try to send it directly.
+        ssize_t n = noblk_send(message_block);
+
+        if (n < 0)
+            return false;
+
+        size_t un = size_t(n);
+        if (un == len)
+            return true;
+
+        // fall down
+        message_block.rd_ptr(un);
+    }
+
+    ACE_Message_Block* mb = message_block.clone();
+
+    if (msg_queue()->enqueue_tail(mb, (ACE_Time_Value *)(&ACE_Time_Value::zero)) == -1)
+    {
+        mb->release();
+        return false;
+    }
+
+    if (reactor()->schedule_wakeup(this, ACE_Event_Handler::WRITE_MASK) == -1)
+        return false;
+
+    return true;
+}
+
+int RealmSocket::handle_output(ACE_HANDLE)
+{
+    if (closing_)
+        return -1;
+
+    ACE_Message_Block* mb = 0;
+
+    if (msg_queue()->is_empty())
+    {
+        reactor()->cancel_wakeup(this, ACE_Event_Handler::WRITE_MASK);
+        return 0;
+    }
+
+    if (msg_queue()->dequeue_head(mb, (ACE_Time_Value *)(&ACE_Time_Value::zero)) == -1)
+        return -1;
+
+    ssize_t n = noblk_send(*mb);
+
+    if (n < 0)
+    {
+        mb->release();
+        return -1;
+    }
+    else if (size_t(n) == mb->length())
+    {
+        mb->release();
+        return 1;
+    }
+    else
+    {
+        mb->rd_ptr(n);
+
+        if (msg_queue()->enqueue_head(mb, (ACE_Time_Value *) &ACE_Time_Value::zero) == -1)
+        {
+            mb->release();
+            return -1;
+        }
+
+        return 0;
+    }
+
+    ACE_NOTREACHED(return -1);
+}
+
+int RealmSocket::handle_close(ACE_HANDLE h, ACE_Reactor_Mask)
+{
+    // As opposed to WorldSocket::handle_close, we don't need locks here.
+    closing_ = true;
+
+    if (h == ACE_INVALID_HANDLE)
+        peer().close_writer();
+
+    if (session_)
+        session_->OnClose();
+
+    reactor()->remove_handler(this, ACE_Event_Handler::DONT_CALL | ACE_Event_Handler::ALL_EVENTS_MASK);
+    return 0;
+}
+
+int RealmSocket::handle_input(ACE_HANDLE)
+{
+    if (closing_)
+        return -1;
+
+    const ssize_t space = input_buffer_.space();
+
+    ssize_t n = peer().recv(input_buffer_.wr_ptr(), space);
+
+    if (n < 0)
+        return errno == EWOULDBLOCK ? 0 : -1;
+    else if (n == 0) // EOF
+        return -1;
+
+    input_buffer_.wr_ptr((size_t)n);
+
+    if (session_ != NULL)
+    {
+        session_->OnRead();
+        input_buffer_.crunch();
+    }
+
+    // return 1 in case there is more data to read from OS
+    return n == space ? 1 : 0;
+}
+
+void RealmSocket::set_session(Session* session)
+{
+    delete session_;
+
+    session_ = session;
+}

src/server/shared/Network/RealmSocket.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ */
+
+#ifndef __REALMSOCKET_H__
+#define __REALMSOCKET_H__
+
+#include <ace/Synch_Traits.h>
+#include <ace/Svc_Handler.h>
+#include <ace/SOCK_Stream.h>
+#include <ace/Message_Block.h>
+#include <ace/Basic_Types.h>
+#include "Common.h"
+
+class RealmSocket : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
+{
+private:
+    typedef ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH> Base;
+
+public:
+    class Session
+    {
+    public:
+        Session(void);
+        virtual ~Session(void);
+
+        virtual void OnRead(void) = 0;
+        virtual void OnAccept(void) = 0;
+        virtual void OnClose(void) = 0;
+    };
+
+    RealmSocket(void);
+    virtual ~RealmSocket(void);
+
+    size_t recv_len(void) const;
+    bool recv_soft(char *buf, size_t len);
+    bool recv(char *buf, size_t len);
+    void recv_skip(size_t len);
+
+    bool send(const char *buf, size_t len);
+
+    const std::string& getRemoteAddress(void) const;
+
+    uint16 getRemotePort(void) const;
+
+    virtual int open(void *);
+
+    virtual int close(u_long);
+
+    virtual int handle_input(ACE_HANDLE = ACE_INVALID_HANDLE);
+    virtual int handle_output(ACE_HANDLE = ACE_INVALID_HANDLE);
+
+    virtual int handle_close(ACE_HANDLE = ACE_INVALID_HANDLE, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK);
+
+    void set_session(Session* session);
+
+private:
+    ssize_t noblk_send(ACE_Message_Block &message_block);
+
+    ACE_Message_Block input_buffer_;
+    Session* session_;
+    std::string _remoteAddress;
+    uint16 _remotePort;
+};
+
+#endif /* __REALMSOCKET_H__ */

src/server/shared/Realms/RealmList.cpp

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ */
+
+#include "Common.h"
+#include "RealmList.h"
+#include "DatabaseEnv.h"
+
+RealmList::RealmList() : m_UpdateInterval(0), m_NextUpdateTime(time(nullptr)) { }
+
+// Load the realm list from the database
+void RealmList::Initialize(uint32 updateInterval)
+{
+    m_UpdateInterval = updateInterval;
+
+    // Get the content of the realmlist table in the database
+    UpdateRealms(true);
+}
+
+void RealmList::UpdateRealm(uint32 id, const std::string& name, ACE_INET_Addr const& address, ACE_INET_Addr const& localAddr, ACE_INET_Addr const& localSubmask, uint8 icon, RealmFlags flag, uint8 timezone, AccountTypes allowedSecurityLevel, float popu, uint32 build)
+{
+    // Create new if not exist or update existed
+    Realm& realm = m_realms[name];
+
+    realm.m_ID = id;
+    realm.name = name;
+    realm.icon = icon;
+    realm.flag = flag;
+    realm.timezone = timezone;
+    realm.allowedSecurityLevel = allowedSecurityLevel;
+    realm.populationLevel = popu;
+
+    // Append port to IP address.
+    realm.ExternalAddress = address;
+    realm.LocalAddress = localAddr;
+    realm.LocalSubnetMask = localSubmask;
+    realm.gamebuild = build;
+}
+
+void RealmList::UpdateIfNeed()
+{
+    // maybe disabled or updated recently
+    if (!m_UpdateInterval || m_NextUpdateTime > time(NULL))
+        return;
+
+    m_NextUpdateTime = time(NULL) + m_UpdateInterval;
+
+    // Clears Realm list
+    m_realms.clear();
+
+    // Get the content of the realmlist table in the database
+    UpdateRealms();
+}
+
+void RealmList::UpdateRealms(bool init)
+{
+    sLog->outString("Updating Realm List...");
+
+    PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST);
+    PreparedQueryResult result = LoginDatabase.Query(stmt);
+
+    // Circle through results and add them to the realm map
+    if (result)
+    {
+        do
+        {
+            Field* fields = result->Fetch();
+            uint32 realmId              = fields[0].GetUInt32();
+            std::string name            = fields[1].GetString();
+            std::string externalAddress = fields[2].GetString();
+            std::string localAddress    = fields[3].GetString();
+            std::string localSubmask    = fields[4].GetString();
+            uint16 port                 = fields[5].GetUInt16();
+            uint8 icon                  = fields[6].GetUInt8();
+            RealmFlags flag             = RealmFlags(fields[7].GetUInt8());
+            uint8 timezone              = fields[8].GetUInt8();
+            uint8 allowedSecurityLevel  = fields[9].GetUInt8();
+            float pop                   = fields[10].GetFloat();
+            uint32 build                = fields[11].GetUInt32();
+
+            ACE_INET_Addr externalAddr(port, externalAddress.c_str(), AF_INET);
+            ACE_INET_Addr localAddr(port, localAddress.c_str(), AF_INET);
+            ACE_INET_Addr submask(0, localSubmask.c_str(), AF_INET);
+
+            UpdateRealm(realmId, name, externalAddr, localAddr, submask, icon, flag, timezone, (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), pop, build);
+
+            if (init)
+                sLog->outString("Added realm \"%s\" at %s:%u.", name.c_str(), m_realms[name].ExternalAddress.get_host_addr(), port);
+        }
+        while (result->NextRow());
+    }
+}

src/server/shared/Realms/RealmList.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2016+     AzerothCore <www.azerothcore.org>, released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2
+ * Copyright (C) 2008-2016 TrinityCore <http://www.trinitycore.org/>
+ * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
+ */
+
+#ifndef _REALMLIST_H
+#define _REALMLIST_H
+
+#include <ace/Singleton.h>
+#include <ace/Null_Mutex.h>
+#include <ace/INET_Addr.h>
+#include "Common.h"
+
+enum RealmFlags
+{
+    REALM_FLAG_NONE                              = 0x00,
+    REALM_FLAG_INVALID                           = 0x01,
+    REALM_FLAG_OFFLINE                           = 0x02,
+    REALM_FLAG_SPECIFYBUILD                      = 0x04,
+    REALM_FLAG_UNK1                              = 0x08,
+    REALM_FLAG_UNK2                              = 0x10,
+    REALM_FLAG_RECOMMENDED                       = 0x20,
+    REALM_FLAG_NEW                               = 0x40,
+    REALM_FLAG_FULL                              = 0x80
+};
+
+// Storage object for a realm
+struct Realm
+{
+    ACE_INET_Addr ExternalAddress;
+    ACE_INET_Addr LocalAddress;
+    ACE_INET_Addr LocalSubnetMask;
+    std::string name;
+    uint8 icon;
+    RealmFlags flag;
+    uint8 timezone;
+    uint32 m_ID;
+    AccountTypes allowedSecurityLevel;
+    float populationLevel;
+    uint32 gamebuild;
+};
+
+/// Storage object for the list of realms on the server
+class RealmList
+{
+public:
+    typedef std::map<std::string, Realm> RealmMap;
+
+    RealmList();
+    ~RealmList() { }
+
+    void Initialize(uint32 updateInterval);
+
+    void UpdateIfNeed();
+
+    void AddRealm(const Realm& NewRealm) { m_realms[NewRealm.name] = NewRealm; }
+
+    RealmMap::const_iterator begin() const { return m_realms.begin(); }
+    RealmMap::const_iterator end() const { return m_realms.end(); }
+    uint32 size() const { return m_realms.size(); }
+
+private:
+    void UpdateRealms(bool init=false);
+    void UpdateRealm(uint32 id, const std::string& name, ACE_INET_Addr const& address, ACE_INET_Addr const& localAddr, ACE_INET_Addr const& localSubmask, uint8 icon, RealmFlags flag, uint8 timezone, AccountTypes allowedSecurityLevel, float popu, uint32 build);
+
+    RealmMap m_realms;
+    uint32   m_UpdateInterval;
+    time_t   m_NextUpdateTime;
+};
+
+#define sRealmList ACE_Singleton<RealmList, ACE_Null_Mutex>::instance()
+
+#endif