Switched tcp over to enet

Source/Core/Core/NetPlayClient.cpp

@@ -4,8 +4,6 @@
 
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
-#include "Core/Movie.h"
-#include "Core/NetPlayClient.h"
 #include "Core/HW/EXI_DeviceIPL.h"
 #include "Core/HW/SI.h"
 #include "Core/HW/SI_DeviceDanceMat.h"
@@ -15,7 +13,8 @@
 #include "Core/HW/WiimoteReal/WiimoteReal.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_Device_usb.h"
 #include "Core/IPC_HLE/WII_IPC_HLE_WiiMote.h"
-
+#include "Core/Movie.h"
+#include "Core/NetPlayClient.h"
 
 static std::mutex crit_netplay_client;
 static NetPlayClient * netplay_client = nullptr;
@@ -33,72 +32,60 @@ NetPlayClient::~NetPlayClient()
 		m_do_loop = false;
 		m_thread.join();
 	}
+
+	if (m_server)
+	{
+		Disconnect();
+	}
+
 }
 
 // called from ---GUI--- thread
-NetPlayClient::NetPlayClient(const std::string& address, const u16 port, NetPlayUI* dialog, const std::string& name) : m_dialog(dialog), m_is_running(false), m_do_loop(true)
+NetPlayClient::NetPlayClient(const std::string& address, const u16 port, NetPlayUI* dialog, const std::string& name)
+	: m_dialog(dialog)
+	, m_client(nullptr)
+	, m_server(nullptr)
+	, m_is_running(false)
+	, m_do_loop(true)
+	, m_target_buffer_size()
+	, m_local_player(nullptr)
+	, m_current_game(0)
+	, m_is_recording(false)
+	, m_pid(0)
+	, m_connecting(false)
 {
 	m_target_buffer_size = 20;
 	ClearBuffers();
 
 	is_connected = false;
 
-	if (m_socket.connect(address, port, sf::seconds(5)) == sf::Socket::Done)
+	m_player_name = name;
+
+	//Direct Connection
+	m_client = enet_host_create(nullptr, 1, 3, 0, 0);
+
+	if (m_client == nullptr)
 	{
-		// send connect message
-		sf::Packet spac;
-		spac << NETPLAY_VERSION;
-		spac << netplay_dolphin_ver;
-		spac << name;
-		m_socket.send(spac);
+		PanicAlertT("Couldn't Create Client");
+	}
 
-		sf::Packet rpac;
-		// TODO: make this not hang
-		m_socket.receive(rpac);
-		MessageId error;
-		rpac >> error;
+	ENetAddress addr;
+	enet_address_set_host(&addr, address.c_str());
+	addr.port = port;
 
-		// got error message
-		if (error)
-		{
-			switch (error)
-			{
-			case CON_ERR_SERVER_FULL :
-				PanicAlertT("The server is full!");
-				break;
-			case CON_ERR_VERSION_MISMATCH :
-				PanicAlertT("The server and client's NetPlay versions are incompatible!");
-				break;
-			case CON_ERR_GAME_RUNNING :
-				PanicAlertT("The server responded: the game is currently running!");
-				break;
-			default :
-				PanicAlertT("The server sent an unknown error message!");
-				break;
-			}
-			m_socket.disconnect();
-		}
-		else
-		{
-			rpac >> m_pid;
+	m_server = enet_host_connect(m_client, &addr, 3, 0);
 
-			Player player;
-			player.name = name;
-			player.pid = m_pid;
-			player.revision = netplay_dolphin_ver;
+	if (m_server == nullptr)
+	{
+		PanicAlertT("Couldn't create peer.");
+	}
 
-			// add self to player list
-			m_players[m_pid] = player;
-			m_local_player = &m_players[m_pid];
-
-			m_dialog->Update();
-
-			//PanicAlertT("Connection successful: assigned player id: %d", m_pid);
-			is_connected = true;
-
-			m_selector.add(m_socket);
+	ENetEvent netEvent;
+	int net = enet_host_service(m_client, &netEvent, 5000);
+	if (net > 0 && netEvent.type == ENET_EVENT_TYPE_CONNECT)
+	{
+		if (Connect())
 			m_thread = std::thread(&NetPlayClient::ThreadFunc, this);
-		}
 	}
 	else
 	{
@@ -106,6 +93,73 @@ NetPlayClient::NetPlayClient(const std::string& address, const u16 port, NetPlay
 	}
 }
 
+bool NetPlayClient::Connect()
+{
+	// send connect message
+	sf::Packet spac;
+	spac << NETPLAY_VERSION;
+	spac << netplay_dolphin_ver;
+	spac << m_player_name;
+	Send(spac);
+	enet_host_flush(m_client);
+	sf::Packet rpac;
+	// TODO: make this not hang
+	ENetEvent netEvent;
+	if (enet_host_service(m_client, &netEvent, 5000) > 0 && netEvent.type == ENET_EVENT_TYPE_RECEIVE)
+	{
+		rpac.append(netEvent.packet->data, netEvent.packet->dataLength);
+	}
+	else
+	{
+		return false;
+	}
+
+	MessageId error;
+	rpac >> error;
+
+	// got error message
+	if (error)
+	{
+		switch (error)
+		{
+		case CON_ERR_SERVER_FULL:
+			PanicAlertT("The server is full!");
+			break;
+		case CON_ERR_VERSION_MISMATCH:
+			PanicAlertT("The server and client's NetPlay versions are incompatible!");
+			break;
+		case CON_ERR_GAME_RUNNING:
+			PanicAlertT("The server responded: the game is currently running!");
+			break;
+		default:
+			PanicAlertT("The server sent an unknown error message!");
+			break;
+		}
+
+		Disconnect();
+		return false;
+	}
+	else
+	{
+		rpac >> m_pid;
+
+		Player player;
+		player.name = m_player_name;
+		player.pid = m_pid;
+		player.revision = netplay_dolphin_ver;
+
+		// add self to player list
+		m_players[m_pid] = player;
+		m_local_player = &m_players[m_pid];
+
+		m_dialog->Update();
+
+		is_connected = true;
+
+		return true;
+	}
+}
+
 // called from ---NETPLAY--- thread
 unsigned int NetPlayClient::OnData(sf::Packet& packet)
 {
@@ -114,135 +168,135 @@ unsigned int NetPlayClient::OnData(sf::Packet& packet)
 
 	switch (mid)
 	{
-	case NP_MSG_PLAYER_JOIN :
-		{
-			Player player;
-			packet >> player.pid;
-			packet >> player.name;
-			packet >> player.revision;
+	case NP_MSG_PLAYER_JOIN:
+	{
+		Player player;
+		packet >> player.pid;
+		packet >> player.name;
+		packet >> player.revision;
 
-			{
+		{
 			std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
 			m_players[player.pid] = player;
-			}
-
-			m_dialog->Update();
 		}
-		break;
 
-	case NP_MSG_PLAYER_LEAVE :
+		m_dialog->Update();
+	}
+	break;
+
+	case NP_MSG_PLAYER_LEAVE:
+	{
+		PlayerId pid;
+		packet >> pid;
+
 		{
-			PlayerId pid;
-			packet >> pid;
-
-			{
 			std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
 			m_players.erase(m_players.find(pid));
-			}
-
-			m_dialog->Update();
 		}
-		break;
 
-	case NP_MSG_CHAT_MESSAGE :
+		m_dialog->Update();
+	}
+	break;
+
+	case NP_MSG_CHAT_MESSAGE:
+	{
+		PlayerId pid;
+		packet >> pid;
+		std::string msg;
+		packet >> msg;
+
+		// don't need lock to read in this thread
+		const Player& player = m_players[pid];
+
+		// add to gui
+		std::ostringstream ss;
+		ss << player.name << '[' << (char)(pid + '0') << "]: " << msg;
+
+		m_dialog->AppendChat(ss.str());
+	}
+	break;
+
+	case NP_MSG_PAD_MAPPING:
+	{
+		for (PadMapping& mapping : m_pad_map)
 		{
-			PlayerId pid;
-			packet >> pid;
-			std::string msg;
-			packet >> msg;
-
-			// don't need lock to read in this thread
-			const Player& player = m_players[pid];
-
-			// add to gui
-			std::ostringstream ss;
-			ss << player.name << '[' << (char)(pid+'0') << "]: " << msg;
-
-			m_dialog->AppendChat(ss.str());
+			packet >> mapping;
 		}
-		break;
 
-	case NP_MSG_PAD_MAPPING :
+		UpdateDevices();
+
+		m_dialog->Update();
+	}
+	break;
+
+	case NP_MSG_WIIMOTE_MAPPING:
+	{
+		for (PadMapping& mapping : m_wiimote_map)
 		{
-			for (PadMapping& mapping : m_pad_map)
-			{
-				packet >> mapping;
-			}
-
-			UpdateDevices();
-
-			m_dialog->Update();
+			packet >> mapping;
 		}
-		break;
 
-	case NP_MSG_WIIMOTE_MAPPING :
+		m_dialog->Update();
+	}
+	break;
+
+	case NP_MSG_PAD_DATA:
+	{
+		PadMapping map = 0;
+		GCPadStatus pad;
+		packet >> map >> pad.button >> pad.analogA >> pad.analogB >> pad.stickX >> pad.stickY >> pad.substickX >> pad.substickY >> pad.triggerLeft >> pad.triggerRight;
+
+		// trusting server for good map value (>=0 && <4)
+		// add to pad buffer
+		m_pad_buffer[map].Push(pad);
+	}
+	break;
+
+	case NP_MSG_WIIMOTE_DATA:
+	{
+		PadMapping map = 0;
+		NetWiimote nw;
+		u8 size;
+		packet >> map >> size;
+
+		nw.resize(size);
+		u8* data = new u8[size];
+		for (unsigned int i = 0; i < size; ++i)
+			packet >> data[i];
+		nw.assign(data, data + size);
+		delete[] data;
+
+		// trusting server for good map value (>=0 && <4)
+		// add to Wiimote buffer
+		m_wiimote_buffer[(unsigned)map].Push(nw);
+	}
+	break;
+
+
+	case NP_MSG_PAD_BUFFER:
+	{
+		u32 size = 0;
+		packet >> size;
+
+		m_target_buffer_size = size;
+	}
+	break;
+
+	case NP_MSG_CHANGE_GAME:
+	{
 		{
-			for (PadMapping& mapping : m_wiimote_map)
-			{
-				packet >> mapping;
-			}
-
-			m_dialog->Update();
-		}
-		break;
-
-	case NP_MSG_PAD_DATA :
-		{
-			PadMapping map = 0;
-			GCPadStatus pad;
-			packet >> map >> pad.button >> pad.analogA >> pad.analogB >> pad.stickX >> pad.stickY >> pad.substickX >> pad.substickY >> pad.triggerLeft >> pad.triggerRight;
-
-			// trusting server for good map value (>=0 && <4)
-			// add to pad buffer
-			m_pad_buffer[map].Push(pad);
-		}
-		break;
-
-	case NP_MSG_WIIMOTE_DATA :
-		{
-			PadMapping map = 0;
-			NetWiimote nw;
-			u8 size;
-			packet >> map >> size;
-
-			nw.resize(size);
-			u8* data = new u8[size];
-			for (unsigned int i = 0; i < size; ++i)
-				packet >> data[i];
-			nw.assign(data,data+size);
-			delete[] data;
-
-			// trusting server for good map value (>=0 && <4)
-			// add to Wiimote buffer
-			m_wiimote_buffer[(unsigned)map].Push(nw);
-		}
-		break;
-
-
-	case NP_MSG_PAD_BUFFER :
-		{
-			u32 size = 0;
-			packet >> size;
-
-			m_target_buffer_size = size;
-		}
-		break;
-
-	case NP_MSG_CHANGE_GAME :
-		{
-			{
 			std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
 			packet >> m_selected_game;
-			}
-
-			// update gui
-			m_dialog->OnMsgChangeGame(m_selected_game);
 		}
-		break;
 
-	case NP_MSG_START_GAME :
+		// update gui
+		m_dialog->OnMsgChangeGame(m_selected_game);
+	}
+	break;
+
+	case NP_MSG_START_GAME:
+	{
 		{
-			{
 			std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
 			packet >> m_current_game;
 			packet >> g_NetPlaySettings.m_CPUthread;
@@ -252,62 +306,63 @@ unsigned int NetPlayClient::OnData(sf::Packet& packet)
 			packet >> g_NetPlaySettings.m_WriteToMemcard;
 			packet >> g_NetPlaySettings.m_OCEnable;
 			packet >> g_NetPlaySettings.m_OCFactor;
+
 			int tmp;
 			packet >> tmp;
-			g_NetPlaySettings.m_EXIDevice[0] = (TEXIDevices) tmp;
+			g_NetPlaySettings.m_EXIDevice[0] = (TEXIDevices)tmp;
 			packet >> tmp;
-			g_NetPlaySettings.m_EXIDevice[1] = (TEXIDevices) tmp;
-			}
-
-			m_dialog->OnMsgStartGame();
+			g_NetPlaySettings.m_EXIDevice[1] = (TEXIDevices)tmp;
 		}
-		break;
 
-	case NP_MSG_STOP_GAME :
-		{
-			m_dialog->OnMsgStopGame();
-		}
-		break;
+		m_dialog->OnMsgStartGame();
+	}
+	break;
 
-	case NP_MSG_DISABLE_GAME :
-		{
-			PanicAlertT("Other client disconnected while game is running!! NetPlay is disabled. You manually stop the game.");
-			std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
-			m_is_running = false;
-			NetPlay_Disable();
-		}
-		break;
+	case NP_MSG_STOP_GAME:
+	{
+		m_dialog->OnMsgStopGame();
+	}
+	break;
 
-	case NP_MSG_PING :
-		{
-			u32 ping_key = 0;
-			packet >> ping_key;
+	case NP_MSG_DISABLE_GAME:
+	{
+		PanicAlertT("Other client disconnected while game is running!! NetPlay is disabled. You manually stop the game.");
+		std::lock_guard<std::recursive_mutex> lkg(m_crit.game);
+		m_is_running = false;
+		NetPlay_Disable();
+	}
+	break;
 
-			sf::Packet spac;
-			spac << (MessageId)NP_MSG_PONG;
-			spac << ping_key;
+	case NP_MSG_PING:
+	{
+		u32 ping_key = 0;
+		packet >> ping_key;
 
-			std::lock_guard<std::recursive_mutex> lks(m_crit.send);
-			m_socket.send(spac);
-		}
-		break;
+		sf::Packet spac;
+		spac << (MessageId)NP_MSG_PONG;
+		spac << ping_key;
+
+		std::lock_guard<std::recursive_mutex> lks(m_crit.send);
+		Send(spac);
+	}
+	break;
 
 	case NP_MSG_PLAYER_PING_DATA:
-		{
-			PlayerId pid;
-			packet >> pid;
+	{
+		PlayerId pid;
+		packet >> pid;
 
-			{
+		{
 			std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
 			Player& player = m_players[pid];
 			packet >> player.ping;
-			}
-
-			m_dialog->Update();
 		}
-		break;
 
-	default :
+		m_dialog->Update();
+	}
+	break;
+
+	default:
 		PanicAlertT("Unknown message received with id : %d", mid);
 		break;
 
@@ -316,34 +371,70 @@ unsigned int NetPlayClient::OnData(sf::Packet& packet)
 	return 0;
 }
 
+void NetPlayClient::Send(sf::Packet& packet)
+{
+	ENetPacket* epac = enet_packet_create(packet.getData(), packet.getDataSize(), ENET_PACKET_FLAG_RELIABLE);
+	enet_peer_send(m_server, 0, epac);
+}
+
+void NetPlayClient::Disconnect()
+{
+	ENetEvent netEvent;
+	enet_peer_disconnect(m_server, 0);
+	while (enet_host_service(m_client, &netEvent, 3000) > 0)
+	{
+		switch (netEvent.type)
+		{
+		case ENET_EVENT_TYPE_RECEIVE:
+			enet_packet_destroy(netEvent.packet);
+			break;
+		case ENET_EVENT_TYPE_DISCONNECT:
+			m_server = nullptr;
+			return;
+		}
+	}
+	//didn't disconnect gracefully force disconnect
+	enet_peer_reset(m_server);
+	m_server = nullptr;
+}
+
 // called from ---NETPLAY--- thread
 void NetPlayClient::ThreadFunc()
 {
 	while (m_do_loop)
 	{
-		if (m_selector.wait(sf::milliseconds(10)))
+		ENetEvent netEvent;
+		int net;
+		{
+			std::lock_guard<std::recursive_mutex> lks(m_crit.send);
+			net = enet_host_service(m_client, &netEvent, 4);
+		}
+		if (net > 0)
 		{
 			sf::Packet rpac;
-			switch (m_socket.receive(rpac))
+			switch (netEvent.type)
 			{
-			case sf::Socket::Done :
+			case ENET_EVENT_TYPE_RECEIVE:
+				rpac.append(netEvent.packet->data, netEvent.packet->dataLength);
 				OnData(rpac);
-				break;
 
-			//case sf::Socket::Disconnected :
-			default :
+				enet_packet_destroy(netEvent.packet);
+				break;
+			case ENET_EVENT_TYPE_DISCONNECT:
 				m_is_running = false;
 				NetPlay_Disable();
 				m_dialog->AppendChat("< LOST CONNECTION TO SERVER >");
 				PanicAlertT("Lost connection to server!");
 				m_do_loop = false;
+
+				netEvent.peer->data = nullptr;
 				break;
 			}
 		}
+
 	}
 
-	m_socket.disconnect();
-
+	Disconnect();
 	return;
 }
 
@@ -357,7 +448,7 @@ void NetPlayClient::GetPlayerList(std::string& list, std::vector<int>& pid_list)
 	std::map<PlayerId, Player>::const_iterator
 		i = m_players.begin(),
 		e = m_players.end();
-	for ( ; i!=e; ++i)
+	for (; i != e; ++i)
 	{
 		const Player *player = &(i->second);
 		ss << player->name << "[" << (int)player->pid << "] : " << player->revision << " | ";
@@ -389,7 +480,7 @@ void NetPlayClient::GetPlayers(std::vector<const Player *> &player_list)
 	std::map<PlayerId, Player>::const_iterator
 		i = m_players.begin(),
 		e = m_players.end();
-	for ( ; i!=e; ++i)
+	for (; i != e; ++i)
 	{
 		const Player *player = &(i->second);
 		player_list.push_back(player);
@@ -405,7 +496,7 @@ void NetPlayClient::SendChatMessage(const std::string& msg)
 	spac << msg;
 
 	std::lock_guard<std::recursive_mutex> lks(m_crit.send);
-	m_socket.send(spac);
+	Send(spac);
 }
 
 // called from ---CPU--- thread
@@ -418,7 +509,7 @@ void NetPlayClient::SendPadState(const PadMapping in_game_pad, const GCPadStatus
 	spac << pad.button << pad.analogA << pad.analogB << pad.stickX << pad.stickY << pad.substickX << pad.substickY << pad.triggerLeft << pad.triggerRight;
 
 	std::lock_guard<std::recursive_mutex> lks(m_crit.send);
-	m_socket.send(spac);
+	Send(spac);
 }
 
 // called from ---CPU--- thread
@@ -435,7 +526,7 @@ void NetPlayClient::SendWiimoteState(const PadMapping in_game_pad, const NetWiim
 	}
 
 	std::lock_guard<std::recursive_mutex> lks(m_crit.send);
-	m_socket.send(spac);
+	Send(spac);
 }
 
 // called from ---GUI--- thread
@@ -450,7 +541,7 @@ bool NetPlayClient::StartGame(const std::string &path)
 	spac << (char *)&g_NetPlaySettings;
 
 	std::lock_guard<std::recursive_mutex> lks(m_crit.send);
-	m_socket.send(spac);
+	Send(spac);
 
 	if (m_is_running)
 	{
@@ -529,7 +620,7 @@ void NetPlayClient::UpdateDevices()
 void NetPlayClient::ClearBuffers()
 {
 	// clear pad buffers, Clear method isn't thread safe
-	for (unsigned int i=0; i<4; ++i)
+	for (unsigned int i = 0; i<4; ++i)
 	{
 		while (m_pad_buffer[i].Size())
 			m_pad_buffer[i].Pop();
@@ -616,44 +707,44 @@ bool NetPlayClient::GetNetPads(const u8 pad_nb, GCPadStatus* pad_status)
 bool NetPlayClient::WiimoteUpdate(int _number, u8* data, const u8 size)
 {
 	NetWiimote nw;
-	static u8 previousSize[4] = {4,4,4,4};
+	static u8 previousSize[4] = { 4, 4, 4, 4 };
 	{
-	std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
+		std::lock_guard<std::recursive_mutex> lkp(m_crit.players);
 
-	// in game mapping for this local Wiimote
-	unsigned int in_game_num = LocalWiimoteToInGameWiimote(_number);
-	// does this local Wiimote map in game?
-	if (in_game_num < 4)
-	{
-		if (previousSize[in_game_num] == size)
+		// in game mapping for this local Wiimote
+		unsigned int in_game_num = LocalWiimoteToInGameWiimote(_number);
+		// does this local Wiimote map in game?
+		if (in_game_num < 4)
 		{
-			nw.assign(data, data + size);
-			do
+			if (previousSize[in_game_num] == size)
 			{
-				// add to buffer
-				m_wiimote_buffer[in_game_num].Push(nw);
+				nw.assign(data, data + size);
+				do
+				{
+					// add to buffer
+					m_wiimote_buffer[in_game_num].Push(nw);
 
-				SendWiimoteState(in_game_num, nw);
-			} while (m_wiimote_buffer[in_game_num].Size() <= m_target_buffer_size * 200 / 120); // TODO: add a seperate setting for wiimote buffer?
-		}
-		else
-		{
-			while (m_wiimote_buffer[in_game_num].Size() > 0)
-			{
-				// Reporting mode changed, so previous buffer is no good.
-				m_wiimote_buffer[in_game_num].Pop();
+					SendWiimoteState(in_game_num, nw);
+				} while (m_wiimote_buffer[in_game_num].Size() <= m_target_buffer_size * 200 / 120); // TODO: add a seperate setting for wiimote buffer?
 			}
-			nw.resize(size, 0);
+			else
+			{
+				while (m_wiimote_buffer[in_game_num].Size() > 0)
+				{
+					// Reporting mode changed, so previous buffer is no good.
+					m_wiimote_buffer[in_game_num].Pop();
+				}
+				nw.resize(size, 0);
 
-			m_wiimote_buffer[in_game_num].Push(nw);
-			m_wiimote_buffer[in_game_num].Push(nw);
-			m_wiimote_buffer[in_game_num].Push(nw);
-			m_wiimote_buffer[in_game_num].Push(nw);
-			m_wiimote_buffer[in_game_num].Push(nw);
-			m_wiimote_buffer[in_game_num].Push(nw);
-			previousSize[in_game_num] = size;
+				m_wiimote_buffer[in_game_num].Push(nw);
+				m_wiimote_buffer[in_game_num].Push(nw);
+				m_wiimote_buffer[in_game_num].Push(nw);
+				m_wiimote_buffer[in_game_num].Push(nw);
+				m_wiimote_buffer[in_game_num].Push(nw);
+				m_wiimote_buffer[in_game_num].Push(nw);
+				previousSize[in_game_num] = size;
+			}
 		}
-	}
 
 	} // unlock players
 
@@ -753,7 +844,7 @@ void NetPlayClient::Stop()
 	{
 		sf::Packet spac;
 		spac << (MessageId)NP_MSG_STOP_GAME;
-		m_socket.send(spac);
+		Send(spac);
 	}
 }
 
@@ -844,7 +935,7 @@ u32 CEXIIPL::NetPlay_GetGCTime()
 	std::lock_guard<std::mutex> lk(crit_netplay_client);
 
 	if (netplay_client)
-		return NETPLAY_INITIAL_GCTIME; // watev
+		return NETPLAY_INITIAL_GCTIME;
 	else
 		return 0;
 }