提交: 4169eaba9b61717a5898fe1bd883d52240008c21 - main (git)

Commit MetaInfo

• 修訂: 4169eaba9b61717a5898fe1bd883d52240008c21 (tree)
• 時間: 2012-10-07 21:58:12
• 作者: h2so5 <h2so5@git....>
• Commiter: h2so5

Log Message

Linux環境でビルドが通らない問題を修正
チャンネル機能を途中まで実装

Change Summary

• modified: client/bin/server/config.json
• modified: common/network/Command.cpp
• modified: common/network/Command.hpp
• modified: common/network/CommandHeader.hpp
• modified: common/network/Session.cpp
• modified: common/network/Session.hpp
• modified: server/Account.cpp
• modified: server/Account.hpp
• add: server/Channel.cpp
• add: server/Channel.hpp
• modified: server/Config.cpp
• modified: server/Config.hpp
• modified: server/Makefile
• modified: server/Server.cpp
• modified: server/Server.hpp
• modified: server/main.cpp
• modified: server/stdafx.h

差異

--- a/client/bin/server/config.json
+++ b/client/bin/server/config.json
@@ -1,6 +1,15 @@
 {
 	"port": 39390,
+	
 	"server_name": "MMO Server",
+	"server_note": "MikuMikuOnlineのサーバーです",
+	
+	"public": true,
+	"lobby_servers":
+		[
+			"m2op.net"
+		],
+	
 	"stage": "stage:ケロリン町",
 	"capacity": 20,
 	

--- a/common/network/Command.cpp
+++ b/common/network/Command.cpp
@@ -28,6 +28,11 @@ boost::asio::ip::udp::endpoint Command::udp_endpoint() const
 	return udp_endpoint_;
 }
 
+bool Command::plain() const
+{
+	return plain_;
+}
+
 FatalConnectionError::FatalConnectionError() :
         Command(header::FatalConnectionError, "")
 {
@@ -132,4 +137,10 @@ ClientReceiveFullServerInfo::ClientReceiveFullServerInfo(const std::string& xml)
 
 }
 
+ClientReceivePlainFullServerInfo::ClientReceivePlainFullServerInfo(const std::string& xml) :
+	Command(header::ClientReceivePlainFullServerInfo, Utils::Serialize(xml))
+{
+	plain_ = true;
+}
+
 }

--- a/common/network/Command.hpp
+++ b/common/network/Command.hpp
@@ -19,20 +19,25 @@ typedef boost::weak_ptr<Session> SessionWeakPtr;
 
     class Command {
         public:
-            Command(header::CommandHeader header, const std::string body) :
-                header_(header), body_(body) {}
+            Command(header::CommandHeader header,
+				const std::string body) :
+                header_(header), body_(body), plain_(false) {}
 
-            Command(header::CommandHeader header, const std::string body, const SessionWeakPtr& session) :
-                header_(header), body_(body), session_(session) {}
+            Command(header::CommandHeader header,
+				const std::string body,
+				const SessionWeakPtr& session) :
+                header_(header), body_(body), session_(session), plain_(false) {}
 
-            Command(header::CommandHeader header, const std::string body,
+            Command(header::CommandHeader header,
+				const std::string body,
 				const boost::asio::ip::udp::endpoint& udp_endpoint) :
-                header_(header), body_(body), udp_endpoint_(udp_endpoint) {}
+                header_(header), body_(body), udp_endpoint_(udp_endpoint), plain_(false) {}
 
             header::CommandHeader header() const;
             const std::string& body() const;
             SessionWeakPtr session();
 			boost::asio::ip::udp::endpoint udp_endpoint() const;
+			bool plain() const;
 
         private:
             header::CommandHeader header_;
@@ -41,6 +46,7 @@ typedef boost::weak_ptr<Session> SessionWeakPtr;
             std::string body_;
             SessionWeakPtr session_;
 			boost::asio::ip::udp::endpoint udp_endpoint_;
+			bool plain_;
     };
 
 	template<header::CommandHeader Header>
@@ -56,6 +62,7 @@ typedef boost::weak_ptr<Session> SessionWeakPtr;
 	typedef CommandTemplate<header::ClientRequestedClientInfo>			ClientRequestedClientInfo;
 	typedef CommandTemplate<header::ClientReceiveServerCrowdedError>	ClientReceiveServerCrowdedError;
 	typedef CommandTemplate<header::ServerRequestedFullServerInfo>		ServerRequestedFullServerInfo;
+	typedef CommandTemplate<header::ServerRequestedPlainFullServerInfo>	ServerRequestedPlainFullServerInfo;
 
     // コネクションの切断
     class FatalConnectionError : public Command {
@@ -153,4 +160,8 @@ typedef boost::weak_ptr<Session> SessionWeakPtr;
         ClientReceiveFullServerInfo(const std::string& xml);
 	};
 
+	class ClientReceivePlainFullServerInfo : public Command {
+    public:
+        ClientReceivePlainFullServerInfo(const std::string& xml);
+	};
 }

--- a/common/network/CommandHeader.hpp
+++ b/common/network/CommandHeader.hpp
@@ -32,6 +32,10 @@ namespace header {
         ClientReceiveFullServerInfo =               0x17,
 		
 		ServerReceiveWriteLimit =					0x20,
+		
+        ServerRequestedPlainFullServerInfo =        0x40,
+        ClientReceivePlainFullServerInfo =			0x41,
+
 		ServerRequstedStatus =						0xE0,
 
         LZ4_COMPRESS_HEADER =                       0xF0,

--- a/common/network/Session.cpp
+++ b/common/network/Session.cpp
@@ -43,7 +43,7 @@ namespace network {
 
     void Session::Send(const Command& command)
     {
-        auto msg = Serialize(command);
+        auto msg = Serialize(command, command.plain());
         write_byte_sum_ += msg.size();
         UpdateWriteByteAverage();
 
@@ -54,7 +54,7 @@ namespace network {
 
     void Session::SyncSend(const Command& command)
     {
-        auto msg = Serialize(command);
+        auto msg = Serialize(command, command.plain());
         write_byte_sum_ += msg.size();
         UpdateWriteByteAverage();
 
@@ -194,7 +194,7 @@ namespace network {
 		write_average_limit_ = limit;
 	}
 
-    std::string Session::Serialize(const Command& command)
+    std::string Session::Serialize(const Command& command, bool plain)
     {
         assert(command.header() < 0xFF);
         auto header = static_cast<uint8_t>(command.header());
@@ -202,24 +202,29 @@ namespace network {
 
         std::string msg = Utils::Serialize(header) + body;
 
-        // 圧縮
-        if (body.size() >= COMPRESS_MIN_LENGTH) {
-            auto compressed = Utils::LZ4Compress(msg);
-            if (msg.size() > compressed.size() + sizeof(uint8_t)) {
-                assert(msg.size() < 65535);
-                msg = Utils::Serialize(static_cast<uint8_t>(header::LZ4_COMPRESS_HEADER),
-                    static_cast<uint16_t>(msg.size()))
-                    + compressed;
-            }
-        }
-
-        // 暗号化
-        if (encryption_) {
-            msg = Utils::Serialize(static_cast<uint8_t>(header::ENCRYPT_HEADER))
-                + encrypter_.Encrypt(msg);
-        }
+		if (plain) {
+			auto length = Utils::Serialize(static_cast<unsigned int>(msg.size()));
+			return length + msg;
+		} else {
+			// 圧縮
+			if (body.size() >= COMPRESS_MIN_LENGTH) {
+				auto compressed = Utils::LZ4Compress(msg);
+				if (msg.size() > compressed.size() + sizeof(uint8_t)) {
+					assert(msg.size() < 65535);
+					msg = Utils::Serialize(static_cast<uint8_t>(header::LZ4_COMPRESS_HEADER),
+						static_cast<uint16_t>(msg.size()))
+						+ compressed;
+				}
+			}
+
+			// 暗号化
+			if (encryption_) {
+				msg = Utils::Serialize(static_cast<uint8_t>(header::ENCRYPT_HEADER))
+					+ encrypter_.Encrypt(msg);
+			}
+			return Utils::Encode(msg);
+		}
 
-        return Utils::Encode(msg);
     }
 
     Command Session::Deserialize(const std::string& msg)
@@ -247,7 +252,7 @@ namespace network {
 
         std::string body = decoded_msg.substr(sizeof(header));
 
-        return Command(static_cast<header::CommandHeader>(header), body, shared_from_this());
+		return Command(static_cast<header::CommandHeader>(header), body, shared_from_this());
     }
 
     void Session::ReceiveTCP(const boost::system::error_code& error)

--- a/common/network/Session.hpp
+++ b/common/network/Session.hpp
@@ -81,7 +81,7 @@ namespace network {
             void UpdateReadByteAverage();
             void UpdateWriteByteAverage();
 
-            std::string Serialize(const Command& command);
+            std::string Serialize(const Command& command, bool plain);
             Command Deserialize(const std::string& msg);
 
             void ReceiveTCP(const boost::system::error_code& error);

--- a/server/Account.cpp
+++ b/server/Account.cpp
@@ -9,7 +9,7 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 #include <assert.h>
 
-Account::Account(const std::string& logfile) :
+Account::Account() :
 revision_(0),
 max_user_id_(0)
 {

--- a/server/Account.hpp
+++ b/server/Account.hpp
@@ -15,10 +15,11 @@
 #include <boost/thread.hpp>
 
 typedef uint32_t UserID;
+#undef GetUserName
 
 class Account {
     public:
-        Account(const std::string&);
+        Account();
         ~Account();
 
         void LoadInitializeData(UserID user_id, std::string data);

--- /dev/null
+++ b/server/Channel.cpp
@@ -0,0 +1,43 @@
+//
+// Channel.hpp
+//
+
+#include "Channel.hpp"
+#include <boost/filesystem.hpp>
+
+using namespace boost::filesystem;
+
+Channel::Channel()
+{
+	Load();
+}
+		
+void Channel::Load()
+{
+	pt_.clear();
+	path p("./channels");
+
+	if (exists(p) && is_directory(p)) {
+		for (auto it_dir = directory_iterator(p); it_dir != directory_iterator(); ++it_dir) {
+			if (is_directory(*it_dir)) {
+				path json_path = it_dir->path() / "config.json";
+				if (exists(json_path)) {
+					auto channel_str = it_dir->path().leaf().string();
+					try {
+						boost::property_tree::ptree config_pt;
+						read_json(json_path.string(), config_pt);
+						pt_.put_child(channel_str, config_pt);
+
+					} catch (const std::exception& e) {
+						Logger::Error("%d", e.what());
+					}
+				}
+			}
+        }
+    }
+}
+
+const boost::property_tree::ptree& Channel::pt() const
+{
+	return pt_;
+}
\ No newline at end of file

--- /dev/null
+++ b/server/Channel.hpp
@@ -0,0 +1,19 @@
+//
+// Channel.cpp
+//
+
+#pragma once
+#include <boost/property_tree/json_parser.hpp>
+
+class Channel {
+	public:
+		Channel();
+
+		const boost::property_tree::ptree& pt() const;
+
+	private:
+		void Load();
+
+	private:
+		boost::property_tree::ptree pt_;
+};
\ No newline at end of file

--- a/server/Config.cpp
+++ b/server/Config.cpp
@@ -40,15 +40,19 @@ Config::Config()
 
 void Config::Load()
 {
+
 	try {
-		read_json(std::ifstream(CONFIG_JSON), pt_);
+		std::ifstream ifs;
+		ifs.open(CONFIG_JSON);
+		read_json(ifs, pt_);
 	} catch(std::exception& e) {
 		Logger::Error(unicode::ToTString(e.what()));
 	}
 	
     port_ =             pt_.get<uint16_t>("port", 39390);
-    server_name_ =		pt_.get<std::string>("server_name", "MMO Server");
-	stage_ =			pt_.get<std::string>("stage", unicode::sjis2utf8("stage:ケロリン町"));
+    server_name_ =		pt_.get<std::string>("server_name", "MMO Server");
+    server_note_ =		pt_.get<std::string>("server_note", "");
+	stage_ =			pt_.get<std::string>("stage", unicode::ToString(_T("stage:ケロリン町")));
     capacity_ =			pt_.get<int>("capacity", 20);
 
 	public_ =			pt_.get<bool>("public", false);
@@ -60,6 +64,11 @@ void Config::Load()
 	BOOST_FOREACH(const auto& item, patterns) {
 		blocking_address_patterns_.push_back(item.second.get_value<std::string>());
 	}
+
+	auto lobby_servers = pt_.get_child("lobby_servers", ptree());
+	BOOST_FOREACH(const auto& item, lobby_servers) {
+		lobby_servers_.push_back(item.second.get_value<std::string>());
+	}
 	
 	if (exists(CONFIG_JSON)) {
 		timestamp_ = last_write_time(CONFIG_JSON);
@@ -89,6 +98,16 @@ const std::string& Config::server_name() const
     return server_name_;
 }
 
+const std::string& Config::server_note() const
+{
+    return server_note_;
+}
+
+bool Config::is_public() const
+{
+	return public_;
+}
+
 const std::string& Config::stage() const
 {
     return stage_;
@@ -113,6 +132,11 @@ const std::list<std::string>& Config::blocking_address_patterns() const
 {
 	return blocking_address_patterns_;
 }
+
+const std::list<std::string>& Config::lobby_servers() const
+{
+	return lobby_servers_;
+}
 
 const boost::property_tree::ptree& Config::pt() const
 {

--- a/server/Config.hpp
+++ b/server/Config.hpp
@@ -21,6 +21,7 @@ class Config
 
         uint16_t port_;
         std::string server_name_;
+        std::string server_note_;
         std::string stage_;
 		int capacity_;
 
@@ -30,12 +31,17 @@ class Config
 		int receive_limit_2_;
 		
 		std::list<std::string> blocking_address_patterns_;
+		std::list<std::string> lobby_servers_;
 
 		boost::property_tree::ptree pt_;
 
     public:
         uint16_t port() const;
         const std::string& server_name() const;
+        const std::string& server_note() const;
+
+        bool is_public() const;
+
         const std::string& stage() const;
         int capacity() const;
 
@@ -43,6 +49,7 @@ class Config
 		int receive_limit_2() const;
 
 		const std::list<std::string>& blocking_address_patterns() const;
+		const std::list<std::string>& lobby_servers() const;
 
 		const boost::property_tree::ptree& pt() const;
 

--- a/server/Makefile
+++ b/server/Makefile
@@ -15,6 +15,7 @@ OBJS += $(patsubst %.c,%.o,$(wildcard ../common/network/lz4/*.c))
 
 all: stdafx.h.gch $(OBJS)
 	$(LD) $(CXXFLAGS) -o $(TARGET) $(OBJS) $(LIBS) $(LIBDIRS)
+	cp ../client/bin/server/config.json .
 
 clean:
 	@rm -f $(OBJS) $(TARGET) stdafx.h.gch

--- a/server/Server.cpp
+++ b/server/Server.cpp
@@ -13,12 +13,12 @@
 
 namespace network {
 
-    Server::Server(Config& config) :
-			config_(config),
-            endpoint_(tcp::v4(), config.port()),
+    Server::Server() :
+            endpoint_(tcp::v4(), config_.port()),
             acceptor_(io_service_, endpoint_),
-            socket_udp_(io_service_, udp::endpoint(udp::v4(), config.port())),
-            udp_packet_count_(0)
+            socket_udp_(io_service_, udp::endpoint(udp::v4(), config_.port())),
+            udp_packet_count_(0),
+			recent_chat_log_(10)
     {
     }
 
@@ -48,6 +48,12 @@ namespace network {
 
         });
 
+		BOOST_FOREACH(const auto& host, config().lobby_servers()) {
+			udp::resolver resolver(io_service_);
+			udp::resolver::query query(udp::v4(), host.c_str(), "39380");
+			lobby_hosts_.push_back(resolver.resolve(query));
+		}
+
         {
         auto new_session = boost::make_shared<ServerSession>(io_service_);
         acceptor_.async_accept(new_session->tcp_socket(),
@@ -105,12 +111,52 @@ namespace network {
 		ptree xml_ptree;
 
 		xml_ptree.put_child("config", config_.pt());
+		xml_ptree.put("version", (boost::format("%d.%d.%d") 
+			% MMO_VERSION_MAJOR % MMO_VERSION_MINOR % MMO_VERSION_REVISION).str());
+		xml_ptree.put("protocol_version", MMO_PROTOCOL_VERSION);
+
+		{
+			ptree player_array;
+			auto id_list = account_.GetIDList();
+			BOOST_FOREACH(unsigned int id, id_list) {
+				ptree player;
+				player.put("name", account_.GetUserName(id));
+				player.put("model_name", account_.GetUserModelName(id));
+				player_array.push_back(std::make_pair("", player));
+			}
+			xml_ptree.put_child("players", player_array);
+		}
+
+		{
+			ptree log_array;
+			BOOST_FOREACH(const std::string& msg, recent_chat_log_) {
+				log_array.push_back(std::make_pair("", msg));
+			}
+			xml_ptree.put_child("recent_chat_log", log_array);
+		}
 
+		xml_ptree.put_child("channels", channel_.pt());
+		
 		std::stringstream stream;
 		write_xml(stream, xml_ptree);
 		return stream.str();
 	}
 
+	const Config& Server::config() const
+	{
+		return config_;
+	}
+
+	Account& Server::account()
+	{
+		return account_;
+	}
+	
+	void Server::AddChatLog(const std::string& msg)
+	{
+		recent_chat_log_.push_back(msg);
+	}
+
     bool Server::Empty() const
     {
         return GetUserCount() == 0;
@@ -171,7 +217,9 @@ namespace network {
             if (auto session = ptr.lock()) {
 				if (channel < 0 || (channel >= 0 && session->channel() == channel)) {
 					if (!limited || session->write_average_limit() > session->GetWriteByteAverage()) {
-						session->Send(command);
+						if (session->id() > 0) {
+							session->Send(command);
+						}
 					}
 				}
             }
@@ -184,7 +232,7 @@ namespace network {
             if (auto session = ptr.lock()) {
 				if (channel < 0 || (channel >= 0 && session->channel() == channel)) {
 					if (!limited || session->write_average_limit() > session->GetWriteByteAverage()) {
-						if (session->id() != self_id) {
+						if (session->id() > 0 && session->id() != self_id) {
 							session->Send(command);
 						}
 					}
@@ -223,6 +271,14 @@ namespace network {
         }
     }
 
+	void Server::SendPublicPing()
+	{
+		static char request[] = "P";
+		BOOST_FOREACH(const auto& iterator, lobby_hosts_) {
+			io_service_.post(boost::bind(&Server::DoWriteUDP, this, request, *iterator));
+		}
+	}
+
     void Server::SendUDP(const std::string& message, const boost::asio::ip::udp::endpoint endpoint)
     {
 		io_service_.post(boost::bind(&Server::DoWriteUDP, this, message, endpoint));

--- a/server/Server.hpp
+++ b/server/Server.hpp
@@ -7,8 +7,11 @@
 #include <string>
 #include <list>
 #include <functional>
+#include <boost/circular_buffer.hpp>
 #include "../common/network/Session.hpp"
 #include "Config.hpp"
+#include "Account.hpp"
+#include "Channel.hpp"
 
 #define UDP_MAX_RECEIVE_LENGTH (2048)
 #define UDP_TEST_PACKET_TIME (5)
@@ -26,7 +29,7 @@ class Server {
         };
 
     public:
-        Server(Config& config);
+        Server();
         void Start(CallbackFuncPtr callback);
         void Stop();
         void Stop(int interrupt_type);
@@ -39,12 +42,18 @@ class Server {
 		std::string GetStatusJSON() const;
 		std::string GetFullStatus() const;
 
+		const Config& config() const;
+		Account& account();
+
+		void AddChatLog(const std::string& msg);
+
         int GetSessionReadAverageLimit();
 		int GetUserCount() const;
 		void RefreshSession();
 
         void SendUDPTestPacket(const std::string& ip_address, uint16_t port);
 		void SendUDP(const std::string& message, const boost::asio::ip::udp::endpoint endpoint);
+		void SendPublicPing();
 
 		bool IsBlockedAddress(const boost::asio::ip::address& address);
 
@@ -58,7 +67,9 @@ class Server {
         void FetchUDP(const std::string& buffer, const boost::asio::ip::udp::endpoint endpoint);
 
     private:
-	   Config& config_;
+	   Config config_;
+	   Account account_;
+	   Channel channel_;
 
        boost::asio::io_service io_service_;
        tcp::endpoint endpoint_;
@@ -75,6 +86,9 @@ class Server {
        boost::mutex mutex_;
        std::list<SessionWeakPtr> sessions_;
 
+	   boost::circular_buffer<std::string> recent_chat_log_;
+	   std::list<udp::resolver::iterator> lobby_hosts_;
+
 };
 
 }

--- a/server/main.cpp
+++ b/server/main.cpp
@@ -16,7 +16,6 @@
 #include "../common/database/AccountProperty.hpp"
 #include "../common/Logger.hpp"
 #include "Config.hpp"
-#include "Account.hpp"
 #include "version.hpp"
 
 #ifdef __linux__
@@ -32,6 +31,7 @@
 using namespace boost::posix_time;
 
 void client_sync(network::Server& server);
+void public_ping(network::Server& server);
 void server();
 
 int main(int argc, char* argv[])
@@ -58,18 +58,14 @@ int main(int argc, char* argv[])
 void server()
 {
 
-    // 設定を読み込み
-    Config config;
-
     // 署名
     network::Signature sign("server_key");
 
     // アカウント
-    Account account("account.db");
-    network::Server server(config);
+    network::Server server;
 
     auto callback = std::make_shared<std::function<void(network::Command)>>(
-            [&server, &account, &sign, &config](network::Command c){
+            [&server, &sign](network::Command c){
 
         // ログを出力
         auto msg = (boost::format("Receive: 0x%08x %dbyte") % c.header() % c.body().size()).str();
@@ -80,10 +76,9 @@ void server()
         // if (auto session = c.session().lock()) {
         //     std::cout << "Write Average: " << session->GetReadByteAverage() << "bytes" << std::endl;
         // }
-
+		auto header = c.header();
         switch (c.header()) {
 
-		// フルステータス要求
 		case network::header::ServerRequestedFullServerInfo:
 		{
 			if (auto session = c.session().lock()) {
@@ -92,6 +87,14 @@ void server()
 		}
 		break;
 
+		case network::header::ServerRequestedPlainFullServerInfo:
+		{
+			if (auto session = c.session().lock()) {
+				session->Send(network::ClientReceivePlainFullServerInfo(server.GetFullStatus()));
+			}
+		}
+		break;
+
 		// ステータス要求
 		case network::header::ServerRequstedStatus:
 		{
@@ -139,6 +142,10 @@ void server()
 						server.SendTo(send_command, user_id);
 					}
 				} else {
+					auto name = server.account().GetUserName(id);
+					auto body = message_tree.get<std::string>("body", std::string());
+					server.AddChatLog((boost::format("[%s] %s") % name % body).str());
+
 					server.SendAll(send_command, session->channel());
 				}
 
@@ -154,7 +161,7 @@ void server()
             if (auto session = c.session().lock()) {
                 PlayerPosition pos;
                 network::Utils::Deserialize(c.body(), &pos.x, &pos.y, &pos.z, &pos.theta, &pos.vy);
-                account.SetUserPosition(session->id(), pos);
+                server.account().SetUserPosition(session->id(), pos);
                 server.SendOthers(network::ClientUpdatePlayerPosition(session->id(),
 					pos.x,pos.y,pos.z,pos.theta, pos.vy), session->id(), session->channel(), true);
             }
@@ -167,7 +174,7 @@ void server()
             if (auto session = c.session().lock()) {
 
 				// 最大接続数を超えていないか判定
-				if (server.GetUserCount() >= config.capacity()) {
+				if (server.GetUserCount() >= server.config().capacity()) {
 					Logger::Info("Refused Session");
 					session->SyncSend(network::ClientReceiveServerCrowdedError());
 					session->Close();
@@ -197,7 +204,7 @@ void server()
                 // テスト送信
                 server.SendUDPTestPacket(session->global_ip(), session->udp_port());
 
-                uint32_t id = account.GetUserIdFromFingerPrint(finger_print);
+                uint32_t id = server.account().GetUserIdFromFingerPrint(finger_print);
                 if (id == 0) {
                     // 未登録の場合、公開鍵を要求
                     session->Send(network::ClientRequestedPublicKey());
@@ -205,11 +212,11 @@ void server()
                     uint32_t user_id = static_cast<uint32_t>(id);
                     // ログイン
                     session->set_id(user_id);
-                    account.LogIn(user_id);
-                    session->encrypter().SetPublicKey(account.GetPublicKey(user_id));
+                    server.account().LogIn(user_id);
+                    session->encrypter().SetPublicKey(server.account().GetPublicKey(user_id));
 
-                    account.SetUserIPAddress(session->id(), session->global_ip());
-                    account.SetUserUDPPort(session->id(), session->udp_port());
+                    server.account().SetUserIPAddress(session->id(), session->global_ip());
+                    server.account().SetUserUDPPort(session->id(), session->udp_port());
 
                     // 共通鍵を送り返す
                     auto key = session->encrypter().GetCryptedCommonKey();
@@ -225,18 +232,18 @@ void server()
         case network::header::ServerReceivePublicKey:
         {
             if (auto session = c.session().lock()) {
-                uint32_t user_id = account.RegisterPublicKey(c.body());
+                uint32_t user_id = server.account().RegisterPublicKey(c.body());
 				assert(user_id > 0);
 
 				session->ResetReadByteAverage();
 
                 // ログイン
                 session->set_id(user_id);
-                account.LogIn(user_id);
-                session->encrypter().SetPublicKey(account.GetPublicKey(user_id));
+                server.account().LogIn(user_id);
+                session->encrypter().SetPublicKey(server.account().GetPublicKey(user_id));
 
-                account.SetUserIPAddress(session->id(), session->global_ip());
-                account.SetUserUDPPort(session->id(), session->udp_port());
+                server.account().SetUserIPAddress(session->id(), session->global_ip());
+                server.account().SetUserUDPPort(session->id(), session->udp_port());
 
                 // 共通鍵を送り返す
                 auto key = session->encrypter().GetCryptedCommonKey();
@@ -252,7 +259,7 @@ void server()
         {
             if (auto session = c.session().lock()) {
 				
-				session->Send(network::ClientReceiveServerInfo(config.stage()));
+				session->Send(network::ClientReceiveServerInfo(server.config().stage()));
 
                 session->Send(network::ClientStartEncryptedSession());
                 session->EnableEncryption();
@@ -266,17 +273,17 @@ void server()
         case network::header::ServerReceiveAccountInitializeData:
         {
             if (auto session = c.session().lock()) {
-                account.LoadInitializeData(session->id(), c.body());
+                server.account().LoadInitializeData(session->id(), c.body());
 
-                const auto& list = account.GetIDList();
+                const auto& list = server.account().GetIDList();
                 BOOST_FOREACH(UserID user_id, list) {
                     session->Send(network::ClientReceiveAccountRevisionUpdateNotify(user_id,
-                            account.GetUserRevision(user_id)));
+                            server.account().GetUserRevision(user_id)));
                 }
 
                 server.SendOthers(
                         network::ClientReceiveAccountRevisionUpdateNotify(session->id(),
-                                account.GetUserRevision(session->id())), session->id());
+                                server.account().GetUserRevision(session->id())), session->id());
 
                 Logger::Info(msg);
             }
@@ -291,9 +298,9 @@ void server()
                 uint32_t client_revision;
                 network::Utils::Deserialize(c.body(), &user_id, &client_revision);
 
-                if (client_revision < account.GetUserRevision(user_id)) {
+                if (client_revision < server.account().GetUserRevision(user_id)) {
                     session->Send(network::ClientReceiveAccountRevisionPatch(
-                            account.GetUserRevisionPatch(user_id, client_revision)));
+                            server.account().GetUserRevisionPatch(user_id, client_revision)));
                 }
                 Logger::Info(msg);
             }
@@ -307,7 +314,7 @@ void server()
 				std::string buffer = c.body().substr(sizeof(AccountProperty));
                 network::Utils::Deserialize(c.body(), &property);
 
-                auto old_revision = account.GetUserRevision(session->id());
+                auto old_revision = server.account().GetUserRevision(session->id());
 
                 switch (property) {
 
@@ -315,36 +322,37 @@ void server()
                     {
 						std::string value;
 						network::Utils::Deserialize(buffer, &value);
-                        account.SetUserName(session->id(), value);
+                        server.account().SetUserName(session->id(), value);
                     }
                     break;
                 case TRIP:
                     {
 						std::string value;
 						network::Utils::Deserialize(buffer, &value);
-                        account.SetUserTrip(session->id(), value);
+                        server.account().SetUserTrip(session->id(), value);
                     }
                     break;
                 case MODEL_NAME:
                     {
 						std::string value;
 						network::Utils::Deserialize(buffer, &value);
-                        account.SetUserModelName(session->id(), value);
+                        server.account().SetUserModelName(session->id(), value);
+                    }
+                    break;
+                case CHANNEL:
+                    {
+						std::string value;
+						network::Utils::Deserialize(buffer, &value);
+						auto channel = *reinterpret_cast<const unsigned int*>(value.data());
+                        server.account().SetUserChannel(session->id(), channel);
+						session->set_channel(channel);
                     }
                     break;
-      //          case CHANNEL:
-      //              {
-						//unsigned char value;
-						//network::Utils::Deserialize(buffer, &value);
-      //                  account.SetUserChannel(session->id(), value);
-						//session->set_channel(value);
-      //              }
-      //              break;
                 default:
                     ;
                 }
 
-                auto new_revison = account.GetUserRevision(session->id());
+                auto new_revison = server.account().GetUserRevision(session->id());
                 if (new_revison > old_revision) {
                     server.SendAll(
                             network::ClientReceiveAccountRevisionUpdateNotify(
@@ -362,14 +370,14 @@ void server()
             if (c.body().size() > 0) {
                 int user_id;
                 network::Utils::Deserialize(c.body(), &user_id);
-                account.LogOut(user_id);
+                server.account().LogOut(user_id);
 
                 server.SendAll(
                         network::ClientReceiveAccountRevisionUpdateNotify(user_id,
-                                account.GetUserRevision(user_id)));
+                                server.account().GetUserRevision(user_id)));
 
                 Logger::Info("Logout User: %d", user_id);
-				account.Remove(user_id);
+				server.account().Remove(user_id);
             }
         }
         Logger::Info(msg);
@@ -382,9 +390,24 @@ void server()
     });
 
 	client_sync(server);
+
+	if (server.config().is_public()) {
+		public_ping(server);
+	}
+
     server.Start(callback);
 }
 
+void public_ping(network::Server& server)
+{
+    boost::thread([&server](){
+        while (1) {
+            boost::this_thread::sleep(boost::posix_time::seconds(10));
+			server.SendPublicPing();
+        }
+    });
+}
+
 void client_sync(network::Server& server)
 {
     bool execute_with_client;
@@ -404,7 +427,7 @@ void client_sync(network::Server& server)
     if (execute_with_client) {
         boost::thread([&server](){
             while (1) {
-                boost::this_thread::sleep(boost::posix_time::milliseconds(4000));
+                boost::this_thread::sleep(boost::posix_time::seconds(4));
                 try {
 					using namespace boost::interprocess;
 					windows_shared_memory shm(open_only, "MMO_SERVER_WITH_CLIENT", read_only);

--- a/server/stdafx.h
+++ b/server/stdafx.h
@@ -54,5 +54,7 @@
 #include <boost/format.hpp>
 #include <boost/thread.hpp>
 #include <boost/foreach.hpp>
+#include <boost/circular_buffer.hpp>
+#include <boost/lexical_cast.hpp>
 
 #include "../common/Logger.hpp"
\ No newline at end of file