Merge pull request #313 from q4z1/serverstuff_stable

Serverstuff stable

.gitignore

@@ -0,0 +1,20 @@
+# exclude changes done by make process
+Makefile
+Makefile.chatcleaner
+Makefile.pokerth_db
+Makefile.pokerth_game
+Makefile.pokerth_lib
+Makefile.pokerth_protocol
+Makefile.pokerth_server
+bin/
+chatcleaner
+lib/
+mocs/
+obj/
+pokerth
+qrc_pokerth.cpp
+uics/
+make.sh
+gitpush_serverstuff_stable
+pokerth_server
+

pokerth_server.pro

@@ -175,6 +175,8 @@ unix : !mac {
 
 	LIBPATH += lib $${PREFIX}/lib /opt/gsasl/lib
 	INCLUDEPATH += $${PREFIX}/include
+	# see issue https://github.com/pokerth/pokerth/issues/282
+	INCLUDEPATH += $${PREFIX}/include/libircclient
 	LIB_DIRS = $${PREFIX}/lib $${PREFIX}/lib64 $$system(qmake -query QT_INSTALL_LIBS)
 	BOOST_FS = boost_filesystem boost_filesystem-mt
 	BOOST_THREAD = boost_thread boost_thread-mt

src/config/configfile.cpp

@@ -311,6 +311,7 @@ ConfigFile::ConfigFile(char *argv0, bool readonly) : noWriteAccess(readonly)
 	configList.push_back(ConfigInfo("DBServerDatabaseName", CONFIG_TYPE_STRING, "pokerth"));
 	configList.push_back(ConfigInfo("DBServerEncryptionKey", CONFIG_TYPE_STRING, ""));
 	configList.push_back(ConfigInfo("GameNameBadWordList", CONFIG_TYPE_STRING_LIST, "Regex"));
+	configList.push_back(ConfigInfo("ServerBlockGuestDuplicateIP", CONFIG_TYPE_INT, "0"));
 
 	//fill tempList firstTime
 	configBufferList = configList;

src/net/common/ircthread.cpp

@@ -32,14 +32,22 @@
 #include <net/socket_helper.h>
 #include <net/ircthread.h>
 #include <net/socket_msg.h>
+#ifdef _WIN32
 #include <libircclient/libircclient.h>
+#else
+#include <libircclient.h>
+#endif
 
 // We need to do the following to handle different versions of libircclient.
 // Sadly, libircclient doesn't have actual definitions for its versions in its headers.
 // However, we can use a definition that appeared in the same version we need
 // to check for. Hacky, but hey, it works.
 #ifdef LIBIRC_OPTION_SSL_NO_VERIFY
+#ifdef _WIN32
 #include <libircclient/libirc_rfcnumeric.h>
+#else
+#include <libirc_rfcnumeric.h>
+#endif
 #endif
 
 #include <boost/algorithm/string/predicate.hpp>

src/net/common/servergame.cpp

@@ -457,6 +457,7 @@ ServerGame::InternalEndGame()
 {
 	StoreAndResetRanking();
 	m_game.reset();
+	m_numJoinsPerPlayer.clear();
 }
 
 void
@@ -1164,3 +1165,25 @@ ServerGame::GetNextGameNum()
 	return m_gameNum++;
 }
 
+void
+ServerGame::AddPlayerToNumJoinsPerPlayer(const std::string &playerName)
+{
+	NumJoinsPerPlayerMap::iterator pos = m_numJoinsPerPlayer.find(playerName);
+	if (pos != m_numJoinsPerPlayer.end())
+	{
+		pos->second++;
+	} else {
+		m_numJoinsPerPlayer[playerName] = 1;
+	}
+}
+
+int
+ServerGame::GetNumJoinsPerPlayer(const std::string &playerName)
+{
+	int num = 0;
+	NumJoinsPerPlayerMap::const_iterator pos = m_numJoinsPerPlayer.find(playerName);
+	if (pos != m_numJoinsPerPlayer.end()) {
+		num = pos->second;
+	}
+	return num;
+}

src/net/common/servergamestate.cpp

@@ -84,6 +84,8 @@ using namespace std;
 #define SERVER_LOOP_DELAY_MSEC						50
 #define SERVER_MAX_NUM_SPECTATORS_PER_GAME			100
 
+#define GAME_MAX_NUM_JOINS_PER_PLAYER				6
+
 // Helper functions
 
 static void SendPlayerAction(ServerGame &server, boost::shared_ptr<PlayerInterface> player)
@@ -537,10 +539,13 @@ ServerGameStateInit::HandleNewPlayer(boost::shared_ptr<ServerGame> server, boost
 {
 	if (session && session->GetPlayerData()) {
 		const GameData &tmpGameData = server->GetGameData();
-		// Check the number of players.
+
-		if (server->GetCurNumberOfPlayers() >= tmpGameData.maxNumberOfPlayers) {
+		// Check the number of players and number of joins per player
+		if (server->GetCurNumberOfPlayers() >= tmpGameData.maxNumberOfPlayers || server->GetNumJoinsPerPlayer(session->GetPlayerData()->GetName()) > GAME_MAX_NUM_JOINS_PER_PLAYER) {
 			server->MoveSessionToLobby(session, NTF_NET_REMOVED_GAME_FULL);
 		} else {
+			// add player to NumJoinsPerPlayerMap
+			server->AddPlayerToNumJoinsPerPlayer(session->GetPlayerData()->GetName());
 
 			AcceptNewSession(server, session, false);
 

src/net/common/serverlobbythread.cpp

@@ -395,8 +395,9 @@ ServerLobbyThread::CloseSession(boost::shared_ptr<SessionData> session)
 		m_sessionManager.RemoveSession(session->GetId());
 		m_gameSessionManager.RemoveSession(session->GetId());
 
-		if (session->GetPlayerData())
+		if (session->GetPlayerData()) {
 			NotifyPlayerLeftLobby(session->GetPlayerData()->GetUniqueId());
+		}
 		// Update stats (if needed).
 		UpdateStatisticsNumberOfPlayers();
 
@@ -1047,6 +1048,8 @@ ServerLobbyThread::HandleNetPacketInit(boost::shared_ptr<SessionData> session, c
 	MD5Buf avatarMD5;
 	bool noAuth = false;
 	bool validGuest = false;
+	// productive: if (initMessage.login() == InitMessage::guestLogin) {
+	// debug: if (initMessage.login() == InitMessage::unauthenticatedLogin) {
 	if (initMessage.login() == InitMessage::guestLogin) {
 		playerName = initMessage.nickname();
 		// Verify guest player name.
@@ -1057,7 +1060,14 @@ ServerLobbyThread::HandleNetPacketInit(boost::shared_ptr<SessionData> session, c
 				validGuest = true;
 				noAuth = true;
 			}
+			// check if a guest session in lobby with same ip is already connected and
+			// if number of lobby guests >= SERVER_MAX_GUEST_USERS_LOBBY
+			if(!m_sessionManager.IsGuestAllowedToConnect(session->GetClientAddr(), m_serverConfig.readConfigInt("ServerBlockGuestDuplicateIP"))) {
+				SessionError(session, ERR_NET_SERVER_FULL);
+				return;
+			}
 		}
+
 		if (!validGuest) {
 			SessionError(session, ERR_NET_INVALID_PLAYER_NAME);
 			return;
@@ -2365,4 +2375,3 @@ ServerLobbyThread::GetRejoinGameIdForPlayer(const std::string &playerName, const
 	}
 	return retGameId;
 }
-

src/net/common/sessionmanager.cpp

@@ -36,6 +36,7 @@
 
 using namespace std;
 
+#define SERVER_MAX_GUEST_USERS_LOBBY	50		// LG: Maximum number of guests users in lobby allowed
 
 SessionManager::SessionManager()
 {
@@ -247,6 +248,35 @@ SessionManager::IsClientAddressConnected(const std::string &clientAddress) const
 	return retVal;
 }
 
+bool
+SessionManager::IsGuestAllowedToConnect(const std::string &clientAddress, int blockDup) const
+{
+	bool retVal = true;
+	boost::recursive_mutex::scoped_lock lock(m_sessionMapMutex);
+
+	SessionMap::const_iterator i = m_sessionMap.begin();
+	SessionMap::const_iterator end = m_sessionMap.end();
+
+	int num = 0;
+	while (i != end) {
+		boost::shared_ptr<PlayerData> tmpPlayer(i->second->GetPlayerData());
+		if (tmpPlayer && tmpPlayer->GetRights() == PLAYER_RIGHTS_GUEST) {
+			num++;
+			if (blockDup && i->second->GetClientAddr() == clientAddress) {
+				// guest has same ip as another guest in lobby or
+				retVal = false;
+				break;
+			}
+		}
+		++i;
+	}
+
+	// Check if number of players in lobby exceeds max
+	if (num >= SERVER_MAX_GUEST_USERS_LOBBY) retVal = false;
+
+	return retVal;
+}
+
 void
 SessionManager::ForEach(boost::function<void (boost::shared_ptr<SessionData>)> func)
 {

src/net/servergame.h

@@ -125,6 +125,9 @@ public:
 
 	void KickPlayer(unsigned playerId);
 
+	void AddPlayerToNumJoinsPerPlayer(const std::string &playerName);
+	int GetNumJoinsPerPlayer(const std::string &playerName);
+
 protected:
 
 	struct RankingData {
@@ -191,6 +194,8 @@ protected:
 	SessionManager &GetSessionManager();
 	ServerDBInterface &GetDatabase();
 
+	typedef std::map<std::string, int> NumJoinsPerPlayerMap;
+
 private:
 	ServerGame(const ServerGame &other);
 
@@ -251,6 +256,8 @@ private:
 	friend class ServerGameStateHand;
 	friend class ServerGameStateWaitPlayerAction;
 	friend class ServerGameStateWaitNextHand;
+
+	NumJoinsPerPlayerMap m_numJoinsPerPlayer;
 };
 
 #endif

src/net/sessionmanager.h

@@ -64,6 +64,7 @@ public:
 	bool IsPlayerConnected(const std::string &playerName) const;
 	bool IsPlayerConnected(unsigned uniqueId) const;
 	bool IsClientAddressConnected(const std::string &clientAddress) const;
+	bool IsGuestAllowedToConnect(const std::string &clientAddress, int) const;
 
 	void ForEach(boost::function<void (boost::shared_ptr<SessionData>)> func);
 

src/third_party/protobuf/chatcleaner.pb.h

@@ -8,12 +8,12 @@
 
 #include <google/protobuf/stubs/common.h>
 
-#if GOOGLE_PROTOBUF_VERSION < 2005000
+#if GOOGLE_PROTOBUF_VERSION < 2006000
 #error This file was generated by a newer version of protoc which is
 #error incompatible with your Protocol Buffer headers.  Please update
 #error your headers.
 #endif
-#if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
 #error This file was generated by an older version of protoc which is
 #error incompatible with your Protocol Buffer headers.  Please
 #error regenerate this file with a newer version of protoc.
@@ -82,6 +82,14 @@ class CleanerInitMessage : public ::google::protobuf::MessageLite {
     return *this;
   }
 
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
   static const CleanerInitMessage& default_instance();
 
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
@@ -110,13 +118,13 @@ class CleanerInitMessage : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
   ::std::string GetTypeName() const;
 
   // nested types ----------------------------------------------------
@@ -149,12 +157,12 @@ class CleanerInitMessage : public ::google::protobuf::MessageLite {
   inline void set_has_clientsecret();
   inline void clear_has_clientsecret();
 
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
   ::std::string* clientsecret_;
   ::google::protobuf::uint32 requestedversion_;
-
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   friend void  protobuf_AddDesc_chatcleaner_2eproto_impl();
   #else
@@ -180,6 +188,14 @@ class CleanerInitAckMessage : public ::google::protobuf::MessageLite {
     return *this;
   }
 
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
   static const CleanerInitAckMessage& default_instance();
 
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
@@ -208,13 +224,13 @@ class CleanerInitAckMessage : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
   ::std::string GetTypeName() const;
 
   // nested types ----------------------------------------------------
@@ -247,12 +263,12 @@ class CleanerInitAckMessage : public ::google::protobuf::MessageLite {
   inline void set_has_serversecret();
   inline void clear_has_serversecret();
 
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
   ::std::string* serversecret_;
   ::google::protobuf::uint32 serverversion_;
-
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
-
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   friend void  protobuf_AddDesc_chatcleaner_2eproto_impl();
   #else
@@ -278,6 +294,14 @@ class CleanerChatRequestMessage : public ::google::protobuf::MessageLite {
     return *this;
   }
 
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
   static const CleanerChatRequestMessage& default_instance();
 
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
@@ -306,13 +330,13 @@ class CleanerChatRequestMessage : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
   ::std::string GetTypeName() const;
 
   // nested types ----------------------------------------------------
@@ -386,16 +410,16 @@ class CleanerChatRequestMessage : public ::google::protobuf::MessageLite {
   inline void set_has_chatmessage();
   inline void clear_has_chatmessage();
 
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
   ::google::protobuf::uint32 requestid_;
   int cleanerchattype_;
   ::google::protobuf::uint32 gameid_;
   ::google::protobuf::uint32 playerid_;
   ::std::string* playername_;
   ::std::string* chatmessage_;
-
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   friend void  protobuf_AddDesc_chatcleaner_2eproto_impl();
   #else
@@ -421,6 +445,14 @@ class CleanerChatReplyMessage : public ::google::protobuf::MessageLite {
     return *this;
   }
 
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
   static const CleanerChatReplyMessage& default_instance();
 
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
@@ -449,13 +481,13 @@ class CleanerChatReplyMessage : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
   ::std::string GetTypeName() const;
 
   // nested types ----------------------------------------------------
@@ -540,16 +572,16 @@ class CleanerChatReplyMessage : public ::google::protobuf::MessageLite {
   inline void set_has_cleanertext();
   inline void clear_has_cleanertext();
 
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
   ::google::protobuf::uint32 requestid_;
   int cleanerchattype_;
   ::google::protobuf::uint32 gameid_;
   ::google::protobuf::uint32 playerid_;
   ::std::string* cleanertext_;
   int cleaneractiontype_;
-
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
-
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   friend void  protobuf_AddDesc_chatcleaner_2eproto_impl();
   #else
@@ -575,6 +607,14 @@ class ChatCleanerMessage : public ::google::protobuf::MessageLite {
     return *this;
   }
 
+  inline const ::std::string& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::std::string* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
   static const ChatCleanerMessage& default_instance();
 
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
@@ -603,13 +643,13 @@ class ChatCleanerMessage : public ::google::protobuf::MessageLite {
       ::google::protobuf::io::CodedInputStream* input);
   void SerializeWithCachedSizes(
       ::google::protobuf::io::CodedOutputStream* output) const;
+  void DiscardUnknownFields();
   int GetCachedSize() const { return _cached_size_; }
   private:
   void SharedCtor();
   void SharedDtor();
   void SetCachedSize(int size) const;
   public:
-
   ::std::string GetTypeName() const;
 
   // nested types ----------------------------------------------------
@@ -687,15 +727,15 @@ class ChatCleanerMessage : public ::google::protobuf::MessageLite {
   inline void set_has_cleanerchatreplymessage();
   inline void clear_has_cleanerchatreplymessage();
 
+  ::std::string _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
   ::CleanerInitMessage* cleanerinitmessage_;
   ::CleanerInitAckMessage* cleanerinitackmessage_;
   ::CleanerChatRequestMessage* cleanerchatrequestmessage_;
   ::CleanerChatReplyMessage* cleanerchatreplymessage_;
   int messagetype_;
-
-  mutable int _cached_size_;
-  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
-
   #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   friend void  protobuf_AddDesc_chatcleaner_2eproto_impl();
   #else
@@ -729,11 +769,13 @@ inline void CleanerInitMessage::clear_requestedversion() {
   clear_has_requestedversion();
 }
 inline ::google::protobuf::uint32 CleanerInitMessage::requestedversion() const {
+  // @@protoc_insertion_point(field_get:CleanerInitMessage.requestedVersion)
   return requestedversion_;
 }
 inline void CleanerInitMessage::set_requestedversion(::google::protobuf::uint32 value) {
   set_has_requestedversion();
   requestedversion_ = value;
+  // @@protoc_insertion_point(field_set:CleanerInitMessage.requestedVersion)
 }
 
 // required string clientSecret = 2;
@@ -747,54 +789,59 @@ inline void CleanerInitMessage::clear_has_clientsecret() {
   _has_bits_[0] &= ~0x00000002u;
 }
 inline void CleanerInitMessage::clear_clientsecret() {
-  if (clientsecret_ != &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     clientsecret_->clear();
   }
   clear_has_clientsecret();
 }
 inline const ::std::string& CleanerInitMessage::clientsecret() const {
+  // @@protoc_insertion_point(field_get:CleanerInitMessage.clientSecret)
   return *clientsecret_;
 }
 inline void CleanerInitMessage::set_clientsecret(const ::std::string& value) {
   set_has_clientsecret();
-  if (clientsecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     clientsecret_ = new ::std::string;
   }
   clientsecret_->assign(value);
+  // @@protoc_insertion_point(field_set:CleanerInitMessage.clientSecret)
 }
 inline void CleanerInitMessage::set_clientsecret(const char* value) {
   set_has_clientsecret();
-  if (clientsecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     clientsecret_ = new ::std::string;
   }
   clientsecret_->assign(value);
+  // @@protoc_insertion_point(field_set_char:CleanerInitMessage.clientSecret)
 }
 inline void CleanerInitMessage::set_clientsecret(const char* value, size_t size) {
   set_has_clientsecret();
-  if (clientsecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     clientsecret_ = new ::std::string;
   }
   clientsecret_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:CleanerInitMessage.clientSecret)
 }
 inline ::std::string* CleanerInitMessage::mutable_clientsecret() {
   set_has_clientsecret();
-  if (clientsecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     clientsecret_ = new ::std::string;
   }
+  // @@protoc_insertion_point(field_mutable:CleanerInitMessage.clientSecret)
   return clientsecret_;
 }
 inline ::std::string* CleanerInitMessage::release_clientsecret() {
   clear_has_clientsecret();
-  if (clientsecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
     ::std::string* temp = clientsecret_;
-    clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
 inline void CleanerInitMessage::set_allocated_clientsecret(::std::string* clientsecret) {
-  if (clientsecret_ != &::google::protobuf::internal::kEmptyString) {
+  if (clientsecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete clientsecret_;
   }
   if (clientsecret) {
@@ -802,8 +849,9 @@ inline void CleanerInitMessage::set_allocated_clientsecret(::std::string* client
     clientsecret_ = clientsecret;
   } else {
     clear_has_clientsecret();
-    clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    clientsecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
+  // @@protoc_insertion_point(field_set_allocated:CleanerInitMessage.clientSecret)
 }
 
 // -------------------------------------------------------------------
@@ -825,11 +873,13 @@ inline void CleanerInitAckMessage::clear_serverversion() {
   clear_has_serverversion();
 }
 inline ::google::protobuf::uint32 CleanerInitAckMessage::serverversion() const {
+  // @@protoc_insertion_point(field_get:CleanerInitAckMessage.serverVersion)
   return serverversion_;
 }
 inline void CleanerInitAckMessage::set_serverversion(::google::protobuf::uint32 value) {
   set_has_serverversion();
   serverversion_ = value;
+  // @@protoc_insertion_point(field_set:CleanerInitAckMessage.serverVersion)
 }
 
 // required string serverSecret = 2;
@@ -843,54 +893,59 @@ inline void CleanerInitAckMessage::clear_has_serversecret() {
   _has_bits_[0] &= ~0x00000002u;
 }
 inline void CleanerInitAckMessage::clear_serversecret() {
-  if (serversecret_ != &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     serversecret_->clear();
   }
   clear_has_serversecret();
 }
 inline const ::std::string& CleanerInitAckMessage::serversecret() const {
+  // @@protoc_insertion_point(field_get:CleanerInitAckMessage.serverSecret)
   return *serversecret_;
 }
 inline void CleanerInitAckMessage::set_serversecret(const ::std::string& value) {
   set_has_serversecret();
-  if (serversecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     serversecret_ = new ::std::string;
   }
   serversecret_->assign(value);
+  // @@protoc_insertion_point(field_set:CleanerInitAckMessage.serverSecret)
 }
 inline void CleanerInitAckMessage::set_serversecret(const char* value) {
   set_has_serversecret();
-  if (serversecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     serversecret_ = new ::std::string;
   }
   serversecret_->assign(value);
+  // @@protoc_insertion_point(field_set_char:CleanerInitAckMessage.serverSecret)
 }
 inline void CleanerInitAckMessage::set_serversecret(const char* value, size_t size) {
   set_has_serversecret();
-  if (serversecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     serversecret_ = new ::std::string;
   }
   serversecret_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:CleanerInitAckMessage.serverSecret)
 }
 inline ::std::string* CleanerInitAckMessage::mutable_serversecret() {
   set_has_serversecret();
-  if (serversecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     serversecret_ = new ::std::string;
   }
+  // @@protoc_insertion_point(field_mutable:CleanerInitAckMessage.serverSecret)
   return serversecret_;
 }
 inline ::std::string* CleanerInitAckMessage::release_serversecret() {
   clear_has_serversecret();
-  if (serversecret_ == &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
     ::std::string* temp = serversecret_;
-    serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
 inline void CleanerInitAckMessage::set_allocated_serversecret(::std::string* serversecret) {
-  if (serversecret_ != &::google::protobuf::internal::kEmptyString) {
+  if (serversecret_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete serversecret_;
   }
   if (serversecret) {
@@ -898,8 +953,9 @@ inline void CleanerInitAckMessage::set_allocated_serversecret(::std::string* ser
     serversecret_ = serversecret;
   } else {
     clear_has_serversecret();
-    serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    serversecret_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
+  // @@protoc_insertion_point(field_set_allocated:CleanerInitAckMessage.serverSecret)
 }
 
 // -------------------------------------------------------------------
@@ -921,11 +977,13 @@ inline void CleanerChatRequestMessage::clear_requestid() {
   clear_has_requestid();
 }
 inline ::google::protobuf::uint32 CleanerChatRequestMessage::requestid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.requestId)
   return requestid_;
 }
 inline void CleanerChatRequestMessage::set_requestid(::google::protobuf::uint32 value) {
   set_has_requestid();
   requestid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.requestId)
 }
 
 // required .CleanerChatType cleanerChatType = 2;
@@ -943,12 +1001,14 @@ inline void CleanerChatRequestMessage::clear_cleanerchattype() {
   clear_has_cleanerchattype();
 }
 inline ::CleanerChatType CleanerChatRequestMessage::cleanerchattype() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.cleanerChatType)
   return static_cast< ::CleanerChatType >(cleanerchattype_);
 }
 inline void CleanerChatRequestMessage::set_cleanerchattype(::CleanerChatType value) {
   assert(::CleanerChatType_IsValid(value));
   set_has_cleanerchattype();
   cleanerchattype_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.cleanerChatType)
 }
 
 // optional uint32 gameId = 3 [default = 0];
@@ -966,11 +1026,13 @@ inline void CleanerChatRequestMessage::clear_gameid() {
   clear_has_gameid();
 }
 inline ::google::protobuf::uint32 CleanerChatRequestMessage::gameid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.gameId)
   return gameid_;
 }
 inline void CleanerChatRequestMessage::set_gameid(::google::protobuf::uint32 value) {
   set_has_gameid();
   gameid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.gameId)
 }
 
 // required uint32 playerId = 4;
@@ -988,11 +1050,13 @@ inline void CleanerChatRequestMessage::clear_playerid() {
   clear_has_playerid();
 }
 inline ::google::protobuf::uint32 CleanerChatRequestMessage::playerid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.playerId)
   return playerid_;
 }
 inline void CleanerChatRequestMessage::set_playerid(::google::protobuf::uint32 value) {
   set_has_playerid();
   playerid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.playerId)
 }
 
 // required string playerName = 5;
@@ -1006,54 +1070,59 @@ inline void CleanerChatRequestMessage::clear_has_playername() {
   _has_bits_[0] &= ~0x00000010u;
 }
 inline void CleanerChatRequestMessage::clear_playername() {
-  if (playername_ != &::google::protobuf::internal::kEmptyString) {
+  if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     playername_->clear();
   }
   clear_has_playername();
 }
 inline const ::std::string& CleanerChatRequestMessage::playername() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.playerName)
   return *playername_;
 }
 inline void CleanerChatRequestMessage::set_playername(const ::std::string& value) {
   set_has_playername();
-  if (playername_ == &::google::protobuf::internal::kEmptyString) {
+  if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     playername_ = new ::std::string;
   }
   playername_->assign(value);
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.playerName)
 }
 inline void CleanerChatRequestMessage::set_playername(const char* value) {
   set_has_playername();
-  if (playername_ == &::google::protobuf::internal::kEmptyString) {
+  if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     playername_ = new ::std::string;
   }
   playername_->assign(value);
+  // @@protoc_insertion_point(field_set_char:CleanerChatRequestMessage.playerName)
 }
 inline void CleanerChatRequestMessage::set_playername(const char* value, size_t size) {
   set_has_playername();
-  if (playername_ == &::google::protobuf::internal::kEmptyString) {
+  if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     playername_ = new ::std::string;
   }
   playername_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:CleanerChatRequestMessage.playerName)
 }
 inline ::std::string* CleanerChatRequestMessage::mutable_playername() {
   set_has_playername();
-  if (playername_ == &::google::protobuf::internal::kEmptyString) {
+  if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     playername_ = new ::std::string;
   }
+  // @@protoc_insertion_point(field_mutable:CleanerChatRequestMessage.playerName)
   return playername_;
 }
 inline ::std::string* CleanerChatRequestMessage::release_playername() {
   clear_has_playername();
-  if (playername_ == &::google::protobuf::internal::kEmptyString) {
+  if (playername_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
     ::std::string* temp = playername_;
-    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
 inline void CleanerChatRequestMessage::set_allocated_playername(::std::string* playername) {
-  if (playername_ != &::google::protobuf::internal::kEmptyString) {
+  if (playername_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete playername_;
   }
   if (playername) {
@@ -1061,8 +1130,9 @@ inline void CleanerChatRequestMessage::set_allocated_playername(::std::string* p
     playername_ = playername;
   } else {
     clear_has_playername();
-    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    playername_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
+  // @@protoc_insertion_point(field_set_allocated:CleanerChatRequestMessage.playerName)
 }
 
 // required string chatMessage = 6;
@@ -1076,54 +1146,59 @@ inline void CleanerChatRequestMessage::clear_has_chatmessage() {
   _has_bits_[0] &= ~0x00000020u;
 }
 inline void CleanerChatRequestMessage::clear_chatmessage() {
-  if (chatmessage_ != &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     chatmessage_->clear();
   }
   clear_has_chatmessage();
 }
 inline const ::std::string& CleanerChatRequestMessage::chatmessage() const {
+  // @@protoc_insertion_point(field_get:CleanerChatRequestMessage.chatMessage)
   return *chatmessage_;
 }
 inline void CleanerChatRequestMessage::set_chatmessage(const ::std::string& value) {
   set_has_chatmessage();
-  if (chatmessage_ == &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     chatmessage_ = new ::std::string;
   }
   chatmessage_->assign(value);
+  // @@protoc_insertion_point(field_set:CleanerChatRequestMessage.chatMessage)
 }
 inline void CleanerChatRequestMessage::set_chatmessage(const char* value) {
   set_has_chatmessage();
-  if (chatmessage_ == &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     chatmessage_ = new ::std::string;
   }
   chatmessage_->assign(value);
+  // @@protoc_insertion_point(field_set_char:CleanerChatRequestMessage.chatMessage)
 }
 inline void CleanerChatRequestMessage::set_chatmessage(const char* value, size_t size) {
   set_has_chatmessage();
-  if (chatmessage_ == &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     chatmessage_ = new ::std::string;
   }
   chatmessage_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:CleanerChatRequestMessage.chatMessage)
 }
 inline ::std::string* CleanerChatRequestMessage::mutable_chatmessage() {
   set_has_chatmessage();
-  if (chatmessage_ == &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     chatmessage_ = new ::std::string;
   }
+  // @@protoc_insertion_point(field_mutable:CleanerChatRequestMessage.chatMessage)
   return chatmessage_;
 }
 inline ::std::string* CleanerChatRequestMessage::release_chatmessage() {
   clear_has_chatmessage();
-  if (chatmessage_ == &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
     ::std::string* temp = chatmessage_;
-    chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
 inline void CleanerChatRequestMessage::set_allocated_chatmessage(::std::string* chatmessage) {
-  if (chatmessage_ != &::google::protobuf::internal::kEmptyString) {
+  if (chatmessage_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete chatmessage_;
   }
   if (chatmessage) {
@@ -1131,8 +1206,9 @@ inline void CleanerChatRequestMessage::set_allocated_chatmessage(::std::string*
     chatmessage_ = chatmessage;
   } else {
     clear_has_chatmessage();
-    chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    chatmessage_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
+  // @@protoc_insertion_point(field_set_allocated:CleanerChatRequestMessage.chatMessage)
 }
 
 // -------------------------------------------------------------------
@@ -1154,11 +1230,13 @@ inline void CleanerChatReplyMessage::clear_requestid() {
   clear_has_requestid();
 }
 inline ::google::protobuf::uint32 CleanerChatReplyMessage::requestid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.requestId)
   return requestid_;
 }
 inline void CleanerChatReplyMessage::set_requestid(::google::protobuf::uint32 value) {
   set_has_requestid();
   requestid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.requestId)
 }
 
 // required .CleanerChatType cleanerChatType = 2;
@@ -1176,12 +1254,14 @@ inline void CleanerChatReplyMessage::clear_cleanerchattype() {
   clear_has_cleanerchattype();
 }
 inline ::CleanerChatType CleanerChatReplyMessage::cleanerchattype() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.cleanerChatType)
   return static_cast< ::CleanerChatType >(cleanerchattype_);
 }
 inline void CleanerChatReplyMessage::set_cleanerchattype(::CleanerChatType value) {
   assert(::CleanerChatType_IsValid(value));
   set_has_cleanerchattype();
   cleanerchattype_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.cleanerChatType)
 }
 
 // optional uint32 gameId = 3 [default = 0];
@@ -1199,11 +1279,13 @@ inline void CleanerChatReplyMessage::clear_gameid() {
   clear_has_gameid();
 }
 inline ::google::protobuf::uint32 CleanerChatReplyMessage::gameid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.gameId)
   return gameid_;
 }
 inline void CleanerChatReplyMessage::set_gameid(::google::protobuf::uint32 value) {
   set_has_gameid();
   gameid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.gameId)
 }
 
 // required uint32 playerId = 4;
@@ -1221,11 +1303,13 @@ inline void CleanerChatReplyMessage::clear_playerid() {
   clear_has_playerid();
 }
 inline ::google::protobuf::uint32 CleanerChatReplyMessage::playerid() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.playerId)
   return playerid_;
 }
 inline void CleanerChatReplyMessage::set_playerid(::google::protobuf::uint32 value) {
   set_has_playerid();
   playerid_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.playerId)
 }
 
 // required .CleanerChatReplyMessage.CleanerActionType cleanerActionType = 5;
@@ -1243,12 +1327,14 @@ inline void CleanerChatReplyMessage::clear_cleaneractiontype() {
   clear_has_cleaneractiontype();
 }
 inline ::CleanerChatReplyMessage_CleanerActionType CleanerChatReplyMessage::cleaneractiontype() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.cleanerActionType)
   return static_cast< ::CleanerChatReplyMessage_CleanerActionType >(cleaneractiontype_);
 }
 inline void CleanerChatReplyMessage::set_cleaneractiontype(::CleanerChatReplyMessage_CleanerActionType value) {
   assert(::CleanerChatReplyMessage_CleanerActionType_IsValid(value));
   set_has_cleaneractiontype();
   cleaneractiontype_ = value;
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.cleanerActionType)
 }
 
 // optional string cleanerText = 6 [default = ""];
@@ -1262,54 +1348,59 @@ inline void CleanerChatReplyMessage::clear_has_cleanertext() {
   _has_bits_[0] &= ~0x00000020u;
 }
 inline void CleanerChatReplyMessage::clear_cleanertext() {
-  if (cleanertext_ != &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     cleanertext_->clear();
   }
   clear_has_cleanertext();
 }
 inline const ::std::string& CleanerChatReplyMessage::cleanertext() const {
+  // @@protoc_insertion_point(field_get:CleanerChatReplyMessage.cleanerText)
   return *cleanertext_;
 }
 inline void CleanerChatReplyMessage::set_cleanertext(const ::std::string& value) {
   set_has_cleanertext();
-  if (cleanertext_ == &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     cleanertext_ = new ::std::string;
   }
   cleanertext_->assign(value);
+  // @@protoc_insertion_point(field_set:CleanerChatReplyMessage.cleanerText)
 }
 inline void CleanerChatReplyMessage::set_cleanertext(const char* value) {
   set_has_cleanertext();
-  if (cleanertext_ == &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     cleanertext_ = new ::std::string;
   }
   cleanertext_->assign(value);
+  // @@protoc_insertion_point(field_set_char:CleanerChatReplyMessage.cleanerText)
 }
 inline void CleanerChatReplyMessage::set_cleanertext(const char* value, size_t size) {
   set_has_cleanertext();
-  if (cleanertext_ == &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     cleanertext_ = new ::std::string;
   }
   cleanertext_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:CleanerChatReplyMessage.cleanerText)
 }
 inline ::std::string* CleanerChatReplyMessage::mutable_cleanertext() {
   set_has_cleanertext();
-  if (cleanertext_ == &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     cleanertext_ = new ::std::string;
   }
+  // @@protoc_insertion_point(field_mutable:CleanerChatReplyMessage.cleanerText)
   return cleanertext_;
 }
 inline ::std::string* CleanerChatReplyMessage::release_cleanertext() {
   clear_has_cleanertext();
-  if (cleanertext_ == &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     return NULL;
   } else {
     ::std::string* temp = cleanertext_;
-    cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
     return temp;
   }
 }
 inline void CleanerChatReplyMessage::set_allocated_cleanertext(::std::string* cleanertext) {
-  if (cleanertext_ != &::google::protobuf::internal::kEmptyString) {
+  if (cleanertext_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete cleanertext_;
   }
   if (cleanertext) {
@@ -1317,8 +1408,9 @@ inline void CleanerChatReplyMessage::set_allocated_cleanertext(::std::string* cl
     cleanertext_ = cleanertext;
   } else {
     clear_has_cleanertext();
-    cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
+    cleanertext_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   }
+  // @@protoc_insertion_point(field_set_allocated:CleanerChatReplyMessage.cleanerText)
 }
 
 // -------------------------------------------------------------------
@@ -1340,12 +1432,14 @@ inline void ChatCleanerMessage::clear_messagetype() {
   clear_has_messagetype();
 }
 inline ::ChatCleanerMessage_ChatCleanerMessageType ChatCleanerMessage::messagetype() const {
+  // @@protoc_insertion_point(field_get:ChatCleanerMessage.messageType)
   return static_cast< ::ChatCleanerMessage_ChatCleanerMessageType >(messagetype_);
 }
 inline void ChatCleanerMessage::set_messagetype(::ChatCleanerMessage_ChatCleanerMessageType value) {
   assert(::ChatCleanerMessage_ChatCleanerMessageType_IsValid(value));
   set_has_messagetype();
   messagetype_ = value;
+  // @@protoc_insertion_point(field_set:ChatCleanerMessage.messageType)
 }
 
 // optional .CleanerInitMessage cleanerInitMessage = 2;
@@ -1363,6 +1457,7 @@ inline void ChatCleanerMessage::clear_cleanerinitmessage() {
   clear_has_cleanerinitmessage();
 }
 inline const ::CleanerInitMessage& ChatCleanerMessage::cleanerinitmessage() const {
+  // @@protoc_insertion_point(field_get:ChatCleanerMessage.cleanerInitMessage)
 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   return cleanerinitmessage_ != NULL ? *cleanerinitmessage_ : *default_instance().cleanerinitmessage_;
 #else
@@ -1372,6 +1467,7 @@ inline const ::CleanerInitMessage& ChatCleanerMessage::cleanerinitmessage() cons
 inline ::CleanerInitMessage* ChatCleanerMessage::mutable_cleanerinitmessage() {
   set_has_cleanerinitmessage();
   if (cleanerinitmessage_ == NULL) cleanerinitmessage_ = new ::CleanerInitMessage;
+  // @@protoc_insertion_point(field_mutable:ChatCleanerMessage.cleanerInitMessage)
   return cleanerinitmessage_;
 }
 inline ::CleanerInitMessage* ChatCleanerMessage::release_cleanerinitmessage() {
@@ -1388,6 +1484,7 @@ inline void ChatCleanerMessage::set_allocated_cleanerinitmessage(::CleanerInitMe
   } else {
     clear_has_cleanerinitmessage();
   }
+  // @@protoc_insertion_point(field_set_allocated:ChatCleanerMessage.cleanerInitMessage)
 }
 
 // optional .CleanerInitAckMessage cleanerInitAckMessage = 3;
@@ -1405,6 +1502,7 @@ inline void ChatCleanerMessage::clear_cleanerinitackmessage() {
   clear_has_cleanerinitackmessage();
 }
 inline const ::CleanerInitAckMessage& ChatCleanerMessage::cleanerinitackmessage() const {
+  // @@protoc_insertion_point(field_get:ChatCleanerMessage.cleanerInitAckMessage)
 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   return cleanerinitackmessage_ != NULL ? *cleanerinitackmessage_ : *default_instance().cleanerinitackmessage_;
 #else
@@ -1414,6 +1512,7 @@ inline const ::CleanerInitAckMessage& ChatCleanerMessage::cleanerinitackmessage(
 inline ::CleanerInitAckMessage* ChatCleanerMessage::mutable_cleanerinitackmessage() {
   set_has_cleanerinitackmessage();
   if (cleanerinitackmessage_ == NULL) cleanerinitackmessage_ = new ::CleanerInitAckMessage;
+  // @@protoc_insertion_point(field_mutable:ChatCleanerMessage.cleanerInitAckMessage)
   return cleanerinitackmessage_;
 }
 inline ::CleanerInitAckMessage* ChatCleanerMessage::release_cleanerinitackmessage() {
@@ -1430,6 +1529,7 @@ inline void ChatCleanerMessage::set_allocated_cleanerinitackmessage(::CleanerIni
   } else {
     clear_has_cleanerinitackmessage();
   }
+  // @@protoc_insertion_point(field_set_allocated:ChatCleanerMessage.cleanerInitAckMessage)
 }
 
 // optional .CleanerChatRequestMessage cleanerChatRequestMessage = 4;
@@ -1447,6 +1547,7 @@ inline void ChatCleanerMessage::clear_cleanerchatrequestmessage() {
   clear_has_cleanerchatrequestmessage();
 }
 inline const ::CleanerChatRequestMessage& ChatCleanerMessage::cleanerchatrequestmessage() const {
+  // @@protoc_insertion_point(field_get:ChatCleanerMessage.cleanerChatRequestMessage)
 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   return cleanerchatrequestmessage_ != NULL ? *cleanerchatrequestmessage_ : *default_instance().cleanerchatrequestmessage_;
 #else
@@ -1456,6 +1557,7 @@ inline const ::CleanerChatRequestMessage& ChatCleanerMessage::cleanerchatrequest
 inline ::CleanerChatRequestMessage* ChatCleanerMessage::mutable_cleanerchatrequestmessage() {
   set_has_cleanerchatrequestmessage();
   if (cleanerchatrequestmessage_ == NULL) cleanerchatrequestmessage_ = new ::CleanerChatRequestMessage;
+  // @@protoc_insertion_point(field_mutable:ChatCleanerMessage.cleanerChatRequestMessage)
   return cleanerchatrequestmessage_;
 }
 inline ::CleanerChatRequestMessage* ChatCleanerMessage::release_cleanerchatrequestmessage() {
@@ -1472,6 +1574,7 @@ inline void ChatCleanerMessage::set_allocated_cleanerchatrequestmessage(::Cleane
   } else {
     clear_has_cleanerchatrequestmessage();
   }
+  // @@protoc_insertion_point(field_set_allocated:ChatCleanerMessage.cleanerChatRequestMessage)
 }
 
 // optional .CleanerChatReplyMessage cleanerChatReplyMessage = 5;
@@ -1489,6 +1592,7 @@ inline void ChatCleanerMessage::clear_cleanerchatreplymessage() {
   clear_has_cleanerchatreplymessage();
 }
 inline const ::CleanerChatReplyMessage& ChatCleanerMessage::cleanerchatreplymessage() const {
+  // @@protoc_insertion_point(field_get:ChatCleanerMessage.cleanerChatReplyMessage)
 #ifdef GOOGLE_PROTOBUF_NO_STATIC_INITIALIZER
   return cleanerchatreplymessage_ != NULL ? *cleanerchatreplymessage_ : *default_instance().cleanerchatreplymessage_;
 #else
@@ -1498,6 +1602,7 @@ inline const ::CleanerChatReplyMessage& ChatCleanerMessage::cleanerchatreplymess
 inline ::CleanerChatReplyMessage* ChatCleanerMessage::mutable_cleanerchatreplymessage() {
   set_has_cleanerchatreplymessage();
   if (cleanerchatreplymessage_ == NULL) cleanerchatreplymessage_ = new ::CleanerChatReplyMessage;
+  // @@protoc_insertion_point(field_mutable:ChatCleanerMessage.cleanerChatReplyMessage)
   return cleanerchatreplymessage_;
 }
 inline ::CleanerChatReplyMessage* ChatCleanerMessage::release_cleanerchatreplymessage() {
@@ -1514,6 +1619,7 @@ inline void ChatCleanerMessage::set_allocated_cleanerchatreplymessage(::CleanerC
   } else {
     clear_has_cleanerchatreplymessage();
   }
+  // @@protoc_insertion_point(field_set_allocated:ChatCleanerMessage.cleanerChatReplyMessage)
 }
 
 

src/third_party/qtsingleapplication/qtlocalpeer.cpp

@@ -44,6 +44,10 @@ static PProcessIdToSessionId pProcessIdToSessionId = 0;
 #include <unistd.h>
 #endif
 
+// @FIXME: bugfix for strange new compiler error on ubuntu 16.04 = ‘QDataStream ds’ has initializer but incomplete type
+// not sure if that collides on other systems:
+#include <QDataStream>
+
 namespace SharedTools {
 
 static const char ack[] = "ack";