Fixed sender again, as it did not work when sending errors.

src/net/clientcontext.h

@@ -34,10 +34,7 @@ public:
 	virtual SOCKET GetSocket() const;
 	void SetSocket(SOCKET sockfd);
 
-	SessionId GetSessionId() const
+	boost::shared_ptr<SessionData> GetSessionData() const;
-	{return m_sessionId;}
-	void SetSessionId(SessionId sessionId)
-	{m_sessionId = sessionId;}
 	int GetProtocol() const
 	{return m_protocol;}
 	void SetProtocol(int protocol)
@@ -78,8 +75,7 @@ public:
 	{return m_receiveBuffer;}
 
 private:
-	SOCKET				m_sockfd;
+	boost::shared_ptr<SessionData> m_sessionData;
-	SessionId			m_sessionId;
 	int					m_protocol;
 	int					m_addrFamily;
 	std::string			m_serverAddr;

src/net/common/clientcontext.cpp

@@ -20,26 +20,31 @@
 #include <net/clientcontext.h>
 
 ClientContext::ClientContext()
-: m_sockfd(INVALID_SOCKET), m_sessionId(SESSION_ID_GENERIC), m_protocol(0), m_addrFamily(AF_INET), m_serverPort(0)
+: m_protocol(0), m_addrFamily(AF_INET), m_serverPort(0)
 {
 	bzero(&m_clientSockaddr, sizeof(m_clientSockaddr));
 }
 
 ClientContext::~ClientContext()
 {
-	if (m_sockfd != INVALID_SOCKET)
-		CLOSESOCKET(m_sockfd);
 }
 
 SOCKET
 ClientContext::GetSocket() const
 {
-	return m_sockfd;
+	assert(m_sessionData.get());
+	return m_sessionData->GetSocket();
 }
 
 void
 ClientContext::SetSocket(SOCKET sockfd)
 {
-	m_sockfd = sockfd;
+	m_sessionData.reset(new SessionData(sockfd, SESSION_ID_GENERIC));
+}
+
+boost::shared_ptr<SessionData>
+ClientContext::GetSessionData() const
+{
+	return m_sessionData;
 }
 

src/net/common/clientstate.cpp

@@ -362,7 +362,7 @@ ClientStateStartSession::Process(ClientThread &client)
 	boost::shared_ptr<NetPacket> packet(new NetPacketInit);
 	((NetPacketInit *)packet.get())->SetData(initData);
 	
-	client.GetSender().Send(context.GetSessionId(), packet);
+	client.GetSender().Send(context.GetSessionData(), packet);
 
 	client.SetState(ClientStateWaitSession::Instance());
 
@@ -592,7 +592,7 @@ ClientStateWaitSession::InternalProcess(ClientThread &client, boost::shared_ptr<
 			tmpList);
 
 		if (!avatarError)
-			client.GetSender().SendLowPrio(client.GetContext().GetSessionId(), tmpList);
+			client.GetSender().SendLowPrio(client.GetContext().GetSessionData(), tmpList);
 		else
 			throw ClientException(__FILE__, __LINE__, avatarError, 0);
 	}
@@ -740,7 +740,7 @@ ClientStateSynchronizeStart::Process(ClientThread &client)
 	if (client.IsSynchronized())
 	{
 		boost::shared_ptr<NetPacket> startAck(new NetPacketStartEventAck);
-		client.GetSender().Send(client.GetContext().GetSessionId(), startAck);
+		client.GetSender().Send(client.GetContext().GetSessionData(), startAck);
 		client.SetState(ClientStateWaitStart::Instance());
 	}
 

src/net/common/clientthread.cpp

@@ -42,12 +42,6 @@ public:
 	ClientSenderCallback(ClientThread &client) : m_client(client) {}
 	virtual ~ClientSenderCallback() {}
 
-	virtual bool GetSocketForSession(SessionId session, SOCKET &outSocket)
-	{
-		assert(session == m_client.GetContext().GetSessionId());
-		outSocket = m_client.GetContext().GetSocket();
-		return true;
-	}
 	virtual void SignalNetError(SessionId /*session*/, int errorID, int osErrorID)
 	{
 		// Just signal the error.
@@ -374,7 +368,7 @@ ClientThread::SendPacketLoop()
 
 		while (i != end)
 		{
-			GetSender().Send(GetContext().GetSessionId(), *i);
+			GetSender().Send(GetContext().GetSessionData(), *i);
 			++i;
 		}
 		m_outPacketList.clear();
@@ -405,7 +399,7 @@ ClientThread::RequestPlayerInfo(unsigned id)
 		NetPacketRetrievePlayerInfo::Data reqData;
 		reqData.playerId = id;
 		static_cast<NetPacketRetrievePlayerInfo *>(req.get())->SetData(reqData);
-		GetSender().Send(GetContext().GetSessionId(), req);
+		GetSender().Send(GetContext().GetSessionData(), req);
 
 		m_playerInfoRequestList.push_back(id);
 	}
@@ -443,7 +437,7 @@ ClientThread::SetPlayerInfo(unsigned id, const PlayerInfo &info, bool retrieveAv
 		retrieveAvatarData.requestId = id;
 		retrieveAvatarData.avatar = info.avatar;
 		static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
-		GetSender().Send(GetContext().GetSessionId(), retrieveAvatar);
+		GetSender().Send(GetContext().GetSessionData(), retrieveAvatar);
 
 		// Insert empty value in list to synchronize waiting.
 		m_tempAvatarMap[id] = boost::shared_ptr<AvatarData>();

src/net/common/senderthread.cpp

@@ -28,7 +28,7 @@ using namespace std;
 
 
 SenderThread::SenderThread(SenderCallback &cb)
-: m_curSession(INVALID_SESSION), m_tmpOutBufSize(0), m_callback(cb)
+: m_tmpOutBufSize(0), m_callback(cb)
 {
 }
 
@@ -37,9 +37,9 @@ SenderThread::~SenderThread()
 }
 
 void
-SenderThread::Send(SessionId session, boost::shared_ptr<NetPacket> packet)
+SenderThread::Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
 {
-	if (packet.get() && session != INVALID_SESSION)
+	if (packet.get() && session.get())
 	{
 		boost::mutex::scoped_lock lock(m_outBufMutex);
 		InternalStore(m_outBuf, SEND_QUEUE_SIZE, session, packet);
@@ -47,9 +47,9 @@ SenderThread::Send(SessionId session, boost::shared_ptr<NetPacket> packet)
 }
 
 void
-SenderThread::Send(SessionId session, const NetPacketList &packetList)
+SenderThread::Send(boost::shared_ptr<SessionData> session, const NetPacketList &packetList)
 {
-	if (!packetList.empty() && session != INVALID_SESSION)
+	if (!packetList.empty() && session.get())
 	{
 		boost::mutex::scoped_lock lock(m_outBufMutex);
 		InternalStore(m_outBuf, SEND_QUEUE_SIZE, session, packetList);
@@ -57,9 +57,9 @@ SenderThread::Send(SessionId session, const NetPacketList &packetList)
 }
 
 void
-SenderThread::SendLowPrio(SessionId session, boost::shared_ptr<NetPacket> packet)
+SenderThread::SendLowPrio(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
 {
-	if (packet.get() && session != INVALID_SESSION)
+	if (packet.get() && session.get())
 	{
 		boost::mutex::scoped_lock lock(m_lowPrioOutBufMutex);
 		InternalStore(m_lowPrioOutBuf, SEND_LOW_PRIO_QUEUE_SIZE, session, packet);
@@ -67,9 +67,9 @@ SenderThread::SendLowPrio(SessionId session, boost::shared_ptr<NetPacket> packet
 }
 
 void
-SenderThread::SendLowPrio(SessionId session, const NetPacketList &packetList)
+SenderThread::SendLowPrio(boost::shared_ptr<SessionData> session, const NetPacketList &packetList)
 {
-	if (!packetList.empty() && session != INVALID_SESSION)
+	if (!packetList.empty() && session.get())
 	{
 		boost::mutex::scoped_lock lock(m_lowPrioOutBufMutex);
 		InternalStore(m_lowPrioOutBuf, SEND_LOW_PRIO_QUEUE_SIZE, session, packetList);
@@ -77,7 +77,7 @@ SenderThread::SendLowPrio(SessionId session, const NetPacketList &packetList)
 }
 
 void
-SenderThread::InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, SessionId session, boost::shared_ptr<NetPacket> packet)
+SenderThread::InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet)
 {
 	if (sendQueue.size() < maxQueueSize) // Queue is limited in size.
 		sendQueue.push_back(std::make_pair(packet, session));
@@ -85,7 +85,7 @@ SenderThread::InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, Ses
 }
 
 void
-SenderThread::InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, SessionId session, const NetPacketList &packetList)
+SenderThread::InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, boost::shared_ptr<SessionData> session, const NetPacketList &packetList)
 {
 	if (sendQueue.size() + packetList.size() < maxQueueSize)
 	{
@@ -134,7 +134,7 @@ SenderThread::Main()
 
 			if (tmpData.first.get())
 			{
-				if (tmpData.second != INVALID_SESSION)
+				if (tmpData.second.get())
 					m_curSession = tmpData.second;
 
 				u_int16_t tmpLen = tmpData.first->GetLen();
@@ -147,25 +147,37 @@ SenderThread::Main()
 		}
 		if (m_tmpOutBufSize)
 		{
-			SOCKET tmpSocket;
+			SOCKET tmpSocket = m_curSession->GetSocket();
-			if (!m_callback.GetSocketForSession(m_curSession, tmpSocket))
+			fd_set writeSet;
+			struct timeval timeout;
+
+			FD_ZERO(&writeSet);
+			FD_SET(tmpSocket, &writeSet);
+
+			timeout.tv_sec  = 0;
+			timeout.tv_usec = SEND_TIMEOUT_MSEC * 1000;
+			int selectResult = select(tmpSocket + 1, NULL, &writeSet, NULL, &timeout);
+			if (!IS_VALID_SELECT(selectResult))
 			{
-				// Invalid session - skip.
+				// Never assume that this is a fatal error.
-				m_tmpOutBufSize = 0;
+				int errCode = SOCKET_ERRNO();
-				m_curSession = INVALID_SESSION;
+				if (errCode != SOCKET_ERR_WOULDBLOCK)
+				{
+					// Skip this packet - this is bad, and is therefore reported.
+					// Ignore invalid or not connected sockets.
+					if (errCode != SOCKET_ERR_NOTCONN && errCode != SOCKET_ERR_NOTSOCK)
+						m_callback.SignalNetError(m_curSession->GetId(), ERR_SOCK_SELECT_FAILED, errCode);
+					m_tmpOutBufSize = 0;
+					m_curSession.reset();
+				}
+				Msleep(SEND_TIMEOUT_MSEC);
 			}
-			else
+			if (selectResult > 0) // send is possible
 			{
-				fd_set writeSet;
+				// send next chunk of data
-				struct timeval timeout;
+				int bytesSent = send(tmpSocket, m_tmpOutBuf, m_tmpOutBufSize, 0);
 
-				FD_ZERO(&writeSet);
+				if (!IS_VALID_SEND(bytesSent))
-				FD_SET(tmpSocket, &writeSet);
-
-				timeout.tv_sec  = 0;
-				timeout.tv_usec = SEND_TIMEOUT_MSEC * 1000;
-				int selectResult = select(tmpSocket + 1, NULL, &writeSet, NULL, &timeout);
-				if (!IS_VALID_SELECT(selectResult))
 				{
 					// Never assume that this is a fatal error.
 					int errCode = SOCKET_ERRNO();
@@ -174,42 +186,21 @@ SenderThread::Main()
 						// Skip this packet - this is bad, and is therefore reported.
 						// Ignore invalid or not connected sockets.
 						if (errCode != SOCKET_ERR_NOTCONN && errCode != SOCKET_ERR_NOTSOCK)
-							m_callback.SignalNetError(m_curSession, ERR_SOCK_SELECT_FAILED, errCode);
+							m_callback.SignalNetError(m_curSession->GetId(), ERR_SOCK_SEND_FAILED, errCode);
 						m_tmpOutBufSize = 0;
-						m_curSession = INVALID_SESSION;
+						m_curSession.reset();
 					}
 					Msleep(SEND_TIMEOUT_MSEC);
 				}
-				if (selectResult > 0) // send is possible
+				else if ((unsigned)bytesSent < m_tmpOutBufSize)
 				{
-					// send next chunk of data
+					m_tmpOutBufSize -= (unsigned)bytesSent;
-					int bytesSent = send(tmpSocket, m_tmpOutBuf, m_tmpOutBufSize, 0);
+					memmove(m_tmpOutBuf, m_tmpOutBuf + bytesSent, m_tmpOutBufSize);
-
+				}
-					if (!IS_VALID_SEND(bytesSent))
+				else
-					{
+				{
-						// Never assume that this is a fatal error.
+					m_tmpOutBufSize = 0;
-						int errCode = SOCKET_ERRNO();
+					m_curSession.reset();
-						if (errCode != SOCKET_ERR_WOULDBLOCK)
-						{
-							// Skip this packet - this is bad, and is therefore reported.
-							// Ignore invalid or not connected sockets.
-							if (errCode != SOCKET_ERR_NOTCONN && errCode != SOCKET_ERR_NOTSOCK)
-								m_callback.SignalNetError(m_curSession, ERR_SOCK_SEND_FAILED, errCode);
-							m_tmpOutBufSize = 0;
-							m_curSession = INVALID_SESSION;
-						}
-						Msleep(SEND_TIMEOUT_MSEC);
-					}
-					else if ((unsigned)bytesSent < m_tmpOutBufSize)
-					{
-						m_tmpOutBufSize -= (unsigned)bytesSent;
-						memmove(m_tmpOutBuf, m_tmpOutBuf + bytesSent, m_tmpOutBufSize);
-					}
-					else
-					{
-						m_tmpOutBufSize = 0;
-						m_curSession = INVALID_SESSION;
-					}
 				}
 			}
 		}

src/net/common/servergamestate.cpp

@@ -271,7 +271,7 @@ ServerGameStateInit::HandleNewSession(ServerGameThread &server, SessionWrapper s
 			joinGameAckData.prights = session.playerData->GetRights();
 			joinGameAckData.gameData = server.GetGameData();
 			static_cast<NetPacketJoinGameAck *>(joinGameAck.get())->SetData(joinGameAckData);
-			server.GetSender().Send(session.sessionData->GetId(), joinGameAck);
+			server.GetSender().Send(session.sessionData, joinGameAck);
 
 			// Send notifications for connected players to client.
 			PlayerDataList tmpPlayerList = server.GetFullPlayerDataList();
@@ -279,7 +279,7 @@ ServerGameStateInit::HandleNewSession(ServerGameThread &server, SessionWrapper s
 			PlayerDataList::iterator player_end = tmpPlayerList.end();
 			while (player_i != player_end)
 			{
-				server.GetSender().Send(session.sessionData->GetId(), CreateNetPacketPlayerJoined(*(*player_i)));
+				server.GetSender().Send(session.sessionData, CreateNetPacketPlayerJoined(*(*player_i)));
 				++player_i;
 			}
 
@@ -538,7 +538,7 @@ ServerGameStateStartHand::Process(ServerGameThread &server)
 			handStartData.smallBlind = curGame.getCurrentHand()->getSmallBlind();
 			static_cast<NetPacketHandStart *>(notifyCards.get())->SetData(handStartData);
 
-			server.GetSender().Send(tmpPlayer->getNetSessionData()->GetId(), notifyCards);
+			server.GetSender().Send(tmpPlayer->getNetSessionData(), notifyCards);
 		}
 		++i;
 	}
@@ -908,7 +908,7 @@ ServerGameStateWaitPlayerAction::InternalProcess(ServerGameThread &server, Sessi
 			rejectData.playerBet = actionData.playerBet;
 			rejectData.rejectionReason = code;
 			static_cast<NetPacketPlayersActionRejected *>(reject.get())->SetData(rejectData);
-			server.GetSender().Send(session.sessionData->GetId(), reject);
+			server.GetSender().Send(session.sessionData, reject);
 		}
 	}
 

src/net/common/servergamethread.cpp

@@ -40,10 +40,6 @@ public:
 	GameSenderCallback(ServerGameThread &server) : m_server(server) {}
 	virtual ~GameSenderCallback() {}
 
-	virtual bool GetSocketForSession(SessionId session, SOCKET &outSocket)
-	{
-		return m_server.GetSessionManager().GetSocketForSession(session, outSocket);
-	}
 	virtual void SignalNetError(SessionId /*session*/, int /*errorID*/, int /*osErrorID*/)
 	{
 		// We just ignore send errors for now, on server side.

src/net/common/serverlobbythread.cpp

@@ -46,10 +46,6 @@ public:
 	ServerSenderCallback(ServerLobbyThread &server) : m_server(server) {}
 	virtual ~ServerSenderCallback() {}
 
-	virtual bool GetSocketForSession(SessionId session, SOCKET &outSocket)
-	{
-		return m_server.GetSocketForSession(session, outSocket);
-	}
 	virtual void SignalNetError(SessionId /*session*/, int /*errorID*/, int /*osErrorID*/)
 	{
 		// We just ignore send errors for now, on server side.
@@ -97,7 +93,7 @@ ServerLobbyThread::ReAddSession(SessionWrapper session, int reason)
 	NetPacketRemovedFromGame::Data removedData;
 	removedData.removeReason = reason;
 	static_cast<NetPacketRemovedFromGame *>(packet.get())->SetData(removedData);
-	GetSender().Send(session.sessionData->GetId(), packet);
+	GetSender().Send(session.sessionData, packet);
 
 	boost::mutex::scoped_lock lock(m_sessionQueueMutex);
 	m_sessionQueue.push_back(session);
@@ -120,7 +116,9 @@ void
 ServerLobbyThread::RemoveSessionFromGame(SessionWrapper session)
 {
 	// Just remove the session. Only for fatal errors.
-	CloseSessionDelayed(session);
+	m_gameSessionManager.RemoveSession(session.sessionData->GetId());
+	// Update stats (if needed).
+	BroadcastStatisticsUpdate();
 }
 
 void
@@ -230,15 +228,6 @@ ServerLobbyThread::RemoveGame(unsigned id)
 	m_removeGameList.push_back(id);
 }
 
-bool
-ServerLobbyThread::GetSocketForSession(SessionId session, SOCKET &outSocket)
-{
-	bool retVal = m_sessionManager.GetSocketForSession(session, outSocket);
-	if (!retVal)
-		retVal = m_gameSessionManager.GetSocketForSession(session, outSocket);
-	return retVal;
-}
-
 AvatarManager &
 ServerLobbyThread::GetAvatarManager()
 {
@@ -310,7 +299,10 @@ ServerLobbyThread::ProcessLoop()
 		} catch (const NetException &)
 		{
 			// On error: Close this session.
-			CloseSessionDelayed(session);
+			m_initTimerSessionMap.erase(session.sessionData->GetId());
+			m_sessionManager.RemoveSession(session.sessionData->GetId());
+			// Update stats (if needed).
+			BroadcastStatisticsUpdate();
 			return;
 		}
 		if (packet.get())
@@ -519,7 +511,7 @@ ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, con
 		if (infoData.playerInfo.hasAvatar)
 			infoData.playerInfo.avatar = tmpPlayer->GetAvatarMD5();
 		static_cast<NetPacketPlayerInfo *>(info.get())->SetData(infoData);
-		GetSender().Send(session.sessionData->GetId(), info);
+		GetSender().Send(session.sessionData, info);
 	}
 	else
 	{
@@ -528,7 +520,7 @@ ServerLobbyThread::HandleNetPacketRetrievePlayerInfo(SessionWrapper session, con
 		NetPacketUnknownPlayerId::Data unknownData;
 		unknownData.playerId = request.playerId;
 		static_cast<NetPacketUnknownPlayerId *>(unknown.get())->SetData(unknownData);
-		GetSender().Send(session.sessionData->GetId(), unknown);
+		GetSender().Send(session.sessionData, unknown);
 	}
 }
 
@@ -546,7 +538,7 @@ ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const N
 		if (GetAvatarManager().AvatarFileToNetPackets(tmpFile, request.requestId, tmpPackets) == 0)
 		{
 			avatarFound = true;
-			GetSender().SendLowPrio(session.sessionData->GetId(), tmpPackets);
+			GetSender().SendLowPrio(session.sessionData, tmpPackets);
 		}
 		else
 			LOG_ERROR("Failed to read avatar file for network transmission.");
@@ -559,7 +551,7 @@ ServerLobbyThread::HandleNetPacketRetrieveAvatar(SessionWrapper session, const N
 		NetPacketUnknownAvatar::Data unknownData;
 		unknownData.requestId = request.requestId;
 		static_cast<NetPacketUnknownAvatar *>(unknown.get())->SetData(unknownData);
-		GetSender().Send(session.sessionData->GetId(), unknown);
+		GetSender().Send(session.sessionData, unknown);
 	}
 }
 
@@ -608,7 +600,7 @@ ServerLobbyThread::HandleNetPacketJoinGame(SessionWrapper session, const NetPack
 		}
 		else
 		{
-			SendJoinGameFailed(session.sessionData->GetId(), NTF_NET_JOIN_INVALID_PASSWORD);
+			SendJoinGameFailed(session.sessionData, NTF_NET_JOIN_INVALID_PASSWORD);
 		}
 	}
 	else
@@ -629,10 +621,10 @@ ServerLobbyThread::EstablishSession(SessionWrapper session)
 	initAckData.sessionId = session.sessionData->GetId(); // TODO: currently unused.
 	initAckData.playerId = session.playerData->GetUniqueId();
 	static_cast<NetPacketInitAck *>(initAck.get())->SetData(initAckData);
-	GetSender().Send(session.sessionData->GetId(), initAck);
+	GetSender().Send(session.sessionData, initAck);
 
 	// Send the game list to the client.
-	SendGameList(session.sessionData->GetId());
+	SendGameList(session.sessionData);
 
 	// Session is now established.
 	m_initTimerSessionMap.erase(session.sessionData->GetId());
@@ -653,7 +645,7 @@ ServerLobbyThread::RequestPlayerAvatar(SessionWrapper session)
 	retrieveAvatarData.requestId = session.playerData->GetUniqueId();
 	retrieveAvatarData.avatar = session.playerData->GetAvatarMD5();
 	static_cast<NetPacketRetrieveAvatar *>(retrieveAvatar.get())->SetData(retrieveAvatarData);
-	GetSender().Send(session.sessionData->GetId(), retrieveAvatar);
+	GetSender().Send(session.sessionData, retrieveAvatar);
 }
 
 void
@@ -867,13 +859,13 @@ ServerLobbyThread::SessionError(SessionWrapper session, int errorCode)
 {
 	if (session.sessionData.get())
 	{
-		SendError(session.sessionData->GetId(), errorCode);
+		SendError(session.sessionData, errorCode);
 		CloseSessionDelayed(session);
 	}
 }
 
 void
-ServerLobbyThread::SendError(SessionId s, int errorCode)
+ServerLobbyThread::SendError(boost::shared_ptr<SessionData> s, int errorCode)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacketError);
 	NetPacketError::Data errorData;
@@ -883,7 +875,7 @@ ServerLobbyThread::SendError(SessionId s, int errorCode)
 }
 
 void
-ServerLobbyThread::SendJoinGameFailed(SessionId s, int reason)
+ServerLobbyThread::SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason)
 {
 	boost::shared_ptr<NetPacket> packet(new NetPacketJoinGameFailed);
 	NetPacketJoinGameFailed::Data failedData;
@@ -893,7 +885,7 @@ ServerLobbyThread::SendJoinGameFailed(SessionId s, int reason)
 }
 
 void
-ServerLobbyThread::SendGameList(SessionId s)
+ServerLobbyThread::SendGameList(boost::shared_ptr<SessionData> s)
 {
 	GameMap::const_iterator game_i = m_gameMap.begin();
 	GameMap::const_iterator game_end = m_gameMap.end();

src/net/common/sessionmanager.cpp

@@ -206,21 +206,6 @@ SessionManager::GetSessionByUniquePlayerId(unsigned uniqueId) const
 	return tmpSession;
 }
 
-bool
-SessionManager::GetSocketForSession(SessionId session, SOCKET &outSocket)
-{
-	bool retVal = false;
-	boost::mutex::scoped_lock lock(m_sessionMapMutex);
-	SessionMap::iterator pos = m_sessionMap.find(session);
-
-	if (pos != m_sessionMap.end())
-	{
-		outSocket = pos->second.sessionData->GetSocket();
-		retVal = true;
-	}
-	return retVal;
-}
-
 PlayerDataList
 SessionManager::GetPlayerDataList() const
 {
@@ -370,7 +355,7 @@ SessionManager::SendToAllSessions(SenderThread &sender, boost::shared_ptr<NetPac
 
 		// Send each client (with a certain state) a copy of the packet.
 		if (i->second.sessionData->GetState() == state)
-			sender.Send(i->first, boost::shared_ptr<NetPacket>(packet->Clone()));
+			sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
 		++i;
 	}
 }
@@ -388,7 +373,7 @@ SessionManager::SendToAllButOneSessions(SenderThread &sender, boost::shared_ptr<
 		// Send each fully connected client but one a copy of the packet.
 		if (i->second.sessionData->GetState() == state)
 			if (i->first != except)
-				sender.Send(i->first, boost::shared_ptr<NetPacket>(packet->Clone()));
+				sender.Send(i->second.sessionData, boost::shared_ptr<NetPacket>(packet->Clone()));
 		++i;
 	}
 }

src/net/sendercallback.h

@@ -29,7 +29,6 @@ class SenderCallback
 public:
 	virtual ~SenderCallback();
 
-	virtual bool GetSocketForSession(SessionId session, SOCKET &outSocket) = 0;
 	virtual void SignalNetError(SessionId session, int errorID, int osErrorID) = 0;
 };
 

src/net/senderthread.h

@@ -41,25 +41,25 @@ public:
 	SenderThread(SenderCallback &cb);
 	virtual ~SenderThread();
 
-	void Send(SessionId session, boost::shared_ptr<NetPacket> packet);
+	void Send(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet);
-	void Send(SessionId session, const NetPacketList &packetList);
+	void Send(boost::shared_ptr<SessionData> session, const NetPacketList &packetList);
 
-	void SendLowPrio(SessionId session, boost::shared_ptr<NetPacket> packet);
+	void SendLowPrio(boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet);
-	void SendLowPrio(SessionId session, const NetPacketList &packetList);
+	void SendLowPrio(boost::shared_ptr<SessionData> session, const NetPacketList &packetList);
 
 protected:
-	typedef std::pair<boost::shared_ptr<NetPacket>, SessionId> SendData;
+	typedef std::pair<boost::shared_ptr<NetPacket>, boost::shared_ptr<SessionData> > SendData;
 	typedef std::deque<SendData> SendDataDeque;
 
 	// Main function of the thread.
 	virtual void Main();
 
-	void InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, SessionId session, boost::shared_ptr<NetPacket> packet);
+	void InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, boost::shared_ptr<SessionData> session, boost::shared_ptr<NetPacket> packet);
-	void InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, SessionId session, const NetPacketList &packetList);
+	void InternalStore(SendDataDeque &sendQueue, unsigned maxQueueSize, boost::shared_ptr<SessionData> session, const NetPacketList &packetList);
 
 private:
 
-	SessionId m_curSession;
+	boost::shared_ptr<SessionData> m_curSession;
 
 	std::deque<SendData> m_outBuf;
 	mutable boost::mutex m_outBufMutex;

src/net/serverlobbythread.h

@@ -70,8 +70,6 @@ public:
 
 	void RemoveGame(unsigned id);
 
-	bool GetSocketForSession(SessionId session, SOCKET &outSocket);
-
 	u_int32_t GetNextUniquePlayerId();
 	u_int32_t GetNextGameId();
 	ServerCallback &GetCallback();
@@ -123,9 +121,9 @@ protected:
 	void CleanupSessionMap();
 
 	void CloseSessionDelayed(SessionWrapper session);
-	void SendError(SessionId s, int errorCode);
+	void SendError(boost::shared_ptr<SessionData> s, int errorCode);
-	void SendJoinGameFailed(SessionId s, int reason);
+	void SendJoinGameFailed(boost::shared_ptr<SessionData> s, int reason);
-	void SendGameList(SessionId s);
+	void SendGameList(boost::shared_ptr<SessionData> s);
 	void BroadcastStatisticsUpdate();
 
 	SenderThread &GetSender();