Merge pull request #2818 from B3n30/network
Enable data transfer over ENet
This commit is contained in:
commit
924215a41f
|
@ -16,7 +16,7 @@ set(HEADERS
|
|||
create_directory_groups(${SRCS} ${HEADERS})
|
||||
|
||||
add_executable(citra ${SRCS} ${HEADERS})
|
||||
target_link_libraries(citra PRIVATE common core input_common)
|
||||
target_link_libraries(citra PRIVATE common core input_common network)
|
||||
target_link_libraries(citra PRIVATE inih glad)
|
||||
if (MSVC)
|
||||
target_link_libraries(citra PRIVATE getopt)
|
||||
|
|
|
@ -16,6 +16,7 @@
|
|||
#include "core/settings.h"
|
||||
#include "input_common/keyboard.h"
|
||||
#include "input_common/main.h"
|
||||
#include "network/network.h"
|
||||
|
||||
void EmuWindow_SDL2::OnMouseMotion(s32 x, s32 y) {
|
||||
TouchMoved((unsigned)std::max(x, 0), (unsigned)std::max(y, 0));
|
||||
|
@ -58,6 +59,7 @@ void EmuWindow_SDL2::OnResize() {
|
|||
|
||||
EmuWindow_SDL2::EmuWindow_SDL2() {
|
||||
InputCommon::Init();
|
||||
Network::Init();
|
||||
|
||||
motion_emu = std::make_unique<Motion::MotionEmu>(*this);
|
||||
|
||||
|
@ -116,6 +118,8 @@ EmuWindow_SDL2::~EmuWindow_SDL2() {
|
|||
SDL_GL_DeleteContext(gl_context);
|
||||
SDL_Quit();
|
||||
motion_emu = nullptr;
|
||||
|
||||
Network::Shutdown();
|
||||
InputCommon::Shutdown();
|
||||
}
|
||||
|
||||
|
|
|
@ -1,11 +1,13 @@
|
|||
set(SRCS
|
||||
network.cpp
|
||||
packet.cpp
|
||||
room.cpp
|
||||
room_member.cpp
|
||||
)
|
||||
|
||||
set(HEADERS
|
||||
network.h
|
||||
packet.h
|
||||
room.h
|
||||
room_member.h
|
||||
)
|
||||
|
|
|
@ -0,0 +1,225 @@
|
|||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <winsock2.h>
|
||||
#else
|
||||
#include <arpa/inet.h>
|
||||
#endif
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include "network/packet.h"
|
||||
|
||||
namespace Network {
|
||||
|
||||
void Packet::Append(const void* in_data, std::size_t size_in_bytes) {
|
||||
if (in_data && (size_in_bytes > 0)) {
|
||||
std::size_t start = data.size();
|
||||
data.resize(start + size_in_bytes);
|
||||
std::memcpy(&data[start], in_data, size_in_bytes);
|
||||
}
|
||||
}
|
||||
|
||||
void Packet::Read(void* out_data, std::size_t size_in_bytes) {
|
||||
if (out_data && CheckSize(size_in_bytes)) {
|
||||
std::memcpy(out_data, &data[read_pos], size_in_bytes);
|
||||
read_pos += size_in_bytes;
|
||||
}
|
||||
}
|
||||
|
||||
void Packet::Clear() {
|
||||
data.clear();
|
||||
read_pos = 0;
|
||||
is_valid = true;
|
||||
}
|
||||
|
||||
const void* Packet::GetData() const {
|
||||
return !data.empty() ? &data[0] : nullptr;
|
||||
}
|
||||
|
||||
void Packet::IgnoreBytes(u32 length) {
|
||||
read_pos += length;
|
||||
}
|
||||
|
||||
std::size_t Packet::GetDataSize() const {
|
||||
return data.size();
|
||||
}
|
||||
|
||||
bool Packet::EndOfPacket() const {
|
||||
return read_pos >= data.size();
|
||||
}
|
||||
|
||||
Packet::operator bool() const {
|
||||
return is_valid ? &Packet::CheckSize : nullptr;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(bool& out_data) {
|
||||
u8 value;
|
||||
if (*this >> value) {
|
||||
out_data = (value != 0);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(s8& out_data) {
|
||||
Read(&out_data, sizeof(out_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(u8& out_data) {
|
||||
Read(&out_data, sizeof(out_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(s16& out_data) {
|
||||
s16 value;
|
||||
Read(&value, sizeof(value));
|
||||
out_data = ntohs(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(u16& out_data) {
|
||||
u16 value;
|
||||
Read(&value, sizeof(value));
|
||||
out_data = ntohs(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(s32& out_data) {
|
||||
s32 value;
|
||||
Read(&value, sizeof(value));
|
||||
out_data = ntohl(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(u32& out_data) {
|
||||
u32 value;
|
||||
Read(&value, sizeof(value));
|
||||
out_data = ntohl(value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(float& out_data) {
|
||||
Read(&out_data, sizeof(out_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(double& out_data) {
|
||||
Read(&out_data, sizeof(out_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(char* out_data) {
|
||||
// First extract string length
|
||||
u32 length = 0;
|
||||
*this >> length;
|
||||
|
||||
if ((length > 0) && CheckSize(length)) {
|
||||
// Then extract characters
|
||||
std::memcpy(out_data, &data[read_pos], length);
|
||||
out_data[length] = '\0';
|
||||
|
||||
// Update reading position
|
||||
read_pos += length;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator>>(std::string& out_data) {
|
||||
// First extract string length
|
||||
u32 length = 0;
|
||||
*this >> length;
|
||||
|
||||
out_data.clear();
|
||||
if ((length > 0) && CheckSize(length)) {
|
||||
// Then extract characters
|
||||
out_data.assign(&data[read_pos], length);
|
||||
|
||||
// Update reading position
|
||||
read_pos += length;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(bool in_data) {
|
||||
*this << static_cast<u8>(in_data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(s8 in_data) {
|
||||
Append(&in_data, sizeof(in_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(u8 in_data) {
|
||||
Append(&in_data, sizeof(in_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(s16 in_data) {
|
||||
s16 toWrite = htons(in_data);
|
||||
Append(&toWrite, sizeof(toWrite));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(u16 in_data) {
|
||||
u16 toWrite = htons(in_data);
|
||||
Append(&toWrite, sizeof(toWrite));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(s32 in_data) {
|
||||
s32 toWrite = htonl(in_data);
|
||||
Append(&toWrite, sizeof(toWrite));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(u32 in_data) {
|
||||
u32 toWrite = htonl(in_data);
|
||||
Append(&toWrite, sizeof(toWrite));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(float in_data) {
|
||||
Append(&in_data, sizeof(in_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(double in_data) {
|
||||
Append(&in_data, sizeof(in_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(const char* in_data) {
|
||||
// First insert string length
|
||||
u32 length = std::strlen(in_data);
|
||||
*this << length;
|
||||
|
||||
// Then insert characters
|
||||
Append(in_data, length * sizeof(char));
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
Packet& Packet::operator<<(const std::string& in_data) {
|
||||
// First insert string length
|
||||
u32 length = static_cast<u32>(in_data.size());
|
||||
*this << length;
|
||||
|
||||
// Then insert characters
|
||||
if (length > 0)
|
||||
Append(in_data.c_str(), length * sizeof(std::string::value_type));
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool Packet::CheckSize(std::size_t size) {
|
||||
is_valid = is_valid && (read_pos + size <= data.size());
|
||||
|
||||
return is_valid;
|
||||
}
|
||||
|
||||
} // namespace Network
|
|
@ -0,0 +1,162 @@
|
|||
// Copyright 2017 Citra Emulator Project
|
||||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <vector>
|
||||
#include "common/common_types.h"
|
||||
|
||||
namespace Network {
|
||||
|
||||
/// A class that serializes data for network transfer. It also handles endianess
|
||||
class Packet {
|
||||
public:
|
||||
Packet() = default;
|
||||
~Packet() = default;
|
||||
|
||||
/**
|
||||
* Append data to the end of the packet
|
||||
* @param data Pointer to the sequence of bytes to append
|
||||
* @param size_in_bytes Number of bytes to append
|
||||
*/
|
||||
void Append(const void* data, std::size_t size_in_bytes);
|
||||
|
||||
/**
|
||||
* Reads data from the current read position of the packet
|
||||
* @param out_data Pointer where the data should get written to
|
||||
* @param size_in_bytes Number of bytes to read
|
||||
*/
|
||||
void Read(void* out_data, std::size_t size_in_bytes);
|
||||
|
||||
/**
|
||||
* Clear the packet
|
||||
* After calling Clear, the packet is empty.
|
||||
*/
|
||||
void Clear();
|
||||
|
||||
/**
|
||||
* Ignores bytes while reading
|
||||
* @param length THe number of bytes to ignore
|
||||
*/
|
||||
void IgnoreBytes(u32 length);
|
||||
|
||||
/**
|
||||
* Get a pointer to the data contained in the packet
|
||||
* @return Pointer to the data
|
||||
*/
|
||||
const void* GetData() const;
|
||||
|
||||
/**
|
||||
* This function returns the number of bytes pointed to by
|
||||
* what getData returns.
|
||||
* @return Data size, in bytes
|
||||
*/
|
||||
std::size_t GetDataSize() const;
|
||||
|
||||
/**
|
||||
* This function is useful to know if there is some data
|
||||
* left to be read, without actually reading it.
|
||||
* @return True if all data was read, false otherwise
|
||||
*/
|
||||
bool EndOfPacket() const;
|
||||
|
||||
explicit operator bool() const;
|
||||
|
||||
/// Overloads of operator >> to read data from the packet
|
||||
Packet& operator>>(bool& out_data);
|
||||
Packet& operator>>(s8& out_data);
|
||||
Packet& operator>>(u8& out_data);
|
||||
Packet& operator>>(s16& out_data);
|
||||
Packet& operator>>(u16& out_data);
|
||||
Packet& operator>>(s32& out_data);
|
||||
Packet& operator>>(u32& out_data);
|
||||
Packet& operator>>(float& out_data);
|
||||
Packet& operator>>(double& out_data);
|
||||
Packet& operator>>(char* out_data);
|
||||
Packet& operator>>(std::string& out_data);
|
||||
template <typename T>
|
||||
Packet& operator>>(std::vector<T>& out_data);
|
||||
template <typename T, std::size_t S>
|
||||
Packet& operator>>(std::array<T, S>& out_data);
|
||||
|
||||
/// Overloads of operator << to write data into the packet
|
||||
Packet& operator<<(bool in_data);
|
||||
Packet& operator<<(s8 in_data);
|
||||
Packet& operator<<(u8 in_data);
|
||||
Packet& operator<<(s16 in_data);
|
||||
Packet& operator<<(u16 in_data);
|
||||
Packet& operator<<(s32 in_data);
|
||||
Packet& operator<<(u32 in_data);
|
||||
Packet& operator<<(float in_data);
|
||||
Packet& operator<<(double in_data);
|
||||
Packet& operator<<(const char* in_data);
|
||||
Packet& operator<<(const std::string& in_data);
|
||||
template <typename T>
|
||||
Packet& operator<<(const std::vector<T>& in_data);
|
||||
template <typename T, std::size_t S>
|
||||
Packet& operator<<(const std::array<T, S>& data);
|
||||
|
||||
private:
|
||||
/**
|
||||
* Check if the packet can extract a given number of bytes
|
||||
* This function updates accordingly the state of the packet.
|
||||
* @param size Size to check
|
||||
* @return True if size bytes can be read from the packet
|
||||
*/
|
||||
bool CheckSize(std::size_t size);
|
||||
|
||||
// Member data
|
||||
std::vector<char> data; ///< Data stored in the packet
|
||||
std::size_t read_pos = 0; ///< Current reading position in the packet
|
||||
bool is_valid = true; ///< Reading state of the packet
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
Packet& Packet::operator>>(std::vector<T>& out_data) {
|
||||
// First extract the size
|
||||
u32 size = 0;
|
||||
*this >> size;
|
||||
out_data.resize(size);
|
||||
|
||||
// Then extract the data
|
||||
for (std::size_t i = 0; i < out_data.size(); ++i) {
|
||||
T character = 0;
|
||||
*this >> character;
|
||||
out_data[i] = character;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T, std::size_t S>
|
||||
Packet& Packet::operator>>(std::array<T, S>& out_data) {
|
||||
for (std::size_t i = 0; i < out_data.size(); ++i) {
|
||||
T character = 0;
|
||||
*this >> character;
|
||||
out_data[i] = character;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
Packet& Packet::operator<<(const std::vector<T>& in_data) {
|
||||
// First insert the size
|
||||
*this << static_cast<u32>(in_data.size());
|
||||
|
||||
// Then insert the data
|
||||
for (std::size_t i = 0; i < in_data.size(); ++i) {
|
||||
*this << in_data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <typename T, std::size_t S>
|
||||
Packet& Packet::operator<<(const std::array<T, S>& in_data) {
|
||||
for (std::size_t i = 0; i < in_data.size(); ++i) {
|
||||
*this << in_data[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
} // namespace Network
|
|
@ -2,7 +2,13 @@
|
|||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <algorithm>
|
||||
#include <atomic>
|
||||
#include <random>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
#include "enet/enet.h"
|
||||
#include "network/packet.h"
|
||||
#include "network/room.h"
|
||||
|
||||
namespace Network {
|
||||
|
@ -12,12 +18,395 @@ static constexpr u32 MaxConcurrentConnections = 10;
|
|||
|
||||
class Room::RoomImpl {
|
||||
public:
|
||||
// This MAC address is used to generate a 'Nintendo' like Mac address.
|
||||
const MacAddress NintendoOUI = {0x00, 0x1F, 0x32, 0x00, 0x00, 0x00};
|
||||
std::mt19937 random_gen; ///< Random number generator. Used for GenerateMacAddress
|
||||
|
||||
ENetHost* server = nullptr; ///< Network interface.
|
||||
|
||||
std::atomic<State> state{State::Closed}; ///< Current state of the room.
|
||||
RoomInformation room_information; ///< Information about this room.
|
||||
|
||||
struct Member {
|
||||
std::string nickname; ///< The nickname of the member.
|
||||
std::string game_name; ///< The current game of the member
|
||||
MacAddress mac_address; ///< The assigned mac address of the member.
|
||||
ENetPeer* peer; ///< The remote peer.
|
||||
};
|
||||
using MemberList = std::vector<Member>;
|
||||
MemberList members; ///< Information about the members of this room.
|
||||
|
||||
RoomImpl() : random_gen(std::random_device()()) {}
|
||||
|
||||
/// Thread that receives and dispatches network packets
|
||||
std::unique_ptr<std::thread> room_thread;
|
||||
|
||||
/// Thread function that will receive and dispatch messages until the room is destroyed.
|
||||
void ServerLoop();
|
||||
void StartLoop();
|
||||
|
||||
/**
|
||||
* Parses and answers a room join request from a client.
|
||||
* Validates the uniqueness of the username and assigns the MAC address
|
||||
* that the client will use for the remainder of the connection.
|
||||
*/
|
||||
void HandleJoinRequest(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Returns whether the nickname is valid, ie. isn't already taken by someone else in the room.
|
||||
*/
|
||||
bool IsValidNickname(const std::string& nickname) const;
|
||||
|
||||
/**
|
||||
* Returns whether the MAC address is valid, ie. isn't already taken by someone else in the
|
||||
* room.
|
||||
*/
|
||||
bool IsValidMacAddress(const MacAddress& address) const;
|
||||
|
||||
/**
|
||||
* Sends a ID_ROOM_NAME_COLLISION message telling the client that the name is invalid.
|
||||
*/
|
||||
void SendNameCollision(ENetPeer* client);
|
||||
|
||||
/**
|
||||
* Sends a ID_ROOM_MAC_COLLISION message telling the client that the MAC is invalid.
|
||||
*/
|
||||
void SendMacCollision(ENetPeer* client);
|
||||
|
||||
/**
|
||||
* Sends a ID_ROOM_VERSION_MISMATCH message telling the client that the version is invalid.
|
||||
*/
|
||||
void SendVersionMismatch(ENetPeer* client);
|
||||
|
||||
/**
|
||||
* Notifies the member that its connection attempt was successful,
|
||||
* and it is now part of the room.
|
||||
*/
|
||||
void SendJoinSuccess(ENetPeer* client, MacAddress mac_address);
|
||||
|
||||
/**
|
||||
* Notifies the members that the room is closed,
|
||||
*/
|
||||
void SendCloseMessage();
|
||||
|
||||
/**
|
||||
* Sends the information about the room, along with the list of members
|
||||
* to every connected client in the room.
|
||||
* The packet has the structure:
|
||||
* <MessageID>ID_ROOM_INFORMATION
|
||||
* <String> room_name
|
||||
* <u32> member_slots: The max number of clients allowed in this room
|
||||
* <u32> num_members: the number of currently joined clients
|
||||
* This is followed by the following three values for each member:
|
||||
* <String> nickname of that member
|
||||
* <MacAddress> mac_address of that member
|
||||
* <String> game_name of that member
|
||||
*/
|
||||
void BroadcastRoomInformation();
|
||||
|
||||
/**
|
||||
* Generates a free MAC address to assign to a new client.
|
||||
* The first 3 bytes are the NintendoOUI 0x00, 0x1F, 0x32
|
||||
*/
|
||||
MacAddress GenerateMacAddress();
|
||||
|
||||
/**
|
||||
* Broadcasts this packet to all members except the sender.
|
||||
* @param event The ENet event containing the data
|
||||
*/
|
||||
void HandleWifiPacket(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Extracts a chat entry from a received ENet packet and adds it to the chat queue.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleChatPacket(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Extracts the game name from a received ENet packet and broadcasts it.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleGameNamePacket(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Removes the client from the members list if it was in it and announces the change
|
||||
* to all other clients.
|
||||
*/
|
||||
void HandleClientDisconnection(ENetPeer* client);
|
||||
};
|
||||
|
||||
// RoomImpl
|
||||
void Room::RoomImpl::ServerLoop() {
|
||||
while (state != State::Closed) {
|
||||
ENetEvent event;
|
||||
if (enet_host_service(server, &event, 100) > 0) {
|
||||
switch (event.type) {
|
||||
case ENET_EVENT_TYPE_RECEIVE:
|
||||
switch (event.packet->data[0]) {
|
||||
case IdJoinRequest:
|
||||
HandleJoinRequest(&event);
|
||||
break;
|
||||
case IdSetGameName:
|
||||
HandleGameNamePacket(&event);
|
||||
break;
|
||||
case IdWifiPacket:
|
||||
HandleWifiPacket(&event);
|
||||
break;
|
||||
case IdChatMessage:
|
||||
HandleChatPacket(&event);
|
||||
break;
|
||||
}
|
||||
enet_packet_destroy(event.packet);
|
||||
break;
|
||||
case ENET_EVENT_TYPE_DISCONNECT:
|
||||
HandleClientDisconnection(event.peer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Close the connection to all members:
|
||||
SendCloseMessage();
|
||||
}
|
||||
|
||||
void Room::RoomImpl::StartLoop() {
|
||||
room_thread = std::make_unique<std::thread>(&Room::RoomImpl::ServerLoop, this);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
|
||||
Packet packet;
|
||||
packet.Append(event->packet->data, event->packet->dataLength);
|
||||
packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
std::string nickname;
|
||||
packet >> nickname;
|
||||
|
||||
MacAddress preferred_mac;
|
||||
packet >> preferred_mac;
|
||||
|
||||
u32 client_version;
|
||||
packet >> client_version;
|
||||
|
||||
if (!IsValidNickname(nickname)) {
|
||||
SendNameCollision(event->peer);
|
||||
return;
|
||||
}
|
||||
|
||||
if (preferred_mac != NoPreferredMac) {
|
||||
// Verify if the preferred mac is available
|
||||
if (!IsValidMacAddress(preferred_mac)) {
|
||||
SendMacCollision(event->peer);
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
// Assign a MAC address of this client automatically
|
||||
preferred_mac = GenerateMacAddress();
|
||||
}
|
||||
|
||||
if (client_version != network_version) {
|
||||
SendVersionMismatch(event->peer);
|
||||
return;
|
||||
}
|
||||
|
||||
// At this point the client is ready to be added to the room.
|
||||
Member member{};
|
||||
member.mac_address = preferred_mac;
|
||||
member.nickname = nickname;
|
||||
member.peer = event->peer;
|
||||
|
||||
members.push_back(std::move(member));
|
||||
|
||||
// Notify everyone that the room information has changed.
|
||||
BroadcastRoomInformation();
|
||||
SendJoinSuccess(event->peer, preferred_mac);
|
||||
}
|
||||
|
||||
bool Room::RoomImpl::IsValidNickname(const std::string& nickname) const {
|
||||
// A nickname is valid if it is not already taken by anybody else in the room.
|
||||
// TODO(B3N30): Check for empty names, spaces, etc.
|
||||
return std::all_of(members.begin(), members.end(),
|
||||
[&nickname](const auto& member) { return member.nickname != nickname; });
|
||||
}
|
||||
|
||||
bool Room::RoomImpl::IsValidMacAddress(const MacAddress& address) const {
|
||||
// A MAC address is valid if it is not already taken by anybody else in the room.
|
||||
return std::all_of(members.begin(), members.end(),
|
||||
[&address](const auto& member) { return member.mac_address != address; });
|
||||
}
|
||||
|
||||
void Room::RoomImpl::SendNameCollision(ENetPeer* client) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdNameCollision);
|
||||
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_peer_send(client, 0, enet_packet);
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::SendMacCollision(ENetPeer* client) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdMacCollision);
|
||||
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_peer_send(client, 0, enet_packet);
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdVersionMismatch);
|
||||
packet << network_version;
|
||||
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_peer_send(client, 0, enet_packet);
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdJoinSuccess);
|
||||
packet << mac_address;
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_peer_send(client, 0, enet_packet);
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::SendCloseMessage() {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdCloseRoom);
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
for (auto& member : members) {
|
||||
enet_peer_send(member.peer, 0, enet_packet);
|
||||
}
|
||||
enet_host_flush(server);
|
||||
for (auto& member : members) {
|
||||
enet_peer_disconnect(member.peer, 0);
|
||||
}
|
||||
}
|
||||
|
||||
void Room::RoomImpl::BroadcastRoomInformation() {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdRoomInformation);
|
||||
packet << room_information.name;
|
||||
packet << room_information.member_slots;
|
||||
|
||||
packet << static_cast<u32>(members.size());
|
||||
for (const auto& member : members) {
|
||||
packet << member.nickname;
|
||||
packet << member.mac_address;
|
||||
packet << member.game_name;
|
||||
}
|
||||
|
||||
ENetPacket* enet_packet =
|
||||
enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_host_broadcast(server, 0, enet_packet);
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
MacAddress Room::RoomImpl::GenerateMacAddress() {
|
||||
MacAddress result_mac =
|
||||
NintendoOUI; // The first three bytes of each MAC address will be the NintendoOUI
|
||||
std::uniform_int_distribution<> dis(0x00, 0xFF); // Random byte between 0 and 0xFF
|
||||
do {
|
||||
for (size_t i = 3; i < result_mac.size(); ++i) {
|
||||
result_mac[i] = dis(random_gen);
|
||||
}
|
||||
} while (!IsValidMacAddress(result_mac));
|
||||
return result_mac;
|
||||
}
|
||||
|
||||
void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) {
|
||||
Packet in_packet;
|
||||
in_packet.Append(event->packet->data, event->packet->dataLength);
|
||||
in_packet.IgnoreBytes(sizeof(u8)); // Message type
|
||||
in_packet.IgnoreBytes(sizeof(u8)); // WifiPacket Type
|
||||
in_packet.IgnoreBytes(sizeof(u8)); // WifiPacket Channel
|
||||
in_packet.IgnoreBytes(sizeof(MacAddress)); // WifiPacket Transmitter Address
|
||||
MacAddress destination_address;
|
||||
in_packet >> destination_address;
|
||||
|
||||
Packet out_packet;
|
||||
out_packet.Append(event->packet->data, event->packet->dataLength);
|
||||
ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(),
|
||||
ENET_PACKET_FLAG_RELIABLE);
|
||||
|
||||
if (destination_address == BroadcastMac) { // Send the data to everyone except the sender
|
||||
for (const auto& member : members) {
|
||||
if (member.peer != event->peer)
|
||||
enet_peer_send(member.peer, 0, enet_packet);
|
||||
}
|
||||
} else { // Send the data only to the destination client
|
||||
auto member = std::find_if(members.begin(), members.end(),
|
||||
[destination_address](const Member& member) -> bool {
|
||||
return member.mac_address == destination_address;
|
||||
});
|
||||
if (member != members.end()) {
|
||||
enet_peer_send(member->peer, 0, enet_packet);
|
||||
}
|
||||
}
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) {
|
||||
Packet in_packet;
|
||||
in_packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
in_packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
std::string message;
|
||||
in_packet >> message;
|
||||
auto CompareNetworkAddress = [event](const Member member) -> bool {
|
||||
return member.peer == event->peer;
|
||||
};
|
||||
const auto sending_member = std::find_if(members.begin(), members.end(), CompareNetworkAddress);
|
||||
if (sending_member == members.end()) {
|
||||
return; // Received a chat message from a unknown sender
|
||||
}
|
||||
|
||||
Packet out_packet;
|
||||
out_packet << static_cast<u8>(IdChatMessage);
|
||||
out_packet << sending_member->nickname;
|
||||
out_packet << message;
|
||||
|
||||
ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(),
|
||||
ENET_PACKET_FLAG_RELIABLE);
|
||||
for (const auto& member : members) {
|
||||
if (member.peer != event->peer)
|
||||
enet_peer_send(member.peer, 0, enet_packet);
|
||||
}
|
||||
enet_host_flush(server);
|
||||
}
|
||||
|
||||
void Room::RoomImpl::HandleGameNamePacket(const ENetEvent* event) {
|
||||
Packet in_packet;
|
||||
in_packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
in_packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
std::string game_name;
|
||||
in_packet >> game_name;
|
||||
auto member =
|
||||
std::find_if(members.begin(), members.end(),
|
||||
[event](const Member& member) -> bool { return member.peer == event->peer; });
|
||||
if (member != members.end()) {
|
||||
member->game_name = game_name;
|
||||
BroadcastRoomInformation();
|
||||
}
|
||||
}
|
||||
|
||||
void Room::RoomImpl::HandleClientDisconnection(ENetPeer* client) {
|
||||
// Remove the client from the members list.
|
||||
members.erase(std::remove_if(members.begin(), members.end(),
|
||||
[client](const Member& member) { return member.peer == client; }),
|
||||
members.end());
|
||||
|
||||
// Announce the change to all clients.
|
||||
enet_peer_disconnect(client, 0);
|
||||
BroadcastRoomInformation();
|
||||
}
|
||||
|
||||
// Room
|
||||
Room::Room() : room_impl{std::make_unique<RoomImpl>()} {}
|
||||
|
||||
Room::~Room() = default;
|
||||
|
@ -25,7 +414,9 @@ Room::~Room() = default;
|
|||
void Room::Create(const std::string& name, const std::string& server_address, u16 server_port) {
|
||||
ENetAddress address;
|
||||
address.host = ENET_HOST_ANY;
|
||||
enet_address_set_host(&address, server_address.c_str());
|
||||
if (!server_address.empty()) {
|
||||
enet_address_set_host(&address, server_address.c_str());
|
||||
}
|
||||
address.port = server_port;
|
||||
|
||||
room_impl->server = enet_host_create(&address, MaxConcurrentConnections, NumChannels, 0, 0);
|
||||
|
@ -34,8 +425,7 @@ void Room::Create(const std::string& name, const std::string& server_address, u1
|
|||
|
||||
room_impl->room_information.name = name;
|
||||
room_impl->room_information.member_slots = MaxConcurrentConnections;
|
||||
|
||||
// TODO(B3N30): Start the receiving thread
|
||||
room_impl->StartLoop();
|
||||
}
|
||||
|
||||
Room::State Room::GetState() const {
|
||||
|
@ -48,13 +438,17 @@ const RoomInformation& Room::GetRoomInformation() const {
|
|||
|
||||
void Room::Destroy() {
|
||||
room_impl->state = State::Closed;
|
||||
// TODO(B3n30): Join the receiving thread
|
||||
room_impl->room_thread->join();
|
||||
room_impl->room_thread.reset();
|
||||
|
||||
if (room_impl->server) {
|
||||
enet_host_destroy(room_impl->server);
|
||||
}
|
||||
room_impl->room_information = {};
|
||||
room_impl->server = nullptr;
|
||||
room_impl->members.clear();
|
||||
room_impl->room_information.member_slots = 0;
|
||||
room_impl->room_information.name.clear();
|
||||
}
|
||||
|
||||
} // namespace Network
|
||||
|
|
|
@ -4,13 +4,15 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <atomic>
|
||||
#include <array>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include "common/common_types.h"
|
||||
|
||||
namespace Network {
|
||||
|
||||
constexpr u32 network_version = 1; ///< The version of this Room and RoomMember
|
||||
|
||||
constexpr u16 DefaultRoomPort = 1234;
|
||||
constexpr size_t NumChannels = 1; // Number of channels used for the connection
|
||||
|
||||
|
@ -19,6 +21,28 @@ struct RoomInformation {
|
|||
u32 member_slots; ///< Maximum number of members in this room
|
||||
};
|
||||
|
||||
using MacAddress = std::array<u8, 6>;
|
||||
/// A special MAC address that tells the room we're joining to assign us a MAC address
|
||||
/// automatically.
|
||||
const MacAddress NoPreferredMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
|
||||
|
||||
// 802.11 broadcast MAC address
|
||||
constexpr MacAddress BroadcastMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
|
||||
|
||||
// The different types of messages that can be sent. The first byte of each packet defines the type
|
||||
enum RoomMessageTypes : u8 {
|
||||
IdJoinRequest = 1,
|
||||
IdJoinSuccess,
|
||||
IdRoomInformation,
|
||||
IdSetGameName,
|
||||
IdWifiPacket,
|
||||
IdChatMessage,
|
||||
IdNameCollision,
|
||||
IdMacCollision,
|
||||
IdVersionMismatch,
|
||||
IdCloseRoom
|
||||
};
|
||||
|
||||
/// This is what a server [person creating a server] would use.
|
||||
class Room final {
|
||||
public:
|
||||
|
|
|
@ -2,8 +2,13 @@
|
|||
// Licensed under GPLv2 or any later version
|
||||
// Refer to the license.txt file included.
|
||||
|
||||
#include <atomic>
|
||||
#include <list>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include "common/assert.h"
|
||||
#include "enet/enet.h"
|
||||
#include "network/packet.h"
|
||||
#include "network/room_member.h"
|
||||
|
||||
namespace Network {
|
||||
|
@ -15,11 +20,263 @@ public:
|
|||
ENetHost* client = nullptr; ///< ENet network interface.
|
||||
ENetPeer* server = nullptr; ///< The server peer the client is connected to
|
||||
|
||||
std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember.
|
||||
/// Information about the clients connected to the same room as us.
|
||||
MemberList member_information;
|
||||
/// Information about the room we're connected to.
|
||||
RoomInformation room_information;
|
||||
|
||||
std::string nickname; ///< The nickname of this member.
|
||||
std::atomic<State> state{State::Idle}; ///< Current state of the RoomMember.
|
||||
void SetState(const State new_state);
|
||||
bool IsConnected() const;
|
||||
|
||||
std::string nickname; ///< The nickname of this member.
|
||||
MacAddress mac_address; ///< The mac_address of this member.
|
||||
|
||||
std::mutex network_mutex; ///< Mutex that controls access to the `client` variable.
|
||||
/// Thread that receives and dispatches network packets
|
||||
std::unique_ptr<std::thread> loop_thread;
|
||||
std::mutex send_list_mutex; ///< Mutex that controls access to the `send_list` variable.
|
||||
std::list<Packet> send_list; ///< A list that stores all packets to send the async
|
||||
void MemberLoop();
|
||||
|
||||
void StartLoop();
|
||||
|
||||
/**
|
||||
* Sends data to the room. It will be send on channel 0 with flag RELIABLE
|
||||
* @param packet The data to send
|
||||
*/
|
||||
void Send(Packet&& packet);
|
||||
|
||||
/**
|
||||
* Sends a request to the server, asking for permission to join a room with the specified
|
||||
* nickname and preferred mac.
|
||||
* @params nickname The desired nickname.
|
||||
* @params preferred_mac The preferred MAC address to use in the room, the NoPreferredMac tells
|
||||
* the server to assign one for us.
|
||||
*/
|
||||
void SendJoinRequest(const std::string& nickname,
|
||||
const MacAddress& preferred_mac = NoPreferredMac);
|
||||
|
||||
/**
|
||||
* Extracts a MAC Address from a received ENet packet.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleJoinPacket(const ENetEvent* event);
|
||||
/**
|
||||
* Extracts RoomInformation and MemberInformation from a received RakNet packet.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleRoomInformationPacket(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Extracts a WifiPacket from a received ENet packet.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleWifiPackets(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Extracts a chat entry from a received ENet packet and adds it to the chat queue.
|
||||
* @param event The ENet event that was received.
|
||||
*/
|
||||
void HandleChatPacket(const ENetEvent* event);
|
||||
|
||||
/**
|
||||
* Disconnects the RoomMember from the Room
|
||||
*/
|
||||
void Disconnect();
|
||||
};
|
||||
|
||||
// RoomMemberImpl
|
||||
void RoomMember::RoomMemberImpl::SetState(const State new_state) {
|
||||
state = new_state;
|
||||
// TODO(B3N30): Invoke the callback functions
|
||||
}
|
||||
|
||||
bool RoomMember::RoomMemberImpl::IsConnected() const {
|
||||
return state == State::Joining || state == State::Joined;
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::MemberLoop() {
|
||||
// Receive packets while the connection is open
|
||||
while (IsConnected()) {
|
||||
std::lock_guard<std::mutex> lock(network_mutex);
|
||||
ENetEvent event;
|
||||
if (enet_host_service(client, &event, 100) > 0) {
|
||||
switch (event.type) {
|
||||
case ENET_EVENT_TYPE_RECEIVE:
|
||||
switch (event.packet->data[0]) {
|
||||
case IdWifiPacket:
|
||||
HandleWifiPackets(&event);
|
||||
break;
|
||||
case IdChatMessage:
|
||||
HandleChatPacket(&event);
|
||||
break;
|
||||
case IdRoomInformation:
|
||||
HandleRoomInformationPacket(&event);
|
||||
break;
|
||||
case IdJoinSuccess:
|
||||
// The join request was successful, we are now in the room.
|
||||
// If we joined successfully, there must be at least one client in the room: us.
|
||||
ASSERT_MSG(member_information.size() > 0,
|
||||
"We have not yet received member information.");
|
||||
HandleJoinPacket(&event); // Get the MAC Address for the client
|
||||
SetState(State::Joined);
|
||||
break;
|
||||
case IdNameCollision:
|
||||
SetState(State::NameCollision);
|
||||
break;
|
||||
case IdMacCollision:
|
||||
SetState(State::MacCollision);
|
||||
break;
|
||||
case IdVersionMismatch:
|
||||
SetState(State::WrongVersion);
|
||||
break;
|
||||
case IdCloseRoom:
|
||||
SetState(State::LostConnection);
|
||||
break;
|
||||
}
|
||||
enet_packet_destroy(event.packet);
|
||||
break;
|
||||
case ENET_EVENT_TYPE_DISCONNECT:
|
||||
SetState(State::LostConnection);
|
||||
break;
|
||||
}
|
||||
}
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(send_list_mutex);
|
||||
for (const auto& packet : send_list) {
|
||||
ENetPacket* enetPacket = enet_packet_create(packet.GetData(), packet.GetDataSize(),
|
||||
ENET_PACKET_FLAG_RELIABLE);
|
||||
enet_peer_send(server, 0, enetPacket);
|
||||
}
|
||||
enet_host_flush(client);
|
||||
send_list.clear();
|
||||
}
|
||||
}
|
||||
Disconnect();
|
||||
};
|
||||
|
||||
void RoomMember::RoomMemberImpl::StartLoop() {
|
||||
loop_thread = std::make_unique<std::thread>(&RoomMember::RoomMemberImpl::MemberLoop, this);
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::Send(Packet&& packet) {
|
||||
std::lock_guard<std::mutex> lock(send_list_mutex);
|
||||
send_list.push_back(std::move(packet));
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::SendJoinRequest(const std::string& nickname,
|
||||
const MacAddress& preferred_mac) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdJoinRequest);
|
||||
packet << nickname;
|
||||
packet << preferred_mac;
|
||||
packet << network_version;
|
||||
Send(std::move(packet));
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* event) {
|
||||
Packet packet;
|
||||
packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
// Ignore the first byte, which is the message id.
|
||||
packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
|
||||
RoomInformation info{};
|
||||
packet >> info.name;
|
||||
packet >> info.member_slots;
|
||||
room_information.name = info.name;
|
||||
room_information.member_slots = info.member_slots;
|
||||
|
||||
u32 num_members;
|
||||
packet >> num_members;
|
||||
member_information.resize(num_members);
|
||||
|
||||
for (auto& member : member_information) {
|
||||
packet >> member.nickname;
|
||||
packet >> member.mac_address;
|
||||
packet >> member.game_name;
|
||||
}
|
||||
// TODO(B3N30): Invoke callbacks
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::HandleJoinPacket(const ENetEvent* event) {
|
||||
Packet packet;
|
||||
packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
// Ignore the first byte, which is the message id.
|
||||
packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
|
||||
// Parse the MAC Address from the packet
|
||||
packet >> mac_address;
|
||||
// TODO(B3N30): Invoke callbacks
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) {
|
||||
WifiPacket wifi_packet{};
|
||||
Packet packet;
|
||||
packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
// Ignore the first byte, which is the message id.
|
||||
packet.IgnoreBytes(sizeof(u8)); // Igonore the message type
|
||||
|
||||
// Parse the WifiPacket from the packet
|
||||
u8 frame_type;
|
||||
packet >> frame_type;
|
||||
WifiPacket::PacketType type = static_cast<WifiPacket::PacketType>(frame_type);
|
||||
|
||||
wifi_packet.type = type;
|
||||
packet >> wifi_packet.channel;
|
||||
packet >> wifi_packet.transmitter_address;
|
||||
packet >> wifi_packet.destination_address;
|
||||
|
||||
u32 data_length;
|
||||
packet >> data_length;
|
||||
|
||||
packet >> wifi_packet.data;
|
||||
|
||||
// TODO(B3N30): Invoke callbacks
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) {
|
||||
Packet packet;
|
||||
packet.Append(event->packet->data, event->packet->dataLength);
|
||||
|
||||
// Ignore the first byte, which is the message id.
|
||||
packet.IgnoreBytes(sizeof(u8));
|
||||
|
||||
ChatEntry chat_entry{};
|
||||
packet >> chat_entry.nickname;
|
||||
packet >> chat_entry.message;
|
||||
// TODO(B3N30): Invoke callbacks
|
||||
}
|
||||
|
||||
void RoomMember::RoomMemberImpl::Disconnect() {
|
||||
member_information.clear();
|
||||
room_information.member_slots = 0;
|
||||
room_information.name.clear();
|
||||
|
||||
if (!server)
|
||||
return;
|
||||
enet_peer_disconnect(server, 0);
|
||||
|
||||
ENetEvent event;
|
||||
while (enet_host_service(client, &event, ConnectionTimeoutMs) > 0) {
|
||||
switch (event.type) {
|
||||
case ENET_EVENT_TYPE_RECEIVE:
|
||||
enet_packet_destroy(event.packet); // Ignore all incoming data
|
||||
break;
|
||||
case ENET_EVENT_TYPE_DISCONNECT:
|
||||
server = nullptr;
|
||||
return;
|
||||
}
|
||||
}
|
||||
// didn't disconnect gracefully force disconnect
|
||||
enet_peer_reset(server);
|
||||
server = nullptr;
|
||||
}
|
||||
|
||||
// RoomMember
|
||||
RoomMember::RoomMember() : room_member_impl{std::make_unique<RoomMemberImpl>()} {
|
||||
room_member_impl->client = enet_host_create(nullptr, 1, NumChannels, 0, 0);
|
||||
ASSERT_MSG(room_member_impl->client != nullptr, "Could not create client");
|
||||
|
@ -34,17 +291,44 @@ RoomMember::State RoomMember::GetState() const {
|
|||
return room_member_impl->state;
|
||||
}
|
||||
|
||||
const RoomMember::MemberList& RoomMember::GetMemberInformation() const {
|
||||
return room_member_impl->member_information;
|
||||
}
|
||||
|
||||
const std::string& RoomMember::GetNickname() const {
|
||||
return room_member_impl->nickname;
|
||||
}
|
||||
|
||||
const MacAddress& RoomMember::GetMacAddress() const {
|
||||
ASSERT_MSG(IsConnected(), "Tried to get MAC address while not connected");
|
||||
return room_member_impl->mac_address;
|
||||
}
|
||||
|
||||
RoomInformation RoomMember::GetRoomInformation() const {
|
||||
return room_member_impl->room_information;
|
||||
}
|
||||
|
||||
void RoomMember::Join(const std::string& nick, const char* server_addr, u16 server_port,
|
||||
u16 client_port) {
|
||||
u16 client_port, const MacAddress& preferred_mac) {
|
||||
// If the member is connected, kill the connection first
|
||||
if (room_member_impl->loop_thread && room_member_impl->loop_thread->joinable()) {
|
||||
room_member_impl->SetState(State::Error);
|
||||
room_member_impl->loop_thread->join();
|
||||
room_member_impl->loop_thread.reset();
|
||||
}
|
||||
// If the thread isn't running but the ptr still exists, reset it
|
||||
else if (room_member_impl->loop_thread) {
|
||||
room_member_impl->loop_thread.reset();
|
||||
}
|
||||
|
||||
ENetAddress address{};
|
||||
enet_address_set_host(&address, server_addr);
|
||||
address.port = server_port;
|
||||
|
||||
room_member_impl->server =
|
||||
enet_host_connect(room_member_impl->client, &address, NumChannels, 0);
|
||||
|
||||
if (!room_member_impl->server) {
|
||||
room_member_impl->state = State::Error;
|
||||
room_member_impl->SetState(State::Error);
|
||||
return;
|
||||
}
|
||||
|
||||
|
@ -52,23 +336,47 @@ void RoomMember::Join(const std::string& nick, const char* server_addr, u16 serv
|
|||
int net = enet_host_service(room_member_impl->client, &event, ConnectionTimeoutMs);
|
||||
if (net > 0 && event.type == ENET_EVENT_TYPE_CONNECT) {
|
||||
room_member_impl->nickname = nick;
|
||||
room_member_impl->state = State::Joining;
|
||||
// TODO(B3N30): Send a join request with the nickname to the server
|
||||
// TODO(B3N30): Start the receive thread
|
||||
room_member_impl->SetState(State::Joining);
|
||||
room_member_impl->StartLoop();
|
||||
room_member_impl->SendJoinRequest(nick, preferred_mac);
|
||||
} else {
|
||||
room_member_impl->state = State::CouldNotConnect;
|
||||
room_member_impl->SetState(State::CouldNotConnect);
|
||||
}
|
||||
}
|
||||
|
||||
bool RoomMember::IsConnected() const {
|
||||
return room_member_impl->state == State::Joining || room_member_impl->state == State::Joined;
|
||||
return room_member_impl->IsConnected();
|
||||
}
|
||||
|
||||
void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdWifiPacket);
|
||||
packet << static_cast<u8>(wifi_packet.type);
|
||||
packet << wifi_packet.channel;
|
||||
packet << wifi_packet.transmitter_address;
|
||||
packet << wifi_packet.destination_address;
|
||||
packet << wifi_packet.data;
|
||||
room_member_impl->Send(std::move(packet));
|
||||
}
|
||||
|
||||
void RoomMember::SendChatMessage(const std::string& message) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdChatMessage);
|
||||
packet << message;
|
||||
room_member_impl->Send(std::move(packet));
|
||||
}
|
||||
|
||||
void RoomMember::SendGameName(const std::string& game_name) {
|
||||
Packet packet;
|
||||
packet << static_cast<u8>(IdSetGameName);
|
||||
packet << game_name;
|
||||
room_member_impl->Send(std::move(packet));
|
||||
}
|
||||
|
||||
void RoomMember::Leave() {
|
||||
enet_peer_disconnect(room_member_impl->server, 0);
|
||||
room_member_impl->state = State::Idle;
|
||||
// TODO(B3N30): Close the receive thread
|
||||
enet_peer_reset(room_member_impl->server);
|
||||
room_member_impl->SetState(State::Idle);
|
||||
room_member_impl->loop_thread->join();
|
||||
room_member_impl->loop_thread.reset();
|
||||
}
|
||||
|
||||
} // namespace Network
|
||||
|
|
|
@ -4,14 +4,32 @@
|
|||
|
||||
#pragma once
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "common/common_types.h"
|
||||
#include "network/room.h"
|
||||
|
||||
namespace Network {
|
||||
|
||||
/// Information about the received WiFi packets.
|
||||
/// Acts as our own 802.11 header.
|
||||
struct WifiPacket {
|
||||
enum class PacketType : u8 { Beacon, Data, Authentication, AssociationResponse };
|
||||
PacketType type; ///< The type of 802.11 frame.
|
||||
std::vector<u8> data; ///< Raw 802.11 frame data, starting at the management frame header
|
||||
/// for management frames.
|
||||
MacAddress transmitter_address; ///< Mac address of the transmitter.
|
||||
MacAddress destination_address; ///< Mac address of the receiver.
|
||||
u8 channel; ///< WiFi channel where this frame was transmitted.
|
||||
};
|
||||
|
||||
/// Represents a chat message.
|
||||
struct ChatEntry {
|
||||
std::string nickname; ///< Nickname of the client who sent this message.
|
||||
std::string message; ///< Body of the message.
|
||||
};
|
||||
|
||||
/**
|
||||
* This is what a client [person joining a server] would use.
|
||||
* It also has to be used if you host a game yourself (You'd create both, a Room and a
|
||||
|
@ -29,9 +47,18 @@ public:
|
|||
// Reasons why connection was rejected
|
||||
NameCollision, ///< Somebody is already using this name
|
||||
MacCollision, ///< Somebody is already using that mac-address
|
||||
WrongVersion, ///< The room version is not the same as for this RoomMember
|
||||
CouldNotConnect ///< The room is not responding to a connection attempt
|
||||
};
|
||||
|
||||
struct MemberInformation {
|
||||
std::string nickname; ///< Nickname of the member.
|
||||
std::string game_name; ///< Name of the game they're currently playing, or empty if they're
|
||||
/// not playing anything.
|
||||
MacAddress mac_address; ///< MAC address associated with this member.
|
||||
};
|
||||
using MemberList = std::vector<MemberInformation>;
|
||||
|
||||
RoomMember();
|
||||
~RoomMember();
|
||||
|
||||
|
@ -40,6 +67,26 @@ public:
|
|||
*/
|
||||
State GetState() const;
|
||||
|
||||
/**
|
||||
* Returns information about the members in the room we're currently connected to.
|
||||
*/
|
||||
const MemberList& GetMemberInformation() const;
|
||||
|
||||
/**
|
||||
* Returns the nickname of the RoomMember.
|
||||
*/
|
||||
const std::string& GetNickname() const;
|
||||
|
||||
/**
|
||||
* Returns the MAC address of the RoomMember.
|
||||
*/
|
||||
const MacAddress& GetMacAddress() const;
|
||||
|
||||
/**
|
||||
* Returns information about the room we're currently connected to.
|
||||
*/
|
||||
RoomInformation GetRoomInformation() const;
|
||||
|
||||
/**
|
||||
* Returns whether we're connected to a server or not.
|
||||
*/
|
||||
|
@ -50,7 +97,26 @@ public:
|
|||
* This may fail if the username is already taken.
|
||||
*/
|
||||
void Join(const std::string& nickname, const char* server_addr = "127.0.0.1",
|
||||
const u16 serverPort = DefaultRoomPort, const u16 clientPort = 0);
|
||||
const u16 serverPort = DefaultRoomPort, const u16 clientPort = 0,
|
||||
const MacAddress& preferred_mac = NoPreferredMac);
|
||||
|
||||
/**
|
||||
* Sends a WiFi packet to the room.
|
||||
* @param packet The WiFi packet to send.
|
||||
*/
|
||||
void SendWifiPacket(const WifiPacket& packet);
|
||||
|
||||
/**
|
||||
* Sends a chat message to the room.
|
||||
* @param message The contents of the message.
|
||||
*/
|
||||
void SendChatMessage(const std::string& message);
|
||||
|
||||
/**
|
||||
* Sends the current game name to the room.
|
||||
* @param game_name The game name.
|
||||
*/
|
||||
void SendGameName(const std::string& game_name);
|
||||
|
||||
/**
|
||||
* Leaves the current room.
|
||||
|
|
Reference in New Issue