// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnDisconnect(sf::SocketTCP& socket) { PlayerId pid = m_players[socket].pid; if (m_is_running) { for (PadMapping mapping : m_pad_map) { if (mapping == pid) { PanicAlertT("Client disconnect while game is running!! NetPlay is disabled. You must manually stop the game."); std::lock_guard<std::recursive_mutex> lkg(m_crit.game); m_is_running = false; sf::Packet spac; spac << (MessageId)NP_MSG_DISABLE_GAME; // this thread doesn't need players lock std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); break; } } } sf::Packet spac; spac << (MessageId)NP_MSG_PLAYER_LEAVE; spac << pid; m_selector.Remove(socket); std::lock_guard<std::recursive_mutex> lkp(m_crit.players); m_players.erase(m_players.find(socket)); // alert other players of disconnect std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); for (PadMapping& mapping : m_pad_map) { if (mapping == pid) { mapping = -1; } } UpdatePadMapping(); for (PadMapping& mapping : m_wiimote_map) { if (mapping == pid) { mapping = -1; } } UpdateWiimoteMapping(); return 0; }
// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnDisconnect(const Client& player) { const PlayerId pid = player.pid; if (m_is_running) { for (PadMapping mapping : m_pad_map) { if (mapping == pid && pid != 1) { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); m_is_running = false; sf::Packet spac; spac << (MessageId)NP_MSG_DISABLE_GAME; // this thread doesn't need players lock SendToClients(spac, static_cast<PlayerId>(-1)); break; } } } sf::Packet spac; spac << (MessageId)NP_MSG_PLAYER_LEAVE; spac << pid; enet_peer_disconnect(player.socket, 0); std::lock_guard<std::recursive_mutex> lkp(m_crit.players); auto it = m_players.find(player.pid); if (it != m_players.end()) m_players.erase(it); // alert other players of disconnect SendToClients(spac); for (PadMapping& mapping : m_pad_map) { if (mapping == pid) { mapping = -1; UpdatePadMapping(); } } for (PadMapping& mapping : m_wiimote_map) { if (mapping == pid) { mapping = -1; UpdateWiimoteMapping(); } } return 0; }
// called from ---GUI--- thread bool NetPlayServer::StartGame(const std::string &path) { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); m_current_game = Common::Timer::GetTimeMs(); // no change, just update with clients AdjustPadBufferSize(m_target_buffer_size); // tell clients to start game sf::Packet spac; spac << (MessageId)NP_MSG_START_GAME; spac << m_current_game; spac << m_settings.m_CPUthread; spac << m_settings.m_CPUcore; spac << m_settings.m_DSPEnableJIT; spac << m_settings.m_DSPHLE; spac << m_settings.m_WriteToMemcard; spac << m_settings.m_EXIDevice[0]; spac << m_settings.m_EXIDevice[1]; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); m_is_running = true; return true; }
// called from ---NETPLAY--- thread void NetPlayServer::UpdateWiimoteMapping() { sf::Packet spac; spac << (MessageId)NP_MSG_WIIMOTE_MAPPING; for (int i = 0; i < 4; i++) spac << m_wiimote_map[i]; SendToClients(spac); }
// called from ---GUI--- thread and ---NETPLAY--- thread void NetPlayServer::UpdatePadMapping() { sf::Packet spac; spac << (MessageId)NP_MSG_PAD_MAPPING; for (int i = 0; i < 4; i++) spac << m_pad_map[i]; SendToClients(spac); }
/** * Close the given socket if he wants to disconnect. */ HRESULT ACWinSock::OnDisconnect(SOCKET skDisconnecting) { UCHAR i=0; if (skDisconnecting==INVALID_SOCKET) return AC_FAIL; if (mMode== NetModeType::NMT_Server) { // delete from the list of active clients for (i=0; i<mClCount; i++) { if (mClients[i].skToClient == skDisconnecting) break; } if (i>=mClCount) { Log("[ERROR] not listed client wants to be disconnected"); return AC_FAIL; } // shutdown and close socket if ( shutdown(mClients[i].skToClient,0x02)==SOCKET_ERROR ) mpSockObj->LogLastWSAError("shutdown() in ACWinSock::OnDisconnect"); if ( closesocket(mClients[i].skToClient)==SOCKET_ERROR ) mpSockObj->LogLastWSAError("closesocket() in ACWinSock::OnDisconnect"); mClients[i].skToClient = INVALID_SOCKET; // inform clients and the server about disconnect ACPACKAGE *pPkg = (ACPACKAGE*)mBuffer; pPkg->pData = &mBuffer[g_PkgSize]; pPkg->nLength = sizeof(UINT); pPkg->nType = 2; // ID Msg disconnecting pPkg->nSender = 0; // Server memcpy(pPkg->pData, &mClients[i].nID, sizeof(UINT)); SendToClients(pPkg); // feed msg into server msg-queue mpSockObj->FeedByHand(pPkg); // copy last struct to deleted field, adjust counter memcpy(&mClients[i], &mClients[mClCount-1], sizeof(ACCLIENT)); mClCount--; } else { if ( shutdown(mpSockObj->GetSocket(),0x02)==SOCKET_ERROR ) mpSockObj->LogLastWSAError("shutdown() in ACWinSock::OnDisconnect"); if ( closesocket(mpSockObj->GetSocket())==SOCKET_ERROR ) mpSockObj->LogLastWSAError("closesocket() in ACWinSock::OnDisconnect"); } Log("one client disconnected"); return AC_OK; };
// called from ---NETPLAY--- thread void NetPlayServer::UpdateWiimoteMapping() { sf::Packet spac; spac << (MessageId)NP_MSG_WIIMOTE_MAPPING; for (PadMapping mapping : m_wiimote_map) { spac << mapping; } SendToClients(spac); }
// called from ---GUI--- thread and ---NETPLAY--- thread void NetPlayServer::UpdatePadMapping() { sf::Packet spac; spac << (MessageId)NP_MSG_PAD_MAPPING; for (PadMapping mapping : m_pad_map) { spac << mapping; } SendToClients(spac); }
// called from ---GUI--- thread / and ---NETPLAY--- thread void NetPlayServer::SendChatMessage(const std::string& msg) { sf::Packet spac; spac << (MessageId)NP_MSG_CHAT_MESSAGE; spac << (PlayerId)0; // server id always 0 spac << msg; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); }
HRESULT ZFXWS::OnDisconnect( SOCKET skDisconnecting ) { ZFXPACKET Pkt; UCHAR i = 0; if ( skDisconnecting == INVALID_SOCKET ) { return ZFX_FAIL; } if ( m_Mode == NMD_SERVER ) { for ( i = 0; i < m_ClCount; i++ ) { if ( m_Clients[i].skToClient == skDisconnecting ) { break; } } if ( i > m_ClCount ) { return ZFX_FAIL; } //close the socket shutdown(m_Clients[i].skToClient, 0x02); closesocket(m_Clients[i].skToClient); m_Clients[i].skToClient = INVALID_SOCKET; //inform the other clients Pkt.pData = &m_Buffer[g_PktSize]; Pkt.nLength = sizeof(UINT); Pkt.nType = 2; Pkt.nSender = 0; memcpy(Pkt.pData, &m_Clients[i].nID, sizeof(UINT)); SendToClients(&Pkt); //copy last client to free position memcpy(&m_Clients[i], &m_Clients[m_ClCount - 1], sizeof(ZFXCLIENT)); m_ClCount--; } else { shutdown(m_pSockObj->GetSocket(),0x02); closesocket(m_pSockObj->GetSocket()); } return ZFX_OK; }
// called from ---GUI--- thread and ---NETPLAY--- thread void NetPlayServer::AdjustPadBufferSize(unsigned int size) { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); m_target_buffer_size = size; // tell clients to change buffer size sf::Packet spac; spac << (MessageId)NP_MSG_PAD_BUFFER; spac << (u32)m_target_buffer_size; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); }
// called from ---GUI--- thread bool NetPlayServer::ChangeGame(const std::string &game) { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); m_selected_game = game; // send changed game to clients sf::Packet spac; spac << (MessageId)NP_MSG_CHANGE_GAME; spac << game; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); return true; }
/** * There is someone is the queue of our server waiting to be accepted * so do him the favor. */ HRESULT ACWinSock::OnAccept(void) { int nSize=0, nBytes=0, i=mClCount; // maximum of 255 clients at all if (mClCount >= 255) return AC_OUTOFMEMORY; // application defined maximum number if ( (mClMax > 0) && (mClCount >= mClMax) ) return AC_OUTOFMEMORY; if (FAILED(mpSockObj->Accept( &(mClients[i].skToClient) ))) return AC_FAIL; // SEND ITS ID TO THE NEW CLIENT: ACPACKAGE *pPkg = (ACPACKAGE*)mBuffer; pPkg->pData = &mBuffer[g_PkgSize]; pPkg->nLength = sizeof(UINT); pPkg->nType = 0; // ID Msg pPkg->nSender = 0; // Server memcpy(pPkg->pData, &mClID, sizeof(UINT)); // add counters mClients[i].nID = mClID; mClCount++; mClID++; nSize = g_PkgSize + pPkg->nLength; nBytes = mpSockObj->Send(mBuffer, nSize, mClients[i].skToClient); if ( (nBytes==SOCKET_ERROR) || (nBytes<nSize) ) return AC_FAIL; // INFORM ALL CLIENTS AND THE SERVER ABOUT THE NEW KID IN TOWN pPkg->nType = 1; SendToClients(pPkg); // feed msg into server msg-queue mpSockObj->FeedByHand(pPkg); return AC_OK; };
HRESULT ZFXWS::OnAccept() { int nSize = 0; int nBytes = 0; int i = m_ClCount; if ( m_ClCount >= 255 ) { return ZFX_OUTOFMEMORY; } if ( FAILED( m_pSockObj->Accept( &( m_Clients[i].skToClient ) ) ) ) { return ZFX_FAIL; } //Send ID to new client ZFXPACKET *pPkt = (ZFXPACKET*)m_Buffer; pPkt->pData = &m_Buffer[g_PktSize]; pPkt->nLength = sizeof(UINT); pPkt->nType = 0; pPkt->nSender = 0; memcpy(pPkt->pData, &m_ClID, sizeof(UINT)); //increase counter m_Clients[i].nID = m_ClID; m_ClCount++; m_ClID++; nSize = g_PktSize + pPkt->nLength; nBytes = m_pSockObj->Send(m_Buffer, nSize, m_Clients[i].skToClient); if ( nBytes == SOCKET_ERROR || nBytes < nSize ) { return ZFX_FAIL; } //inform other clients about the new client pPkt->nType = 1; SendToClients(pPkt); return ZFX_OK; }
// called from ---NETPLAY--- thread void NetPlayServer::ThreadFunc() { while (m_do_loop) { // update pings every so many seconds if ((m_ping_timer.GetTimeElapsed() > (10 * 1000)) || m_update_pings) { //PanicAlertT("Sending pings"); m_ping_key = Common::Timer::GetTimeMs(); sf::Packet spac; spac << (MessageId)NP_MSG_PING; spac << m_ping_key; std::lock_guard<std::recursive_mutex> lks(m_crit.send); m_ping_timer.Start(); SendToClients(spac); m_update_pings = false; } // check which sockets need attention const unsigned int num = m_selector.Wait(0.01f); for (unsigned int i=0; i<num; ++i) { sf::SocketTCP ready_socket = m_selector.GetSocketReady(i); // listening socket if (ready_socket == m_socket) { sf::SocketTCP accept_socket; m_socket.Accept(accept_socket); unsigned int error; { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); error = OnConnect(accept_socket); } if (error) { sf::Packet spac; spac << (MessageId)error; // don't need to lock, this client isn't in the client map accept_socket.Send(spac); // TODO: not sure if client gets the message if i close right away accept_socket.Close(); } } // client socket else { sf::Packet rpac; switch (ready_socket.Receive(rpac)) { case sf::Socket::Done : // if a bad packet is received, disconnect the client if (0 == OnData(rpac, ready_socket)) break; //case sf::Socket::Disconnected : default : { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); OnDisconnect(ready_socket); break; } } } } } // close listening socket and client sockets { std::map<sf::SocketTCP, Client>::reverse_iterator i = m_players.rbegin(), e = m_players.rend(); for ( ; i!=e; ++i) i->second.socket.Close(); } return; }
// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnData(sf::Packet& packet, sf::SocketTCP& socket) { MessageId mid; packet >> mid; // don't need lock because this is the only thread that modifies the players // only need locks for writes to m_players in this thread Client& player = m_players[socket]; switch (mid) { case NP_MSG_CHAT_MESSAGE : { std::string msg; packet >> msg; // send msg to other clients sf::Packet spac; spac << (MessageId)NP_MSG_CHAT_MESSAGE; spac << player.pid; spac << msg; { std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac, player.pid); } } break; case NP_MSG_PAD_DATA : { // if this is pad data from the last game still being received, ignore it if (player.current_game != m_current_game) break; PadMapping map = 0; int hi, lo; packet >> map >> hi >> lo; // If the data is not from the correct player, // then disconnect them. if (m_pad_map[map] != player.pid) return 1; // Relay to clients sf::Packet spac; spac << (MessageId)NP_MSG_PAD_DATA; spac << map << hi << lo; std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac, player.pid); } break; case NP_MSG_WIIMOTE_DATA : { // if this is wiimote data from the last game still being received, ignore it if (player.current_game != m_current_game) break; PadMapping map = 0; u8 size; packet >> map >> size; u8* data = new u8[size]; for (unsigned int i = 0; i < size; ++i) packet >> data[i]; // If the data is not from the correct player, // then disconnect them. if (m_wiimote_map[map] != player.pid) { delete[] data; return 1; } // relay to clients sf::Packet spac; spac << (MessageId)NP_MSG_WIIMOTE_DATA; spac << map; spac << size; for (unsigned int i = 0; i < size; ++i) spac << data[i]; delete[] data; std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac, player.pid); } break; case NP_MSG_PONG : { const u32 ping = (u32)m_ping_timer.GetTimeElapsed(); u32 ping_key = 0; packet >> ping_key; if (m_ping_key == ping_key) { player.ping = ping; } sf::Packet spac; spac << (MessageId)NP_MSG_PLAYER_PING_DATA; spac << player.pid; spac << player.ping; std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); } break; case NP_MSG_START_GAME : { packet >> player.current_game; } break; case NP_MSG_STOP_GAME: { // tell clients to stop game sf::Packet spac; spac << (MessageId)NP_MSG_STOP_GAME; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); std::lock_guard<std::recursive_mutex> lks(m_crit.send); SendToClients(spac); m_is_running = false; } break; default : PanicAlertT("Unknown message with id:%d received from player:%d Kicking player!", mid, player.pid); // unknown message, kick the client return 1; break; } return 0; }
// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnData(sf::Packet& packet, Client& player) { MessageId mid; packet >> mid; INFO_LOG(NETPLAY, "Got client message: %x", mid); // don't need lock because this is the only thread that modifies the players // only need locks for writes to m_players in this thread switch (mid) { case NP_MSG_CHAT_MESSAGE: { std::string msg; packet >> msg; // send msg to other clients sf::Packet spac; spac << (MessageId)NP_MSG_CHAT_MESSAGE; spac << player.pid; spac << msg; SendToClients(spac, player.pid); } break; case NP_MSG_PAD_DATA: { // if this is pad data from the last game still being received, ignore it if (player.current_game != m_current_game) break; sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_PAD_DATA); while (!packet.endOfPacket()) { PadMapping map; packet >> map; // If the data is not from the correct player, // then disconnect them. if (m_pad_map.at(map) != player.pid) { return 1; } GCPadStatus pad; packet >> pad.button >> pad.analogA >> pad.analogB >> pad.stickX >> pad.stickY >> pad.substickX >> pad.substickY >> pad.triggerLeft >> pad.triggerRight >> pad.isConnected; if (m_host_input_authority) { m_last_pad_status[map] = pad; if (!m_first_pad_status_received[map]) { m_first_pad_status_received[map] = true; SendFirstReceivedToHost(map, true); } } else { spac << map << pad.button << pad.analogA << pad.analogB << pad.stickX << pad.stickY << pad.substickX << pad.substickY << pad.triggerLeft << pad.triggerRight << pad.isConnected; } } if (!m_host_input_authority) SendToClients(spac, player.pid); } break; case NP_MSG_PAD_HOST_POLL: { PadMapping pad_num; packet >> pad_num; sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_PAD_DATA); if (pad_num < 0) { for (size_t i = 0; i < m_pad_map.size(); i++) { if (m_pad_map[i] == -1) continue; const GCPadStatus& pad = m_last_pad_status[i]; spac << static_cast<PadMapping>(i) << pad.button << pad.analogA << pad.analogB << pad.stickX << pad.stickY << pad.substickX << pad.substickY << pad.triggerLeft << pad.triggerRight << pad.isConnected; } } else if (m_pad_map.at(pad_num) != -1) { const GCPadStatus& pad = m_last_pad_status[pad_num]; spac << pad_num << pad.button << pad.analogA << pad.analogB << pad.stickX << pad.stickY << pad.substickX << pad.substickY << pad.triggerLeft << pad.triggerRight << pad.isConnected; } SendToClients(spac); } break; case NP_MSG_WIIMOTE_DATA: { // if this is Wiimote data from the last game still being received, ignore it if (player.current_game != m_current_game) break; PadMapping map = 0; u8 size; packet >> map >> size; std::vector<u8> data(size); for (size_t i = 0; i < data.size(); ++i) packet >> data[i]; // If the data is not from the correct player, // then disconnect them. if (m_wiimote_map.at(map) != player.pid) { return 1; } // relay to clients sf::Packet spac; spac << (MessageId)NP_MSG_WIIMOTE_DATA; spac << map; spac << size; for (const u8& byte : data) spac << byte; SendToClients(spac, player.pid); } break; case NP_MSG_PONG: { const u32 ping = (u32)m_ping_timer.GetTimeElapsed(); u32 ping_key = 0; packet >> ping_key; if (m_ping_key == ping_key) { player.ping = ping; } sf::Packet spac; spac << (MessageId)NP_MSG_PLAYER_PING_DATA; spac << player.pid; spac << player.ping; SendToClients(spac); } break; case NP_MSG_START_GAME: { packet >> player.current_game; } break; case NP_MSG_STOP_GAME: { if (!m_is_running) break; m_is_running = false; // tell clients to stop game sf::Packet spac; spac << (MessageId)NP_MSG_STOP_GAME; std::lock_guard<std::recursive_mutex> lkp(m_crit.players); SendToClients(spac); } break; case NP_MSG_GAME_STATUS: { u32 status; packet >> status; m_players[player.pid].game_status = static_cast<PlayerGameStatus>(status); // send msg to other clients sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_GAME_STATUS); spac << player.pid; spac << status; SendToClients(spac); } break; case NP_MSG_IPL_STATUS: { bool status; packet >> status; m_players[player.pid].has_ipl_dump = status; } break; case NP_MSG_TIMEBASE: { u64 timebase = Common::PacketReadU64(packet); u32 frame; packet >> frame; if (m_desync_detected) break; std::vector<std::pair<PlayerId, u64>>& timebases = m_timebase_by_frame[frame]; timebases.emplace_back(player.pid, timebase); if (timebases.size() >= m_players.size()) { // we have all records for this frame if (!std::all_of(timebases.begin(), timebases.end(), [&](std::pair<PlayerId, u64> pair) { return pair.second == timebases[0].second; })) { int pid_to_blame = -1; for (auto pair : timebases) { if (std::all_of(timebases.begin(), timebases.end(), [&](std::pair<PlayerId, u64> other) { return other.first == pair.first || other.second != pair.second; })) { // we are the only outlier pid_to_blame = pair.first; break; } } sf::Packet spac; spac << (MessageId)NP_MSG_DESYNC_DETECTED; spac << pid_to_blame; spac << frame; SendToClients(spac); m_desync_detected = true; } m_timebase_by_frame.erase(frame); } } break; case NP_MSG_MD5_PROGRESS: { int progress; packet >> progress; sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_MD5_PROGRESS); spac << player.pid; spac << progress; SendToClients(spac); } break; case NP_MSG_MD5_RESULT: { std::string result; packet >> result; sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_MD5_RESULT); spac << player.pid; spac << result; SendToClients(spac); } break; case NP_MSG_MD5_ERROR: { std::string error; packet >> error; sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_MD5_ERROR); spac << player.pid; spac << error; SendToClients(spac); } break; case NP_MSG_SYNC_SAVE_DATA: { MessageId sub_id; packet >> sub_id; switch (sub_id) { case SYNC_SAVE_DATA_SUCCESS: { if (m_start_pending) { m_save_data_synced_players++; if (m_save_data_synced_players >= m_players.size() - 1) { m_dialog->AppendChat(GetStringT("All players synchronized.")); StartGame(); } } } break; case SYNC_SAVE_DATA_FAILURE: { m_dialog->AppendChat( StringFromFormat(GetStringT("%s failed to synchronize.").c_str(), player.name.c_str())); m_dialog->OnSaveDataSyncFailure(); m_start_pending = false; } break; default: PanicAlertT( "Unknown SYNC_SAVE_DATA message with id:%d received from player:%d Kicking player!", sub_id, player.pid); return 1; } } break; default: PanicAlertT("Unknown message with id:%d received from player:%d Kicking player!", mid, player.pid); // unknown message, kick the client return 1; } return 0; }
// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnConnect(ENetPeer* socket) { sf::Packet rpac; ENetPacket* epack; do { epack = enet_peer_receive(socket, nullptr); } while (epack == nullptr); rpac.append(epack->data, epack->dataLength); // give new client first available id PlayerId pid = 1; for (auto i = m_players.begin(); i != m_players.end(); ++i) { if (i->second.pid == pid) { pid++; i = m_players.begin(); } } socket->data = new PlayerId(pid); std::string npver; rpac >> npver; // Dolphin netplay version if (npver != Common::scm_rev_git_str) return CON_ERR_VERSION_MISMATCH; // game is currently running if (m_is_running) return CON_ERR_GAME_RUNNING; // too many players if (m_players.size() >= 255) return CON_ERR_SERVER_FULL; // cause pings to be updated m_update_pings = true; Client player; player.pid = pid; player.socket = socket; rpac >> player.revision; rpac >> player.name; enet_packet_destroy(epack); // try to automatically assign new user a pad for (PadMapping& mapping : m_pad_map) { if (mapping == -1) { mapping = player.pid; break; } } // send join message to already connected clients sf::Packet spac; spac << static_cast<MessageId>(NP_MSG_PLAYER_JOIN); spac << player.pid << player.name << player.revision; SendToClients(spac); // send new client success message with their id spac.clear(); spac << static_cast<MessageId>(0); spac << player.pid; Send(player.socket, spac); // send new client the selected game if (m_selected_game != "") { spac.clear(); spac << static_cast<MessageId>(NP_MSG_CHANGE_GAME); spac << m_selected_game; Send(player.socket, spac); } if (!m_host_input_authority) { // send the pad buffer value spac.clear(); spac << static_cast<MessageId>(NP_MSG_PAD_BUFFER); spac << static_cast<u32>(m_target_buffer_size); Send(player.socket, spac); } // send input authority state spac.clear(); spac << static_cast<MessageId>(NP_MSG_HOST_INPUT_AUTHORITY); spac << m_host_input_authority; Send(player.socket, spac); // sync GC SRAM with new client if (!g_SRAM_netplay_initialized) { SConfig::GetInstance().m_strSRAM = File::GetUserPath(F_GCSRAM_IDX); InitSRAM(); g_SRAM_netplay_initialized = true; } spac.clear(); spac << static_cast<MessageId>(NP_MSG_SYNC_GC_SRAM); for (size_t i = 0; i < sizeof(g_SRAM) - offsetof(Sram, settings); ++i) { spac << g_SRAM[offsetof(Sram, settings) + i]; } Send(player.socket, spac); // sync values with new client for (const auto& p : m_players) { spac.clear(); spac << static_cast<MessageId>(NP_MSG_PLAYER_JOIN); spac << p.second.pid << p.second.name << p.second.revision; Send(player.socket, spac); spac.clear(); spac << static_cast<MessageId>(NP_MSG_GAME_STATUS); spac << p.second.pid << static_cast<u32>(p.second.game_status); Send(player.socket, spac); } if (Config::Get(Config::NETPLAY_ENABLE_QOS)) player.qos_session = Common::QoSSession(player.socket); // add client to the player list { std::lock_guard<std::recursive_mutex> lkp(m_crit.players); m_players.emplace(*(PlayerId*)player.socket->data, std::move(player)); UpdatePadMapping(); // sync pad mappings with everyone UpdateWiimoteMapping(); } return 0; }
// called from ---NETPLAY--- thread unsigned int NetPlayServer::OnConnect(sf::SocketTCP& socket) { sf::Packet rpac; // TODO: make this not hang / check if good packet socket.Receive(rpac); std::string npver; rpac >> npver; // dolphin netplay version if (npver != NETPLAY_VERSION) return CON_ERR_VERSION_MISMATCH; // game is currently running if (m_is_running) return CON_ERR_GAME_RUNNING; // too many players if (m_players.size() >= 255) return CON_ERR_SERVER_FULL; // cause pings to be updated m_update_pings = true; Client player; player.socket = socket; rpac >> player.revision; rpac >> player.name; // give new client first available id player.pid = (PlayerId)(m_players.size() + 1); // try to automatically assign new user a pad for (PadMapping& mapping : m_pad_map) { if (mapping == -1) { mapping = player.pid; break; } } { std::lock_guard<std::recursive_mutex> lks(m_crit.send); // send join message to already connected clients sf::Packet spac; spac << (MessageId)NP_MSG_PLAYER_JOIN; spac << player.pid << player.name << player.revision; SendToClients(spac); // send new client success message with their id spac.Clear(); spac << (MessageId)0; spac << player.pid; socket.Send(spac); // send new client the selected game if (m_selected_game != "") { spac.Clear(); spac << (MessageId)NP_MSG_CHANGE_GAME; spac << m_selected_game; socket.Send(spac); } // send the pad buffer value spac.Clear(); spac << (MessageId)NP_MSG_PAD_BUFFER; spac << (u32)m_target_buffer_size; socket.Send(spac); // sync values with new client for (const auto& p : m_players) { spac.Clear(); spac << (MessageId)NP_MSG_PLAYER_JOIN; spac << p.second.pid << p.second.name << p.second.revision; socket.Send(spac); } } // unlock send // add client to the player list { std::lock_guard<std::recursive_mutex> lkp(m_crit.players); m_players[socket] = player; std::lock_guard<std::recursive_mutex> lks(m_crit.send); UpdatePadMapping(); // sync pad mappings with everyone UpdateWiimoteMapping(); } // add client to selector/ used for receiving m_selector.Add(socket); return 0; }
// called from ---NETPLAY--- thread void NetPlayServer::ThreadFunc() { while (m_do_loop) { // update pings every so many seconds if ((m_ping_timer.GetTimeElapsed() > 1000) || m_update_pings) { m_ping_key = Common::Timer::GetTimeMs(); sf::Packet spac; spac << (MessageId)NP_MSG_PING; spac << m_ping_key; m_ping_timer.Start(); SendToClients(spac); m_update_pings = false; } ENetEvent netEvent; int net; if (m_traversal_client) m_traversal_client->HandleResends(); net = enet_host_service(m_server, &netEvent, 1000); while (!m_async_queue.Empty()) { { std::lock_guard<std::recursive_mutex> lkp(m_crit.players); SendToClients(m_async_queue.Front()); } m_async_queue.Pop(); } if (net > 0) { switch (netEvent.type) { case ENET_EVENT_TYPE_CONNECT: { ENetPeer* accept_peer = netEvent.peer; unsigned int error; { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); error = OnConnect(accept_peer); } if (error) { sf::Packet spac; spac << (MessageId)error; // don't need to lock, this client isn't in the client map Send(accept_peer, spac); if (netEvent.peer->data) { delete (PlayerId*)netEvent.peer->data; netEvent.peer->data = nullptr; } enet_peer_disconnect_later(accept_peer, 0); } } break; case ENET_EVENT_TYPE_RECEIVE: { sf::Packet rpac; rpac.append(netEvent.packet->data, netEvent.packet->dataLength); auto it = m_players.find(*(PlayerId*)netEvent.peer->data); Client& client = it->second; if (OnData(rpac, client) != 0) { // if a bad packet is received, disconnect the client std::lock_guard<std::recursive_mutex> lkg(m_crit.game); OnDisconnect(client); if (netEvent.peer->data) { delete (PlayerId*)netEvent.peer->data; netEvent.peer->data = nullptr; } } enet_packet_destroy(netEvent.packet); } break; case ENET_EVENT_TYPE_DISCONNECT: { std::lock_guard<std::recursive_mutex> lkg(m_crit.game); if (!netEvent.peer->data) break; auto it = m_players.find(*(PlayerId*)netEvent.peer->data); if (it != m_players.end()) { Client& client = it->second; OnDisconnect(client); if (netEvent.peer->data) { delete (PlayerId*)netEvent.peer->data; netEvent.peer->data = nullptr; } } } break; default: break; } } } // close listening socket and client sockets for (auto& player_entry : m_players) { delete (PlayerId*)player_entry.second.socket->data; player_entry.second.socket->data = nullptr; enet_peer_disconnect(player_entry.second.socket, 0); } }