[svn] Merge from Mangos:

3c7ac5bd3e20c33a22ac57c5c3bac23a0798dc9e 2008-10-23 19:06:27
Some endianess related fixes and cleanups. By VladimirMangos.

--HG--
branch : trunk

1 files changed, 570 insertions, 614 deletions

diff --git a/src/game/WorldSocket.cpp b/src/game/WorldSocket.cpp
index bf9dd0aefb4..620c2116c30 100644
--- a/src/game/WorldSocket.cpp
+++ b/src/game/WorldSocket.cpp
@@ -1,22 +1,22 @@
 /* 
- * Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
- *
- * Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
+* Copyright (C) 2005-2008 MaNGOS <http://www.mangosproject.org/>
+*
+* Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation; either version 2 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program; if not, write to the Free Software
+* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
 
 #include <ace/Message_Block.h>
 #include <ace/OS_NS_string.h>
@@ -54,14 +54,14 @@
 
 struct ServerPktHeader
 {
-  ACE_UINT16 size;
-  ACE_UINT16 cmd;
+    uint16 size;
+    uint16 cmd;
 };
 
 struct ClientPktHeader
 {
-  ACE_UINT16 size;
-  ACE_UINT32 cmd;
+    uint16 size;
+    uint32 cmd;
 };
 
 #if defined( __GNUC__ )
@@ -83,642 +83,607 @@ m_Seed (static_cast<uint32> (rand32 ())),
 m_OverSpeedPings (0),
 m_LastPingTime (ACE_Time_Value::zero)
 {
-  this->reference_counting_policy ().value (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
+    reference_counting_policy ().value (ACE_Event_Handler::Reference_Counting_Policy::ENABLED);
 }
 
 WorldSocket::~WorldSocket (void)
 {
-  if (m_RecvWPct)
-    delete m_RecvWPct;
+    if (m_RecvWPct)
+        delete m_RecvWPct;
 
-  if (m_OutBuffer)
-    m_OutBuffer->release ();
+    if (m_OutBuffer)
+        m_OutBuffer->release ();
 
-  this->closing_ = true;
+    closing_ = true;
 
-  this->peer ().close ();
+    peer ().close ();
 
-  WorldPacket* pct;
-  while (m_PacketQueue.dequeue_head (pct) == 0)
-    delete pct;
+    WorldPacket* pct;
+    while (m_PacketQueue.dequeue_head (pct) == 0)
+        delete pct;
 }
 
-bool
-WorldSocket::IsClosed (void) const
+bool WorldSocket::IsClosed (void) const
 {
-  return this->closing_;
+    return closing_;
 }
 
-void
-WorldSocket::CloseSocket (void)
+void WorldSocket::CloseSocket (void)
 {
-  {
-    ACE_GUARD (LockType, Guard, m_OutBufferLock);
-
-    if (this->closing_)
-      return;
+    {
+        ACE_GUARD (LockType, Guard, m_OutBufferLock);
 
-    this->closing_ = true;
+        if (closing_)
+        return;
 
-    this->peer ().close_writer ();
-  }
+        closing_ = true;
 
-  {
-    ACE_GUARD (LockType, Guard, m_SessionLock);
+        peer ().close_writer ();
+    }
 
-    m_Session = NULL;
-  }
+    {
+        ACE_GUARD (LockType, Guard, m_SessionLock);
 
+        m_Session = NULL;
+    }
 }
 
-const std::string&
-WorldSocket::GetRemoteAddress (void) const
+const std::string& WorldSocket::GetRemoteAddress (void) const
 {
-  return m_Address;
+    return m_Address;
 }
 
-int
-WorldSocket::SendPacket (const WorldPacket& pct)
+int WorldSocket::SendPacket (const WorldPacket& pct)
 {
-  ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
+    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 
-  if (this->closing_)
-    return -1;
+    if (closing_)
+        return -1;
 
-  // Dump outgoing packet.
-  if (sWorldLog.LogWorld ())
+    // Dump outgoing packet.
+    if (sWorldLog.LogWorld ())
     {
-      sWorldLog.Log ("SERVER:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
+        sWorldLog.Log ("SERVER:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
                      (uint32) get_handle (),
                      pct.size (),
                      LookupOpcodeName (pct.GetOpcode ()),
                      pct.GetOpcode ());
 
-      uint32 p = 0;
-      while (p < pct.size ())
+        uint32 p = 0;
+        while (p < pct.size ())
         {
-          for (uint32 j = 0; j < 16 && p < pct.size (); j++)
-            sWorldLog.Log ("%.2X ", const_cast<WorldPacket&> (pct)[p++]);
+            for (uint32 j = 0; j < 16 && p < pct.size (); j++)
+                sWorldLog.Log ("%.2X ", const_cast<WorldPacket&>(pct)[p++]);
 
-          sWorldLog.Log ("\n");
+            sWorldLog.Log ("\n");
         }
 
-      sWorldLog.Log ("\n\n");
+        sWorldLog.Log ("\n\n");
     }
 
-  if (iSendPacket (pct) == -1)
+    if (iSendPacket (pct) == -1)
     {
-      WorldPacket* npct;
+        WorldPacket* npct;
 
-      ACE_NEW_RETURN (npct, WorldPacket (pct), -1);
+        ACE_NEW_RETURN (npct, WorldPacket (pct), -1);
 
-      // NOTE maybe check of the size of the queue can be good ?
-      // to make it bounded instead of unbounded
-      if (m_PacketQueue.enqueue_tail (npct) == -1)
+        // NOTE maybe check of the size of the queue can be good ?
+        // to make it bounded instead of unbounded
+        if (m_PacketQueue.enqueue_tail (npct) == -1)
         {
-          delete npct;
-          sLog.outError ("WorldSocket::SendPacket: m_PacketQueue.enqueue_tail failed");
-          return -1;
+            delete npct;
+            sLog.outError ("WorldSocket::SendPacket: m_PacketQueue.enqueue_tail failed");
+            return -1;
         }
     }
 
-  return 0;
+    return 0;
 }
 
-long
-WorldSocket::AddReference (void)
+long WorldSocket::AddReference (void)
 {
-  return static_cast<long> (this->add_reference ());
+    return static_cast<long> (add_reference ());
 }
 
-long
-WorldSocket::RemoveReference (void)
+long WorldSocket::RemoveReference (void)
 {
-  return static_cast<long> (this->remove_reference ());
+    return static_cast<long> (remove_reference ());
 }
 
-int
-WorldSocket::open (void *a)
+int WorldSocket::open (void *a)
 {
-  ACE_UNUSED_ARG (a);
+    ACE_UNUSED_ARG (a);
 
-  // Prevent double call to this func.
-  if (m_OutBuffer)
-    return -1;
+    // Prevent double call to this func.
+    if (m_OutBuffer)
+        return -1;
 
-  // This will also prevent the socket from being Updated
-  // while we are initializing it.
-  m_OutActive = true;
+    // This will also prevent the socket from being Updated
+    // while we are initializing it.
+    m_OutActive = true;
 
-  // Hook for the manager.
-  if (sWorldSocketMgr->OnSocketOpen (this) == -1)
-    return -1;
+    // Hook for the manager.
+    if (sWorldSocketMgr->OnSocketOpen (this) == -1)
+        return -1;
 
-  // Allocate the buffer.
-  ACE_NEW_RETURN (m_OutBuffer, ACE_Message_Block (m_OutBufferSize), -1);
+    // Allocate the buffer.
+    ACE_NEW_RETURN (m_OutBuffer, ACE_Message_Block (m_OutBufferSize), -1);
 
-  // Store peer address.
-  ACE_INET_Addr remote_addr;
+    // Store peer address.
+    ACE_INET_Addr remote_addr;
 
-  if (this->peer ().get_remote_addr (remote_addr) == -1)
+    if (peer ().get_remote_addr (remote_addr) == -1)
     {
-      sLog.outError ("WorldSocket::open: peer ().get_remote_addr errno = %s", ACE_OS::strerror (errno));
-      return -1;
+        sLog.outError ("WorldSocket::open: peer ().get_remote_addr errno = %s", ACE_OS::strerror (errno));
+        return -1;
     }
 
-  m_Address = remote_addr.get_host_addr ();
+    m_Address = remote_addr.get_host_addr ();
 
-  // Send startup packet.
-  WorldPacket packet (SMSG_AUTH_CHALLENGE, 4);
-  packet << m_Seed;
+    // Send startup packet.
+    WorldPacket packet (SMSG_AUTH_CHALLENGE, 4);
+    packet << m_Seed;
 
-  if (SendPacket (packet) == -1)
-    return -1;
+    if (SendPacket (packet) == -1)
+        return -1;
 
-  // Register with ACE Reactor
-  if (this->reactor ()->register_handler
-      (this,
-       ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK) == -1)
+    // Register with ACE Reactor
+    if (reactor ()->register_handler(this, ACE_Event_Handler::READ_MASK | ACE_Event_Handler::WRITE_MASK) == -1)
     {
-      sLog.outError ("WorldSocket::open: unable to register client handler errno = %s", ACE_OS::strerror (errno));
-      return -1;
+        sLog.outError ("WorldSocket::open: unable to register client handler errno = %s", ACE_OS::strerror (errno));
+        return -1;
     }
 
-  // reactor takes care of the socket from now on
-  this->remove_reference ();
+    // reactor takes care of the socket from now on
+    remove_reference ();
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::close (int)
+int WorldSocket::close (int)
 {
-  this->shutdown ();
+    shutdown ();
 
-  this->closing_ = true;
+    closing_ = true;
 
-  this->remove_reference ();
+    remove_reference ();
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::handle_input (ACE_HANDLE)
+int WorldSocket::handle_input (ACE_HANDLE)
 {
-  if (this->closing_)
-    return -1;
+    if (closing_)
+        return -1;
 
-  switch (this->handle_input_missing_data ())
+    switch (handle_input_missing_data ())
     {
-    case -1 :
-      {
-        if ((errno == EWOULDBLOCK) ||
-            (errno == EAGAIN))
-          {
-            //return 0;
-            return this->Update (); // interesting line ,isnt it ?
-          }
-
-        DEBUG_LOG ("WorldSocket::handle_input: Peer error closing connection errno = %s", ACE_OS::strerror (errno));
+        case -1 :
+        {
+            if ((errno == EWOULDBLOCK) ||
+                (errno == EAGAIN))
+            {
+                return Update (); // interesting line ,isnt it ?
+            }
 
-        return -1;
-      }
-    case 0:
-      {
-        DEBUG_LOG ("WorldSocket::handle_input: Peer has closed connection\n");
+            DEBUG_LOG ("WorldSocket::handle_input: Peer error closing connection errno = %s", ACE_OS::strerror (errno));
 
-        errno = ECONNRESET;
+            errno = ECONNRESET;
+            return -1;
+        }
+        case 0:
+        {
+            DEBUG_LOG ("WorldSocket::handle_input: Peer has closed connection\n");
 
-        return -1;
-      }
-    case 1:
-      return 1;
+            errno = ECONNRESET;
+            return -1;
+        }
+        case 1:
+            return 1;
+        default:
+            return Update (); // another interesting line ;)
     }
 
-  //return 0;
-  return this->Update (); // another interesting line ;)
+    ACE_NOTREACHED(return -1);
 }
 
-int
-WorldSocket::handle_output (ACE_HANDLE)
+int WorldSocket::handle_output (ACE_HANDLE)
 {
-  ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
+    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 
-  if (this->closing_)
-    return -1;
+    if (closing_)
+        return -1;
 
-  const size_t send_len = m_OutBuffer->length ();
+    const size_t send_len = m_OutBuffer->length ();
 
-  if (send_len == 0)
-    return this->cancel_wakeup_output (Guard);
+    if (send_len == 0)
+        return cancel_wakeup_output (Guard);
 
-  // TODO SO_NOSIGPIPE on platforms that support it
 #ifdef MSG_NOSIGNAL
-  ssize_t n = this->peer ().send (m_OutBuffer->rd_ptr (), send_len, MSG_NOSIGNAL);
+    ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len, MSG_NOSIGNAL);
 #else
-  ssize_t n = this->peer ().send (m_OutBuffer->rd_ptr (), send_len);
+    ssize_t n = peer ().send (m_OutBuffer->rd_ptr (), send_len);
 #endif // MSG_NOSIGNAL
 
-  if (n == 0)
-    return -1;
-  else if (n == -1)
+    if (n == 0)
+        return -1;
+    else if (n == -1)
     {
-      if (errno == EWOULDBLOCK || errno == EAGAIN)
-        return this->schedule_wakeup_output (Guard);
+        if (errno == EWOULDBLOCK || errno == EAGAIN)
+            return schedule_wakeup_output (Guard);
 
-      return -1;
+        return -1;
     }
-  else if (n < send_len) //now n > 0
+    else if (n < send_len) //now n > 0
     {
-      m_OutBuffer->rd_ptr (static_cast<size_t> (n));
+        m_OutBuffer->rd_ptr (static_cast<size_t> (n));
 
-      // move the data to the base of the buffer
-      m_OutBuffer->crunch ();
+        // move the data to the base of the buffer
+        m_OutBuffer->crunch ();
 
-      return this->schedule_wakeup_output (Guard);
+        return schedule_wakeup_output (Guard);
     }
-  else //now n == send_len
+    else //now n == send_len
     {
-      m_OutBuffer->reset ();
+        m_OutBuffer->reset ();
 
-      if (!iFlushPacketQueue ())
-        return this->cancel_wakeup_output (Guard);
-      else
-        return this->schedule_wakeup_output (Guard);
+        if (!iFlushPacketQueue ())
+            return cancel_wakeup_output (Guard);
+        else
+            return schedule_wakeup_output (Guard);
     }
 
-  ACE_NOTREACHED (return 0);
+    ACE_NOTREACHED (return 0);
 }
 
-int
-WorldSocket::handle_close (ACE_HANDLE h, ACE_Reactor_Mask)
+int WorldSocket::handle_close (ACE_HANDLE h, ACE_Reactor_Mask)
 {
-  // Critical section
-  {
-    ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
+    // Critical section
+    {
+        ACE_GUARD_RETURN (LockType, Guard, m_OutBufferLock, -1);
 
-    this->closing_ = true;
+        closing_ = true;
 
-    if (h == ACE_INVALID_HANDLE)
-      this->peer ().close_writer ();
-  }
+        if (h == ACE_INVALID_HANDLE)
+            peer ().close_writer ();
+    }
 
-  // Critical section
-  {
-    ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
+    // Critical section
+    {
+        ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 
-    m_Session = NULL;
-  }
+        m_Session = NULL;
+    }
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::Update (void)
+int WorldSocket::Update (void)
 {
-  if (this->closing_)
-    return -1;
+    if (closing_)
+        return -1;
 
-  if (m_OutActive || m_OutBuffer->length () == 0)
-    return 0;
+    if (m_OutActive || m_OutBuffer->length () == 0)
+        return 0;
 
-  return this->handle_output (this->get_handle ());
+    return handle_output (get_handle ());
 }
 
-int
-WorldSocket::handle_input_header (void)
+int WorldSocket::handle_input_header (void)
 {
-  ACE_ASSERT (m_RecvWPct == NULL);
+    ACE_ASSERT (m_RecvWPct == NULL);
 
-  if (m_Header.length () != sizeof (ClientPktHeader))
-    {
-      sLog.outError ("WorldSocket::handle_input_header: internal error: invalid header");
-      errno = EINVAL;
-      return -1;
-    }
-
-  m_Crypt.DecryptRecv ((ACE_UINT8*) m_Header.rd_ptr (), sizeof (ClientPktHeader));
+    ACE_ASSERT (m_Header.length () == sizeof (ClientPktHeader));
 
-  ClientPktHeader& header = *((ClientPktHeader*) m_Header.rd_ptr ());
+    m_Crypt.DecryptRecv ((ACE_UINT8*) m_Header.rd_ptr (), sizeof (ClientPktHeader));
 
-  header.size = ACE_NTOHS (header.size);
+    ClientPktHeader& header = *((ClientPktHeader*) m_Header.rd_ptr ());
 
-#if ACE_BYTE_ORDER == ACE_BIG_ENDIAN
-  header.cmd = ACE_SWAP_LONG (header.cmd)
-#endif // ACE_BIG_ENDIAN
+    EndianConvertReverse(header.size);
+    EndianConvert(header.cmd);
 
-  if ((header.size < 4) ||
-      (header.size > 10240) ||
-      (header.cmd <= 0) ||
-      (header.cmd > 10240)
-      )
+    if ((header.size < 4) || (header.size > 10240) ||
+        (header.cmd  < 0) || (header.cmd  > 10240) )
     {
-      sLog.outError ("WorldSocket::handle_input_header: client sent mailformed packet size = %d , cmd = %d",
-                     header.size,
-                     header.cmd);
+        sLog.outError ("WorldSocket::handle_input_header: client sent mailformed packet size = %d , cmd = %d",
+                       header.size, header.cmd);
 
-      errno = EINVAL;
-      return -1;
+        errno = EINVAL;
+        return -1;
     }
 
-  header.size -= 4;
+    header.size -= 4;
 
-  ACE_NEW_RETURN (m_RecvWPct, WorldPacket ((uint16) header.cmd, header.size), -1);
+    ACE_NEW_RETURN (m_RecvWPct, WorldPacket ((uint16) header.cmd, header.size), -1);
 
-  if (header.size > 0)
+    if(header.size > 0)
     {
-      m_RecvWPct->resize (header.size);
-      m_RecvPct.base ((char*) m_RecvWPct->contents (), m_RecvWPct->size ());
+        m_RecvWPct->resize (header.size);
+        m_RecvPct.base ((char*) m_RecvWPct->contents (), m_RecvWPct->size ());
     }
-  else
+    else
     {
-      ACE_ASSERT (m_RecvPct.space () == 0);
+        ACE_ASSERT(m_RecvPct.space() == 0);
     }
 
-
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::handle_input_payload (void)
+int WorldSocket::handle_input_payload (void)
 {
-  // set errno properly here on error !!!
-  // now have a header and payload
+    // set errno properly here on error !!!
+    // now have a header and payload
 
-  ACE_ASSERT (m_RecvPct.space () == 0);
-  ACE_ASSERT (m_Header.space () == 0);
-  ACE_ASSERT (m_RecvWPct != NULL);
+    ACE_ASSERT (m_RecvPct.space () == 0);
+    ACE_ASSERT (m_Header.space () == 0);
+    ACE_ASSERT (m_RecvWPct != NULL);
 
-  const int ret = this->ProcessIncoming (m_RecvWPct);
+    const int ret = ProcessIncoming (m_RecvWPct);
 
-  m_RecvPct.base (NULL, 0);
-  m_RecvPct.reset ();
-  m_RecvWPct = NULL;
+    m_RecvPct.base (NULL, 0);
+    m_RecvPct.reset ();
+    m_RecvWPct = NULL;
 
-  m_Header.reset ();
+    m_Header.reset ();
 
-  if (ret == -1)
-    errno = EINVAL;
+    if (ret == -1)
+        errno = EINVAL;
 
-  return ret;
+    return ret;
 }
 
-int
-WorldSocket::handle_input_missing_data (void)
+int WorldSocket::handle_input_missing_data (void)
 {
-  char buf [1024];
+    char buf [1024];
 
-  ACE_Data_Block db (sizeof (buf),
-                     ACE_Message_Block::MB_DATA,
-                     buf,
-                     0,
-                     0,
-                     ACE_Message_Block::DONT_DELETE,
-                     0);
+    ACE_Data_Block db ( sizeof (buf),
+                        ACE_Message_Block::MB_DATA,
+                        buf,
+                        0,
+                        0,
+                        ACE_Message_Block::DONT_DELETE,
+                        0);
 
-  ACE_Message_Block message_block (&db,
-                                   ACE_Message_Block::DONT_DELETE,
-                                   0);
+    ACE_Message_Block message_block(&db,
+                                    ACE_Message_Block::DONT_DELETE,
+                                    0);
 
-  const size_t recv_size = message_block.space ();
+    const size_t recv_size = message_block.space ();
 
-  const ssize_t n = this->peer ().recv (message_block.wr_ptr (),
-                                        recv_size);
+    const ssize_t n = peer ().recv (message_block.wr_ptr (),
+                                          recv_size);
 
-  if (n <= 0)
-    return n;
+    if (n <= 0)
+        return n;
 
-  message_block.wr_ptr (n);
+    message_block.wr_ptr (n);
 
-  while (message_block.length () > 0)
+    while (message_block.length () > 0)
     {
-      if (m_Header.space () > 0)
+        if (m_Header.space () > 0)
         {
-          //need to recieve the header
-          const size_t to_header = (message_block.length () > m_Header.space () ? m_Header.space () : message_block.length ());
-          m_Header.copy (message_block.rd_ptr (), to_header);
-          message_block.rd_ptr (to_header);
+            //need to recieve the header
+            const size_t to_header = (message_block.length () > m_Header.space () ? m_Header.space () : message_block.length ());
+            m_Header.copy (message_block.rd_ptr (), to_header);
+            message_block.rd_ptr (to_header);
 
-          if (m_Header.space () > 0)
+            if (m_Header.space () > 0)
             {
-              //couldnt recieve the whole header this time
-              ACE_ASSERT (message_block.length () == 0);
-              errno = EWOULDBLOCK;
-              return -1;
+                //couldnt recieve the whole header this time
+                ACE_ASSERT (message_block.length () == 0);
+                errno = EWOULDBLOCK;
+                return -1;
             }
 
           //we just recieved nice new header
-          if (this->handle_input_header () == -1)
+            if (handle_input_header () == -1)
             {
-              ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
-              return -1;
+                ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
+                return -1;
             }
         }
 
-      // Its possible on some error situations that this happens
-      // for example on closing when epoll recieves more chunked data and stuff
-      // hope this is not hack ,as proper m_RecvWPct is asserted around
-      if (!m_RecvWPct)
+        // Its possible on some error situations that this happens
+        // for example on closing when epoll recieves more chunked data and stuff
+        // hope this is not hack ,as proper m_RecvWPct is asserted around
+        if (!m_RecvWPct)
         {
-          sLog.outError ("Forsing close on input m_RecvWPct = NULL");
-          errno = EINVAL;
-          return -1;
+            sLog.outError ("Forsing close on input m_RecvWPct = NULL");
+            errno = EINVAL;
+            return -1;
         }
 
-      // We have full readed header, now check the data payload
-      if (m_RecvPct.space () > 0)
+        // We have full readed header, now check the data payload
+        if (m_RecvPct.space () > 0)
         {
-          //need more data in the payload
-          const size_t to_data = (message_block.length () > m_RecvPct.space () ? m_RecvPct.space () : message_block.length ());
-          m_RecvPct.copy (message_block.rd_ptr (), to_data);
-          message_block.rd_ptr (to_data);
+            //need more data in the payload
+            const size_t to_data = (message_block.length () > m_RecvPct.space () ? m_RecvPct.space () : message_block.length ());
+            m_RecvPct.copy (message_block.rd_ptr (), to_data);
+            message_block.rd_ptr (to_data);
 
-          if (m_RecvPct.space () > 0)
+            if (m_RecvPct.space () > 0)
             {
-              //couldnt recieve the whole data this time
-              ACE_ASSERT (message_block.length () == 0);
-              errno = EWOULDBLOCK;
-              return -1;
+                //couldnt recieve the whole data this time
+                ACE_ASSERT (message_block.length () == 0);
+                errno = EWOULDBLOCK;
+                return -1;
             }
         }
 
-      //just recieved fresh new payload
-      if (this->handle_input_payload () == -1)
+        //just recieved fresh new payload
+        if (handle_input_payload () == -1)
         {
-          ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
-          return -1;
+            ACE_ASSERT ((errno != EWOULDBLOCK) && (errno != EAGAIN));
+            return -1;
         }
     }
 
-  return n == recv_size ? 1 : 2;
+    return n == recv_size ? 1 : 2;
 }
 
-int
-WorldSocket::cancel_wakeup_output (GuardType& g)
+int WorldSocket::cancel_wakeup_output (GuardType& g)
 {
-  if (!m_OutActive)
-    return 0;
+    if (!m_OutActive)
+        return 0;
 
-  m_OutActive = false;
+    m_OutActive = false;
 
-  g.release ();
+    g.release ();
 
-  if (this->reactor ()->cancel_wakeup
-      (this, ACE_Event_Handler::WRITE_MASK) == -1)
+    if (reactor ()->cancel_wakeup
+        (this, ACE_Event_Handler::WRITE_MASK) == -1)
     {
-      // would be good to store errno from reactor with errno guard
-      sLog.outError ("WorldSocket::cancel_wakeup_output");
-      return -1;
+        // would be good to store errno from reactor with errno guard
+        sLog.outError ("WorldSocket::cancel_wakeup_output");
+        return -1;
     }
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::schedule_wakeup_output (GuardType& g)
+int WorldSocket::schedule_wakeup_output (GuardType& g)
 {
-  if (m_OutActive)
-    return 0;
+    if (m_OutActive)
+        return 0;
 
-  m_OutActive = true;
+    m_OutActive = true;
 
-  g.release ();
+    g.release ();
 
-  if (this->reactor ()->schedule_wakeup
-      (this, ACE_Event_Handler::WRITE_MASK) == -1)
+    if (reactor ()->schedule_wakeup
+        (this, ACE_Event_Handler::WRITE_MASK) == -1)
     {
-      sLog.outError ("WorldSocket::schedule_wakeup_output");
-      return -1;
+        sLog.outError ("WorldSocket::schedule_wakeup_output");
+        return -1;
     }
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::ProcessIncoming (WorldPacket* new_pct)
+int WorldSocket::ProcessIncoming (WorldPacket* new_pct)
 {
-  ACE_ASSERT (new_pct);
+    ACE_ASSERT (new_pct);
 
-  // manage memory ;)
-  ACE_Auto_Ptr<WorldPacket> aptr (new_pct);
+    // manage memory ;)
+    ACE_Auto_Ptr<WorldPacket> aptr (new_pct);
 
-  const ACE_UINT16 opcode = new_pct->GetOpcode ();
+    const ACE_UINT16 opcode = new_pct->GetOpcode ();
 
-  if (this->closing_)
-    return -1;
+    if (closing_)
+        return -1;
 
-  // dump recieved packet
-  if (sWorldLog.LogWorld ())
+    // dump recieved packet
+    if (sWorldLog.LogWorld ())
     {
-      sWorldLog.Log ("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
+        sWorldLog.Log ("CLIENT:\nSOCKET: %u\nLENGTH: %u\nOPCODE: %s (0x%.4X)\nDATA:\n",
                      (uint32) get_handle (),
                      new_pct->size (),
                      LookupOpcodeName (new_pct->GetOpcode ()),
                      new_pct->GetOpcode ());
 
-      uint32 p = 0;
-      while (p < new_pct->size ())
+        uint32 p = 0;
+        while (p < new_pct->size ())
         {
-          for (uint32 j = 0; j < 16 && p < new_pct->size (); j++)
-            sWorldLog.Log ("%.2X ", (*new_pct)[p++]);
-          sWorldLog.Log ("\n");
+            for (uint32 j = 0; j < 16 && p < new_pct->size (); j++)
+                sWorldLog.Log ("%.2X ", (*new_pct)[p++]);
+            sWorldLog.Log ("\n");
         }
-      sWorldLog.Log ("\n\n");
+        sWorldLog.Log ("\n\n");
     }
 
-  // like one switch ;)
-  if (opcode == CMSG_PING)
+    // like one switch ;)
+    if (opcode == CMSG_PING)
     {
-      return HandlePing (*new_pct);
+        return HandlePing (*new_pct);
     }
-  else if (opcode == CMSG_AUTH_SESSION)
+    else if (opcode == CMSG_AUTH_SESSION)
     {
-      if (m_Session)
+        if (m_Session)
         {
-          sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again");
-          return -1;
+            sLog.outError ("WorldSocket::ProcessIncoming: Player send CMSG_AUTH_SESSION again");
+            return -1;
         }
 
-      return HandleAuthSession (*new_pct);
+        return HandleAuthSession (*new_pct);
     }
-  else if (opcode == CMSG_KEEP_ALIVE)
+    else if (opcode == CMSG_KEEP_ALIVE)
     {
-      DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size ());
+        DEBUG_LOG ("CMSG_KEEP_ALIVE ,size: %d", new_pct->size ());
 
-      return 0;
+        return 0;
     }
-  else
+    else
     {
-      ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
+        ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 
-      if (m_Session != NULL)
+        if (m_Session != NULL)
         {
-          // OK ,give the packet to WorldSession
-          aptr.release ();
-          // WARNINIG here we call it with locks held.
-          // Its possible to cause deadlock if QueuePacket calls back
-          m_Session->QueuePacket (new_pct);
-          return 0;
+            // OK ,give the packet to WorldSession
+            aptr.release ();
+            // WARNINIG here we call it with locks held.
+            // Its possible to cause deadlock if QueuePacket calls back
+            m_Session->QueuePacket (new_pct);
+            return 0;
         }
-      else
+        else
         {
-          sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = ", opcode);
-          return -1;
+            sLog.outError ("WorldSocket::ProcessIncoming: Client not authed opcode = ", opcode);
+            return -1;
         }
     }
 
-  ACE_NOTREACHED (return 0);
+    ACE_NOTREACHED (return 0);
 }
 
-int
-WorldSocket::HandleAuthSession (WorldPacket& recvPacket)
+int WorldSocket::HandleAuthSession (WorldPacket& recvPacket)
 {
-  uint8 digest[20];
-  uint32 clientSeed;
-  uint32 unk2;
-  uint32 BuiltNumberClient;
-  uint32 id, security;
-  //uint8 expansion = 0;
-  LocaleConstant locale;
-  std::string account;
-  Sha1Hash sha1;
-  BigNumber v, s, g, N, x, I;
-  WorldPacket packet, SendAddonPacked;
-
-  BigNumber K;
-
-  if (recvPacket.size () < (4 + 4 + 1 + 4 + 20))
-    {
-      sLog.outError ("WorldSocket::HandleAuthSession: wrong packet size");
-      return -1;
+    // NOTE: ATM the socket is singlethreaded, have this in mind ...
+    uint8 digest[20];
+    uint32 clientSeed;
+    uint32 unk2;
+    uint32 BuiltNumberClient;
+    uint32 id, security;
+    //uint8 expansion = 0;
+    LocaleConstant locale;
+    std::string account;
+    Sha1Hash sha1;
+    BigNumber v, s, g, N, x, I;
+    WorldPacket packet, SendAddonPacked;
+
+    BigNumber K;
+
+    if (recvPacket.size () < (4 + 4 + 1 + 4 + 20))
+    {
+        sLog.outError ("WorldSocket::HandleAuthSession: wrong packet size");
+        return -1;
     }
 
-  // Read the content of the packet
-  recvPacket >> BuiltNumberClient; // for now no use
-  recvPacket >> unk2;
-  recvPacket >> account;
+    // Read the content of the packet
+    recvPacket >> BuiltNumberClient;                        // for now no use
+    recvPacket >> unk2;
+    recvPacket >> account;
 
-  if (recvPacket.size () < (4 + 4 + (account.size () + 1) + 4 + 20))
+    if (recvPacket.size () < (4 + 4 + (account.size () + 1) + 4 + 20))
     {
-      sLog.outError ("WorldSocket::HandleAuthSession: wrong packet size second check");
-      return -1;
+        sLog.outError ("WorldSocket::HandleAuthSession: wrong packet size second check");
+        return -1;
     }
 
-  recvPacket >> clientSeed;
-  recvPacket.read (digest, 20);
+    recvPacket >> clientSeed;
+    recvPacket.read (digest, 20);
 
-  DEBUG_LOG ("WorldSocket::HandleAuthSession: client %u, unk2 %u, account %s, clientseed %u",
-             BuiltNumberClient,
-             unk2,
-             account.c_str (),
-             clientSeed);
+    DEBUG_LOG ("WorldSocket::HandleAuthSession: client %u, unk2 %u, account %s, clientseed %u",
+                BuiltNumberClient,
+                unk2,
+                account.c_str (),
+                clientSeed);
 
-  // Get the account information from the realmd database
-  std::string safe_account = account; // Duplicate, else will screw the SHA hash verification below
-  loginDatabase.escape_string (safe_account);
-  // No SQL injection, username escaped.
+    // Get the account information from the realmd database
+    std::string safe_account = account; // Duplicate, else will screw the SHA hash verification below
+    loginDatabase.escape_string (safe_account);
+    // No SQL injection, username escaped.
 
-  QueryResult *result =
+    QueryResult *result =
           loginDatabase.PQuery ("SELECT "
                                 "id, " //0
                                 "gmlevel, " //1
@@ -735,107 +700,106 @@ WorldSocket::HandleAuthSession (WorldPacket& recvPacket)
                                 "WHERE username = '%s'",
                                 safe_account.c_str ());
 
-  // Stop if the account is not found
-  if (!result)
+    // Stop if the account is not found
+    if (!result)
     {
-      packet.Initialize (SMSG_AUTH_RESPONSE, 1);
-      packet << uint8 (AUTH_UNKNOWN_ACCOUNT);
+        packet.Initialize (SMSG_AUTH_RESPONSE, 1);
+        packet << uint8 (AUTH_UNKNOWN_ACCOUNT);
 
-      SendPacket (packet);
+        SendPacket (packet);
 
-      sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (unknown account).");
-      return -1;
+        sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (unknown account).");
+        return -1;
     }
 
-  Field* fields = result->Fetch ();
+    Field* fields = result->Fetch ();
 
     uint8 expansion = fields[8].GetUInt8();
     uint32 world_expansion = sWorld.getConfig(CONFIG_EXPANSION);
     if(expansion > world_expansion)
         expansion = world_expansion;
 
-  N.SetHexStr ("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7");
-  g.SetDword (7);
-  I.SetHexStr (fields[5].GetString ());
+    N.SetHexStr ("894B645E89E1535BBDAD5B8B290650530801B18EBFBF5E8FAB3C82872A3E9BB7");
+    g.SetDword (7);
+    I.SetHexStr (fields[5].GetString ());
 
-  //In case of leading zeros in the I hash, restore them
-  uint8 mDigest[SHA_DIGEST_LENGTH];
-  memset (mDigest, 0, SHA_DIGEST_LENGTH);
+    //In case of leading zeros in the I hash, restore them
+    uint8 mDigest[SHA_DIGEST_LENGTH];
+    memset (mDigest, 0, SHA_DIGEST_LENGTH);
 
-  if (I.GetNumBytes () <= SHA_DIGEST_LENGTH)
-    memcpy (mDigest, I.AsByteArray (), I.GetNumBytes ());
+    if (I.GetNumBytes () <= SHA_DIGEST_LENGTH)
+        memcpy (mDigest, I.AsByteArray (), I.GetNumBytes ());
 
-  std::reverse (mDigest, mDigest + SHA_DIGEST_LENGTH);
+    std::reverse (mDigest, mDigest + SHA_DIGEST_LENGTH);
 
-  s.SetHexStr (fields[7].GetString ());
-  sha1.UpdateData (s.AsByteArray (), s.GetNumBytes ());
-  sha1.UpdateData (mDigest, SHA_DIGEST_LENGTH);
-  sha1.Finalize ();
-  x.SetBinary (sha1.GetDigest (), sha1.GetLength ());
-  v = g.ModExp (x, N);
+    s.SetHexStr (fields[7].GetString ());
+    sha1.UpdateData (s.AsByteArray (), s.GetNumBytes ());
+    sha1.UpdateData (mDigest, SHA_DIGEST_LENGTH);
+    sha1.Finalize ();
+    x.SetBinary (sha1.GetDigest (), sha1.GetLength ());
+    v = g.ModExp (x, N);
 
-  const char* sStr = s.AsHexStr (); //Must be freed by OPENSSL_free()
-  const char* vStr = v.AsHexStr (); //Must be freed by OPENSSL_free()
-  const char* vold = fields[6].GetString ();
+    const char* sStr = s.AsHexStr (); //Must be freed by OPENSSL_free()
+    const char* vStr = v.AsHexStr (); //Must be freed by OPENSSL_free()
+    const char* vold = fields[6].GetString ();
 
-  DEBUG_LOG ("WorldSocket::HandleAuthSession: "
-             "(s,v) check s: %s v_old: %s v_new: %s",
-             sStr,
-             vold,
-             vStr);
+    DEBUG_LOG ("WorldSocket::HandleAuthSession: (s,v) check s: %s v_old: %s v_new: %s",
+                sStr,
+                vold,
+                vStr);
 
-  loginDatabase.PExecute ("UPDATE account "
-                          "SET "
-                          "v = '0', "
-                          "s = '0' "
-                          "WHERE username = '%s'",
-                          safe_account.c_str ());
+    loginDatabase.PExecute ("UPDATE account "
+                            "SET "
+                            "v = '0', "
+                            "s = '0' "
+                            "WHERE username = '%s'",
+                            safe_account.c_str ());
 
-  if (!vold || strcmp (vStr, vold))
+    if (!vold || strcmp (vStr, vold))
     {
-      packet.Initialize (SMSG_AUTH_RESPONSE, 1);
-      packet << uint8 (AUTH_UNKNOWN_ACCOUNT);
-      SendPacket (packet);
-      delete result;
-      OPENSSL_free ((void*) sStr);
-      OPENSSL_free ((void*) vStr);
-
-      sLog.outBasic ("WorldSocket::HandleAuthSession: User not logged.");
-      return -1;
+        packet.Initialize (SMSG_AUTH_RESPONSE, 1);
+        packet << uint8 (AUTH_UNKNOWN_ACCOUNT);
+        SendPacket (packet);
+        delete result;
+        OPENSSL_free ((void*) sStr);
+        OPENSSL_free ((void*) vStr);
+
+        sLog.outBasic ("WorldSocket::HandleAuthSession: User not logged.");
+        return -1;
     }
 
-  OPENSSL_free ((void*) sStr);
-  OPENSSL_free ((void*) vStr);
+    OPENSSL_free ((void*) sStr);
+    OPENSSL_free ((void*) vStr);
 
-  ///- Re-check ip locking (same check as in realmd).
-  if (fields[4].GetUInt8 () == 1) // if ip is locked
+    ///- Re-check ip locking (same check as in realmd).
+    if (fields[4].GetUInt8 () == 1) // if ip is locked
     {
-      if (strcmp (fields[3].GetString (), GetRemoteAddress ().c_str ()))
+        if (strcmp (fields[3].GetString (), GetRemoteAddress ().c_str ()))
         {
-          packet.Initialize (SMSG_AUTH_RESPONSE, 1);
-          packet << uint8 (AUTH_FAILED);
-          SendPacket (packet);
+            packet.Initialize (SMSG_AUTH_RESPONSE, 1);
+            packet << uint8 (AUTH_FAILED);
+            SendPacket (packet);
 
-          delete result;
-          sLog.outBasic ("WorldSocket::HandleAuthSession: Sent Auth Response (Account IP differs).");
-          return -1;
+            delete result;
+            sLog.outBasic ("WorldSocket::HandleAuthSession: Sent Auth Response (Account IP differs).");
+            return -1;
         }
     }
 
-  id = fields[0].GetUInt32 ();
-  security = fields[1].GetUInt16 ();
-  K.SetHexStr (fields[2].GetString ());
+    id = fields[0].GetUInt32 ();
+    security = fields[1].GetUInt16 ();
+    K.SetHexStr (fields[2].GetString ());
 
-  time_t mutetime = time_t (fields[9].GetUInt64 ());
+    time_t mutetime = time_t (fields[9].GetUInt64 ());
 
-  locale = LocaleConstant (fields[10].GetUInt8 ());
-  if (locale >= MAX_LOCALE)
-    locale = LOCALE_enUS;
+    locale = LocaleConstant (fields[10].GetUInt8 ());
+    if (locale >= MAX_LOCALE)
+        locale = LOCALE_enUS;
 
-  delete result;
+    delete result;
 
-  // Re-check account ban (same check as in realmd) 
-  QueryResult *banresult =
+    // Re-check account ban (same check as in realmd)
+    QueryResult *banresult =
           loginDatabase.PQuery ("SELECT "
                                 "bandate, "
                                 "unbandate "
@@ -844,219 +808,211 @@ WorldSocket::HandleAuthSession (WorldPacket& recvPacket)
                                 "AND active = 1",
                                 id);
 
-  if (banresult) // if account banned
+    if (banresult) // if account banned
     {
-      packet.Initialize (SMSG_AUTH_RESPONSE, 1);
-      packet << uint8 (AUTH_BANNED);
-      SendPacket (packet);
+        packet.Initialize (SMSG_AUTH_RESPONSE, 1);
+        packet << uint8 (AUTH_BANNED);
+        SendPacket (packet);
 
-      delete banresult;
+        delete banresult;
 
-      sLog.outBasic ("WorldSocket::HandleAuthSession: Sent Auth Response (Account banned).");
-      return -1;
+        sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (Account banned).");
+        return -1;
     }
 
-  // Check locked state for server
-  AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit ();
+    // Check locked state for server
+    AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit ();
 
-  if (allowedAccountType > SEC_PLAYER && security < allowedAccountType)
+    if (allowedAccountType > SEC_PLAYER && security < allowedAccountType)
     {
-      WorldPacket Packet (SMSG_AUTH_RESPONSE, 1);
-      Packet << uint8 (AUTH_UNAVAILABLE);
+        WorldPacket Packet (SMSG_AUTH_RESPONSE, 1);
+        Packet << uint8 (AUTH_UNAVAILABLE);
 
-      SendPacket (packet);
+        SendPacket (packet);
 
-      sLog.outBasic ("WorldSocket::HandleAuthSession: User tryes to login but his security level is not enough");
-      return -1;
+        sLog.outBasic ("WorldSocket::HandleAuthSession: User tryes to login but his security level is not enough");
+        return -1;
     }
 
-  // Check that Key and account name are the same on client and server
-  Sha1Hash sha;
+    // Check that Key and account name are the same on client and server
+    Sha1Hash sha;
 
-  uint32 t = 0;
-  uint32 seed = m_Seed;
+    uint32 t = 0;
+    uint32 seed = m_Seed;
 
-  sha.UpdateData (account);
-  sha.UpdateData ((uint8 *) & t, 4);
-  sha.UpdateData ((uint8 *) & clientSeed, 4);
-  sha.UpdateData ((uint8 *) & seed, 4);
-  sha.UpdateBigNumbers (&K, NULL);
-  sha.Finalize ();
+    sha.UpdateData (account);
+    sha.UpdateData ((uint8 *) & t, 4);
+    sha.UpdateData ((uint8 *) & clientSeed, 4);
+    sha.UpdateData ((uint8 *) & seed, 4);
+    sha.UpdateBigNumbers (&K, NULL);
+    sha.Finalize ();
 
-  if (memcmp (sha.GetDigest (), digest, 20))
+    if (memcmp (sha.GetDigest (), digest, 20))
     {
-      packet.Initialize (SMSG_AUTH_RESPONSE, 1);
-      packet << uint8 (AUTH_FAILED);
+        packet.Initialize (SMSG_AUTH_RESPONSE, 1);
+        packet << uint8 (AUTH_FAILED);
 
-      SendPacket (packet);
+        SendPacket (packet);
 
-      sLog.outBasic ("WorldSocket::HandleAuthSession: Sent Auth Response (authentification failed).");
-      return -1;
+        sLog.outError ("WorldSocket::HandleAuthSession: Sent Auth Response (authentification failed).");
+        return -1;
     }
 
-  std::string address = this->GetRemoteAddress ();
+    std::string address = GetRemoteAddress ();
 
-  DEBUG_LOG ("WorldSocket::HandleAuthSession: Client '%s' authenticated successfully from %s.",
-             account.c_str (),
-             address.c_str ());
+    DEBUG_LOG ("WorldSocket::HandleAuthSession: Client '%s' authenticated successfully from %s.",
+                account.c_str (),
+                address.c_str ());
 
-  // Update the last_ip in the database
-  // No SQL injection, username escaped.
-  loginDatabase.escape_string (address);
+    // Update the last_ip in the database
+    // No SQL injection, username escaped.
+    loginDatabase.escape_string (address);
 
-  loginDatabase.PExecute ("UPDATE account "
-                          "SET last_ip = '%s' "
-                          "WHERE username = '%s'",
-                          address.c_str (),
-                          safe_account.c_str ());
+    loginDatabase.PExecute ("UPDATE account "
+                            "SET last_ip = '%s' "
+                            "WHERE username = '%s'",
+                            address.c_str (),
+                            safe_account.c_str ());
 
-  // TODO protect here probably ?
-  // Althought atm the socket is singlethreaded
-  ACE_NEW_RETURN (m_Session, WorldSession (id, this, security, expansion, mutetime, locale), -1);
+    // NOTE ATM the socket is singlethreaded, have this in mind ...
+    ACE_NEW_RETURN (m_Session, WorldSession (id, this, security, expansion, mutetime, locale), -1);
 
-  m_Crypt.SetKey (&K);
-  m_Crypt.Init ();
+    m_Crypt.SetKey (&K);
+    m_Crypt.Init ();
 
-  // In case needed sometime the second arg is in microseconds 1 000 000 = 1 sec
-  ACE_OS::sleep (ACE_Time_Value (0, 10000));
+    // In case needed sometime the second arg is in microseconds 1 000 000 = 1 sec
+    ACE_OS::sleep (ACE_Time_Value (0, 10000));
 
-  // TODO error handling
-  sWorld.AddSession (this->m_Session);
+    sWorld.AddSession (m_Session);
 
-  // Create and send the Addon packet
-  if (sAddOnHandler.BuildAddonPacket (&recvPacket, &SendAddonPacked))
-    SendPacket (SendAddonPacked);
+    // Create and send the Addon packet
+    if (sAddOnHandler.BuildAddonPacket (&recvPacket, &SendAddonPacked))
+        SendPacket (SendAddonPacked);
 
-  return 0;
+    return 0;
 }
 
-int
-WorldSocket::HandlePing (WorldPacket& recvPacket)
+int WorldSocket::HandlePing (WorldPacket& recvPacket)
 {
-  uint32 ping;
-  uint32 latency;
+    uint32 ping;
+    uint32 latency;
 
-  if (recvPacket.size () < 8)
+    if (recvPacket.size () < 8)
     {
-      sLog.outError ("WorldSocket::_HandlePing wrong packet size");
-      return -1;
+        sLog.outError ("WorldSocket::_HandlePing wrong packet size");
+        return -1;
     }
 
-  // Get the ping packet content
-  recvPacket >> ping;
-  recvPacket >> latency;
+    // Get the ping packet content
+    recvPacket >> ping;
+    recvPacket >> latency;
 
-  if (m_LastPingTime == ACE_Time_Value::zero)
-    m_LastPingTime = ACE_OS::gettimeofday (); // for 1st ping
-  else
+    if (m_LastPingTime == ACE_Time_Value::zero)
+        m_LastPingTime = ACE_OS::gettimeofday (); // for 1st ping
+    else
     {
-      ACE_Time_Value cur_time = ACE_OS::gettimeofday ();
-      ACE_Time_Value diff_time (cur_time);
-      diff_time -= m_LastPingTime;
-      m_LastPingTime = cur_time;
+        ACE_Time_Value cur_time = ACE_OS::gettimeofday ();
+        ACE_Time_Value diff_time (cur_time);
+        diff_time -= m_LastPingTime;
+        m_LastPingTime = cur_time;
 
-      if (diff_time < ACE_Time_Value (27))
+        if (diff_time < ACE_Time_Value (27))
         {
-          ++m_OverSpeedPings;
+            ++m_OverSpeedPings;
 
-          uint32 max_count = sWorld.getConfig (CONFIG_MAX_OVERSPEED_PINGS);
+            uint32 max_count = sWorld.getConfig (CONFIG_MAX_OVERSPEED_PINGS);
 
-          if (max_count && m_OverSpeedPings > max_count)
+            if (max_count && m_OverSpeedPings > max_count)
             {
-              ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
+                ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 
-              if (m_Session && m_Session->GetSecurity () == SEC_PLAYER)
+                if (m_Session && m_Session->GetSecurity () == SEC_PLAYER)
                 {
-                  sLog.outError ("WorldSocket::HandlePing: Player kicked for "
-                                 "overspeeded pings adress = %s",
-                                 GetRemoteAddress ().c_str ());
+                    sLog.outError  ("WorldSocket::HandlePing: Player kicked for "
+                                    "overspeeded pings adress = %s",
+                                    GetRemoteAddress ().c_str ());
 
-                  return -1;
+                    return -1;
                 }
             }
         }
-      else
-        m_OverSpeedPings = 0;
+        else
+            m_OverSpeedPings = 0;
     }
 
-  // critical section
-  {
-    ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
+    // critical section
+    {
+        ACE_GUARD_RETURN (LockType, Guard, m_SessionLock, -1);
 
-    if (m_Session)
-      m_Session->SetLatency (latency);
-    else
-      {
-        sLog.outError ("WorldSocket::HandlePing: peer sent CMSG_PING, "
-                       "but is not authenticated or got recently kicked,"
-                       " adress = %s",
-                       this->GetRemoteAddress ().c_str ());
-        return -1;
-      }
-  }
+        if (m_Session)
+        m_Session->SetLatency (latency);
+        else
+        {
+            sLog.outError ("WorldSocket::HandlePing: peer sent CMSG_PING, "
+                            "but is not authenticated or got recently kicked,"
+                            " adress = %s",
+                            GetRemoteAddress ().c_str ());
+             return -1;
+        }
+    }
 
-  WorldPacket packet (SMSG_PONG, 4);
-  packet << ping;
-  return this->SendPacket (packet);
+    WorldPacket packet (SMSG_PONG, 4);
+    packet << ping;
+    return SendPacket (packet);
 }
 
-int
-WorldSocket::iSendPacket (const WorldPacket& pct)
+int WorldSocket::iSendPacket (const WorldPacket& pct)
 {
-  if (m_OutBuffer->space () < pct.size () + sizeof (ServerPktHeader))
+    if (m_OutBuffer->space () < pct.size () + sizeof (ServerPktHeader))
     {
-      errno = ENOBUFS;
-      return -1;
+        errno = ENOBUFS;
+        return -1;
     }
 
-  ServerPktHeader header;
-
-  header.cmd = pct.GetOpcode ();
+    ServerPktHeader header;
 
-#if ACE_BYTE_ORDER == ACE_BIG_ENDIAN
-  header.cmd = ACE_SWAP_WORD (header.cmd)
-#endif
+    header.cmd = pct.GetOpcode ();
+    EndianConvert(header.cmd);
 
-          header.size = (uint16) pct.size () + 2;
-  header.size = ACE_HTONS (header.size);
+    header.size = (uint16) pct.size () + 2;
+    EndianConvertReverse(header.size);
 
-  m_Crypt.EncryptSend ((uint8*) & header, sizeof (header));
+    m_Crypt.EncryptSend ((uint8*) & header, sizeof (header));
 
-  if (m_OutBuffer->copy ((char*) & header, sizeof (header)) == -1)
-    ACE_ASSERT (false);
+    if (m_OutBuffer->copy ((char*) & header, sizeof (header)) == -1)
+        ACE_ASSERT (false);
 
-  if (!pct.empty ())
-    if (m_OutBuffer->copy ((char*) pct.contents (), pct.size ()) == -1)
-      ACE_ASSERT (false);
+    if (!pct.empty ())
+        if (m_OutBuffer->copy ((char*) pct.contents (), pct.size ()) == -1)
+            ACE_ASSERT (false);
 
-  return 0;
+    return 0;
 }
 
-bool
-WorldSocket::iFlushPacketQueue ()
+bool WorldSocket::iFlushPacketQueue ()
 {
-  WorldPacket *pct;
-  bool haveone = false;
+    WorldPacket *pct;
+    bool haveone = false;
 
-  while (m_PacketQueue.dequeue_head (pct) == 0)
+    while (m_PacketQueue.dequeue_head (pct) == 0)
     {
-      if (iSendPacket (*pct) == -1)
+        if (iSendPacket (*pct) == -1)
         {
-          if (m_PacketQueue.enqueue_head (pct) == -1)
+            if (m_PacketQueue.enqueue_head (pct) == -1)
             {
-              delete pct;
-              sLog.outError ("WorldSocket::iFlushPacketQueue m_PacketQueue->enqueue_head");
-              return false;
+                delete pct;
+                sLog.outError ("WorldSocket::iFlushPacketQueue m_PacketQueue->enqueue_head");
+                return false;
             }
 
-          break;
+            break;
         }
-      else
+        else
         {
-          haveone = true;
-          delete pct;
+            haveone = true;
+            delete pct;
         }
     }
 
-  return haveone;
+    return haveone;
 }