trinitycore 魔兽服务器源码分析(一) 网络

  1 /*
  2  * Copyright (C) 2008-2017 TrinityCore <http://www.trinitycore.org/>
  3  *
  4  * This program is free software; you can redistribute it and/or modify it
  5  * under the terms of the GNU General Public License as published by the
  6  * Free Software Foundation; either version 2 of the License, or (at your
  7  * option) any later version.
  8  *
  9  * This program is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 12  * more details.
 13  *
 14  * You should have received a copy of the GNU General Public License along
 15  * with this program. If not, see <http://www.gnu.org/licenses/>.
 16  */
 17 
 18 #ifndef __ASYNCACCEPT_H_
 19 #define __ASYNCACCEPT_H_
 20 
 21 #include "Log.h"
 22 #include <boost/asio/ip/tcp.hpp>
 23 #include <boost/asio/ip/address.hpp>
 24 #include <functional>
 25 #include <atomic>
 26 
 27 using boost::asio::ip::tcp;
 28 
 29 class AsyncAcceptor
 30 {
 31 public:
 32     typedef void(*AcceptCallback)(tcp::socket&& newSocket, uint32 threadIndex);
 33 
 34     AsyncAcceptor(boost::asio::io_service& ioService, std::string const& bindIp, uint16 port) :
 35         _acceptor(ioService), _endpoint(boost::asio::ip::address::from_string(bindIp), port),
 36         _socket(ioService), _closed(false), _socketFactory(std::bind(&AsyncAcceptor::DefeaultSocketFactory, this))
 37     {
 38     }
 39 
 40     template<class T>
 41     void AsyncAccept();
 42 
 43     template<AcceptCallback acceptCallback>
 44     void AsyncAcceptWithCallback()
 45     {
 46         tcp::socket* socket;
 47         uint32 threadIndex;
 48         std::tie(socket, threadIndex) = _socketFactory();
 49         _acceptor.async_accept(*socket, [this, socket, threadIndex](boost::system::error_code error)
 50         {
 51             if (!error)
 52             {
 53                 try
 54                 {
 55                     socket->non_blocking(true);
 56 
 57                     acceptCallback(std::move(*socket), threadIndex);
 58                 }
 59                 catch (boost::system::system_error const& err)
 60                 {
 61                     TC_LOG_INFO("network", "Failed to initialize client's socket %s", err.what());
 62                 }
 63             }
 64 
 65             if (!_closed)
 66                 this->AsyncAcceptWithCallback<acceptCallback>();
 67         });
 68     }
 69 
 70     bool Bind()
 71     {
 72         boost::system::error_code errorCode;
 73         _acceptor.open(_endpoint.protocol(), errorCode);
 74         if (errorCode)
 75         {
 76             TC_LOG_INFO("network", "Failed to open acceptor %s", errorCode.message().c_str());
 77             return false;
 78         }
 79 
 80         _acceptor.bind(_endpoint, errorCode);
 81         if (errorCode)
 82         {
 83             TC_LOG_INFO("network", "Could not bind to %s:%u %s", _endpoint.address().to_string().c_str(), _endpoint.port(), errorCode.message().c_str());
 84             return false;
 85         }
 86 
 87         _acceptor.listen(boost::asio::socket_base::max_connections, errorCode);
 88         if (errorCode)
 89         {
 90             TC_LOG_INFO("network", "Failed to start listening on %s:%u %s", _endpoint.address().to_string().c_str(), _endpoint.port(), errorCode.message().c_str());
 91             return false;
 92         }
 93 
 94         return true;
 95     }
 96 
 97     void Close()
 98     {
 99         if (_closed.exchange(true))
100             return;
101 
102         boost::system::error_code err;
103         _acceptor.close(err);
104     }
105 
106     void SetSocketFactory(std::function<std::pair<tcp::socket*, uint32>()> func) { _socketFactory = func; }
107 
108 private:
109     std::pair<tcp::socket*, uint32> DefeaultSocketFactory() { return std::make_pair(&_socket, 0); }
110 
111     tcp::acceptor _acceptor;
112     tcp::endpoint _endpoint;
113     tcp::socket _socket;
114     std::atomic<bool> _closed;
115     std::function<std::pair<tcp::socket*, uint32>()> _socketFactory;
116 };
117 
118 template<class T>
119 void AsyncAcceptor::AsyncAccept()
120 {
121     _acceptor.async_accept(_socket, [this](boost::system::error_code error)
122     {
123         if (!error)
124         {
125             try
126             {
127                 // this-> is required here to fix an segmentation fault in gcc 4.7.2 - reason is lambdas in a templated class
128                 std::make_shared<T>(std::move(this->_socket))->Start();
129             }
130             catch (boost::system::system_error const& err)
131             {
132                 TC_LOG_INFO("network", "Failed to retrieve client's remote address %s", err.what());
133             }
134         }
135 
136         // lets slap some more this-> on this so we can fix this bug with gcc 4.7.2 throwing internals in yo face
137         if (!_closed)
138             this->AsyncAccept<T>();
139     });
140 }
141 
142 #endif /* __ASYNCACCEPT_H_ */