summaryrefslogtreecommitdiffstats
path: root/src/network
diff options
context:
space:
mode:
Diffstat (limited to 'src/network')
-rw-r--r--src/network/room.cpp200
-rw-r--r--src/network/room.h6
2 files changed, 205 insertions, 1 deletions
diff --git a/src/network/room.cpp b/src/network/room.cpp
index 274cb4159..3502264e1 100644
--- a/src/network/room.cpp
+++ b/src/network/room.cpp
@@ -3,8 +3,11 @@
// Refer to the license.txt file included.
#include <atomic>
+#include <random>
#include <thread>
+#include <vector>
#include "enet/enet.h"
+#include "network/packet.h"
#include "network/room.h"
namespace Network {
@@ -14,17 +17,87 @@ 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);
+
+ /**
+ * Notifies the member that its connection attempt was successful,
+ * and it is now part of the room.
+ */
+ void SendJoinSuccess(ENetPeer* client, MacAddress mac_address);
+
+ /**
+ * 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
+ * <uint32_t> member_slots: The max number of clients allowed in this room
+ * <uint32_t> 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();
};
// RoomImpl
@@ -34,7 +107,12 @@ void Room::RoomImpl::ServerLoop() {
if (enet_host_service(server, &event, 1000) > 0) {
switch (event.type) {
case ENET_EVENT_TYPE_RECEIVE:
- // TODO(B3N30): Select the type of message and handle it
+ switch (event.packet->data[0]) {
+ case IdJoinRequest:
+ HandleJoinRequest(&event);
+ break;
+ // TODO(B3N30): Handle the other message types
+ }
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
@@ -49,6 +127,126 @@ 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(MessageID));
+ std::string nickname;
+ packet >> nickname;
+
+ MacAddress preferred_mac;
+ packet >> preferred_mac;
+
+ 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();
+ }
+
+ // 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(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.
+ for (const Member& member : members) {
+ if (member.nickname == nickname) {
+ return false;
+ }
+ }
+ return true;
+}
+
+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.
+ for (const Member& member : members) {
+ if (member.mac_address == address) {
+ return false;
+ }
+ }
+ return true;
+}
+
+void Room::RoomImpl::SendNameCollision(ENetPeer* client) {
+ Packet packet;
+ packet << static_cast<MessageID>(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<MessageID>(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::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) {
+ Packet packet;
+ packet << static_cast<MessageID>(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::BroadcastRoomInformation() {
+ Packet packet;
+ packet << static_cast<MessageID>(IdRoomInformation);
+ packet << room_information.name;
+ packet << room_information.member_slots;
+
+ packet << static_cast<uint32_t>(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;
+ std::uniform_int_distribution<> dis(0x00, 0xFF); // Random byte between 0 and 0xFF
+ do {
+ for (int i = 3; i < result_mac.size(); ++i) {
+ result_mac[i] = dis(random_gen);
+ }
+ } while (!IsValidMacAddress(result_mac));
+ return result_mac;
+}
+
// Room
Room::Room() : room_impl{std::make_unique<RoomImpl>()} {}
diff --git a/src/network/room.h b/src/network/room.h
index 0a6217c11..ca663058f 100644
--- a/src/network/room.h
+++ b/src/network/room.h
@@ -4,6 +4,7 @@
#pragma once
+#include <array>
#include <memory>
#include <string>
#include "common/common_types.h"
@@ -18,6 +19,11 @@ struct RoomInformation {
u32 member_slots; ///< Maximum number of members in this room
};
+using MacAddress = std::array<uint8_t, 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};
+
// The different types of messages that can be sent. The first byte of each packet defines the type
typedef uint8_t MessageID;
enum RoomMessageTypes {
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 15:12:41 +0100