From f80c7c4cd5c090b9a31f89a0eb3d86cbe928c50b Mon Sep 17 00:00:00 2001 From: FearlessTobi Date: Sat, 30 Jul 2022 05:58:23 +0200 Subject: core, network: Add ability to proxy socket packets --- src/network/room.cpp | 170 ++++++++++++++++++-------------------------- src/network/room.h | 14 ++-- src/network/room_member.cpp | 123 +++++++++++++++++--------------- src/network/room_member.h | 70 ++++++++---------- 4 files changed, 168 insertions(+), 209 deletions(-) (limited to 'src/network') diff --git a/src/network/room.cpp b/src/network/room.cpp index 3fc3a0383..b06797bf1 100644 --- a/src/network/room.cpp +++ b/src/network/room.cpp @@ -20,9 +20,7 @@ namespace Network { class Room::RoomImpl { public: - // This MAC address is used to generate a 'Nintendo' like Mac address. - const MacAddress NintendoOUI; - std::mt19937 random_gen; ///< Random number generator. Used for GenerateMacAddress + std::mt19937 random_gen; ///< Random number generator. Used for GenerateFakeIPAddress ENetHost* server = nullptr; ///< Network interface. @@ -35,10 +33,9 @@ public: std::string password; ///< The password required to connect to this room. struct Member { - std::string nickname; ///< The nickname of the member. - std::string console_id_hash; ///< A hash of the console ID of the member. - GameInfo game_info; ///< The current game of the member - MacAddress mac_address; ///< The assigned mac address of the member. + std::string nickname; ///< The nickname of the member. + GameInfo game_info; ///< The current game of the member + IPv4Address fake_ip; ///< The assigned fake ip address of the member. /// Data of the user, often including authenticated forum username. VerifyUser::UserData user_data; ENetPeer* peer; ///< The remote peer. @@ -51,8 +48,7 @@ public: IPBanList ip_ban_list; ///< List of banned IP addresses mutable std::mutex ban_list_mutex; ///< Mutex for the ban lists - RoomImpl() - : NintendoOUI{0x00, 0x1F, 0x32, 0x00, 0x00, 0x00}, random_gen(std::random_device()()) {} + RoomImpl() : random_gen(std::random_device()()) {} /// Thread that receives and dispatches network packets std::unique_ptr room_thread; @@ -101,16 +97,10 @@ public: bool IsValidNickname(const std::string& nickname) const; /** - * Returns whether the MAC address is valid, ie. isn't already taken by someone else in the + * Returns whether the fake ip address is valid, ie. isn't already taken by someone else in the * room. */ - bool IsValidMacAddress(const MacAddress& address) const; - - /** - * Returns whether the console ID (hash) is valid, ie. isn't already taken by someone else in - * the room. - */ - bool IsValidConsoleId(const std::string& console_id_hash) const; + bool IsValidFakeIPAddress(const IPv4Address& address) const; /** * Returns whether a user has mod permissions. @@ -128,15 +118,9 @@ public: void SendNameCollision(ENetPeer* client); /** - * Sends a ID_ROOM_MAC_COLLISION message telling the client that the MAC is invalid. + * Sends a ID_ROOM_IP_COLLISION message telling the client that the IP is invalid. */ - void SendMacCollision(ENetPeer* client); - - /** - * Sends a IdConsoleIdCollison message telling the client that another member with the same - * console ID exists. - */ - void SendConsoleIdCollision(ENetPeer* client); + void SendIPCollision(ENetPeer* client); /** * Sends a ID_ROOM_VERSION_MISMATCH message telling the client that the version is invalid. @@ -152,13 +136,13 @@ public: * Notifies the member that its connection attempt was successful, * and it is now part of the room. */ - void SendJoinSuccess(ENetPeer* client, MacAddress mac_address); + void SendJoinSuccess(ENetPeer* client, IPv4Address fake_ip); /** * Notifies the member that its connection attempt was successful, * and it is now part of the room, and it has been granted mod permissions. */ - void SendJoinSuccessAsMod(ENetPeer* client, MacAddress mac_address); + void SendJoinSuccessAsMod(ENetPeer* client, IPv4Address fake_ip); /** * Sends a IdHostKicked message telling the client that they have been kicked. @@ -210,7 +194,7 @@ public: * num_members: the number of currently joined clients * This is followed by the following three values for each member: * nickname of that member - * mac_address of that member + * fake_ip of that member * game_name of that member */ void BroadcastRoomInformation(); @@ -219,13 +203,13 @@ public: * Generates a free MAC address to assign to a new client. * The first 3 bytes are the NintendoOUI 0x00, 0x1F, 0x32 */ - MacAddress GenerateMacAddress(); + IPv4Address GenerateFakeIPAddress(); /** * Broadcasts this packet to all members except the sender. * @param event The ENet event containing the data */ - void HandleWifiPacket(const ENetEvent* event); + void HandleProxyPacket(const ENetEvent* event); /** * Extracts a chat entry from a received ENet packet and adds it to the chat queue. @@ -250,7 +234,7 @@ public: void Room::RoomImpl::ServerLoop() { while (state != State::Closed) { ENetEvent event; - if (enet_host_service(server, &event, 16) > 0) { + if (enet_host_service(server, &event, 50) > 0) { switch (event.type) { case ENET_EVENT_TYPE_RECEIVE: switch (event.packet->data[0]) { @@ -260,8 +244,8 @@ void Room::RoomImpl::ServerLoop() { case IdSetGameInfo: HandleGameNamePacket(&event); break; - case IdWifiPacket: - HandleWifiPacket(&event); + case IdProxyPacket: + HandleProxyPacket(&event); break; case IdChatMessage: HandleChatPacket(&event); @@ -313,11 +297,8 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) { std::string nickname; packet.Read(nickname); - std::string console_id_hash; - packet.Read(console_id_hash); - - MacAddress preferred_mac; - packet.Read(preferred_mac); + IPv4Address preferred_fake_ip; + packet.Read(preferred_fake_ip); u32 client_version; packet.Read(client_version); @@ -338,20 +319,15 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) { return; } - if (preferred_mac != NoPreferredMac) { - // Verify if the preferred mac is available - if (!IsValidMacAddress(preferred_mac)) { - SendMacCollision(event->peer); + if (preferred_fake_ip != NoPreferredIP) { + // Verify if the preferred fake ip is available + if (!IsValidFakeIPAddress(preferred_fake_ip)) { + SendIPCollision(event->peer); return; } } else { - // Assign a MAC address of this client automatically - preferred_mac = GenerateMacAddress(); - } - - if (!IsValidConsoleId(console_id_hash)) { - SendConsoleIdCollision(event->peer); - return; + // Assign a fake ip address of this client automatically + preferred_fake_ip = GenerateFakeIPAddress(); } if (client_version != network_version) { @@ -361,8 +337,7 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) { // At this point the client is ready to be added to the room. Member member{}; - member.mac_address = preferred_mac; - member.console_id_hash = console_id_hash; + member.fake_ip = preferred_fake_ip; member.nickname = nickname; member.peer = event->peer; @@ -408,9 +383,9 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) { // Notify everyone that the room information has changed. BroadcastRoomInformation(); if (HasModPermission(event->peer)) { - SendJoinSuccessAsMod(event->peer, preferred_mac); + SendJoinSuccessAsMod(event->peer, preferred_fake_ip); } else { - SendJoinSuccess(event->peer, preferred_mac); + SendJoinSuccess(event->peer, preferred_fake_ip); } } @@ -575,19 +550,11 @@ bool Room::RoomImpl::IsValidNickname(const std::string& nickname) const { [&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. +bool Room::RoomImpl::IsValidFakeIPAddress(const IPv4Address& address) const { + // An IP address is valid if it is not already taken by anybody else in the room. std::lock_guard lock(member_mutex); return std::all_of(members.begin(), members.end(), - [&address](const auto& member) { return member.mac_address != address; }); -} - -bool Room::RoomImpl::IsValidConsoleId(const std::string& console_id_hash) const { - // A Console ID is valid if it is not already taken by anybody else in the room. - std::lock_guard lock(member_mutex); - return std::all_of(members.begin(), members.end(), [&console_id_hash](const auto& member) { - return member.console_id_hash != console_id_hash; - }); + [&address](const auto& member) { return member.fake_ip != address; }); } bool Room::RoomImpl::HasModPermission(const ENetPeer* client) const { @@ -621,19 +588,9 @@ void Room::RoomImpl::SendNameCollision(ENetPeer* client) { enet_host_flush(server); } -void Room::RoomImpl::SendMacCollision(ENetPeer* client) { +void Room::RoomImpl::SendIPCollision(ENetPeer* client) { Packet packet; - packet.Write(static_cast(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::SendConsoleIdCollision(ENetPeer* client) { - Packet packet; - packet.Write(static_cast(IdConsoleIdCollision)); + packet.Write(static_cast(IdIpCollision)); ENetPacket* enet_packet = enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); @@ -672,20 +629,20 @@ void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) { enet_host_flush(server); } -void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) { +void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, IPv4Address fake_ip) { Packet packet; packet.Write(static_cast(IdJoinSuccess)); - packet.Write(mac_address); + packet.Write(fake_ip); 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::SendJoinSuccessAsMod(ENetPeer* client, MacAddress mac_address) { +void Room::RoomImpl::SendJoinSuccessAsMod(ENetPeer* client, IPv4Address fake_ip) { Packet packet; packet.Write(static_cast(IdJoinSuccessAsMod)); - packet.Write(mac_address); + packet.Write(fake_ip); ENetPacket* enet_packet = enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); enet_peer_send(client, 0, enet_packet); @@ -818,7 +775,7 @@ void Room::RoomImpl::BroadcastRoomInformation() { std::lock_guard lock(member_mutex); for (const auto& member : members) { packet.Write(member.nickname); - packet.Write(member.mac_address); + packet.Write(member.fake_ip); packet.Write(member.game_info.name); packet.Write(member.game_info.id); packet.Write(member.user_data.username); @@ -833,34 +790,43 @@ void Room::RoomImpl::BroadcastRoomInformation() { 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 +IPv4Address Room::RoomImpl::GenerateFakeIPAddress() { + IPv4Address result_ip{192, 168, 0, 0}; + std::uniform_int_distribution<> dis(0x01, 0xFE); // Random byte between 1 and 0xFE do { - for (std::size_t i = 3; i < result_mac.size(); ++i) { - result_mac[i] = dis(random_gen); + for (std::size_t i = 2; i < result_ip.size(); ++i) { + result_ip[i] = dis(random_gen); } - } while (!IsValidMacAddress(result_mac)); - return result_mac; + } while (!IsValidFakeIPAddress(result_ip)); + + return result_ip; } -void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) { +void Room::RoomImpl::HandleProxyPacket(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.Read(destination_address); + in_packet.IgnoreBytes(sizeof(u8)); // Message type + + in_packet.IgnoreBytes(sizeof(u8)); // Domain + in_packet.IgnoreBytes(sizeof(IPv4Address)); // IP + in_packet.IgnoreBytes(sizeof(u16)); // Port + + in_packet.IgnoreBytes(sizeof(u8)); // Domain + IPv4Address remote_ip; + in_packet.Read(remote_ip); // IP + in_packet.IgnoreBytes(sizeof(u16)); // Port + + in_packet.IgnoreBytes(sizeof(u8)); // Protocol + bool broadcast; + in_packet.Read(broadcast); // Broadcast 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 + const auto& destination_address = remote_ip; + if (broadcast) { // Send the data to everyone except the sender std::lock_guard lock(member_mutex); bool sent_packet = false; for (const auto& member : members) { @@ -877,16 +843,16 @@ void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) { std::lock_guard lock(member_mutex); auto member = std::find_if(members.begin(), members.end(), [destination_address](const Member& member_entry) -> bool { - return member_entry.mac_address == destination_address; + return member_entry.fake_ip == destination_address; }); if (member != members.end()) { enet_peer_send(member->peer, 0, enet_packet); } else { LOG_ERROR(Network, - "Attempting to send to unknown MAC address: " - "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}", + "Attempting to send to unknown IP address: " + "{}.{}.{}.{}", destination_address[0], destination_address[1], destination_address[2], - destination_address[3], destination_address[4], destination_address[5]); + destination_address[3]); enet_packet_destroy(enet_packet); } } @@ -1073,7 +1039,7 @@ std::vector Room::GetRoomMemberList() const { member.username = member_impl.user_data.username; member.display_name = member_impl.user_data.display_name; member.avatar_url = member_impl.user_data.avatar_url; - member.mac_address = member_impl.mac_address; + member.fake_ip = member_impl.fake_ip; member.game = member_impl.game_info; member_list.push_back(member); } diff --git a/src/network/room.h b/src/network/room.h index 6f7e3b5b5..c2a4b1a70 100644 --- a/src/network/room.h +++ b/src/network/room.h @@ -9,12 +9,12 @@ #include #include "common/announce_multiplayer_room.h" #include "common/common_types.h" +#include "common/socket_types.h" #include "network/verify_user.h" namespace Network { using AnnounceMultiplayerRoom::GameInfo; -using AnnounceMultiplayerRoom::MacAddress; using AnnounceMultiplayerRoom::Member; using AnnounceMultiplayerRoom::RoomInformation; @@ -29,12 +29,9 @@ static constexpr u32 MaxConcurrentConnections = 254; constexpr std::size_t NumChannels = 1; // Number of channels used for the connection -/// A special MAC address that tells the room we're joining to assign us a MAC address +/// A special IP address that tells the room we're joining to assign us a IP address /// automatically. -constexpr MacAddress NoPreferredMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; - -// 802.11 broadcast MAC address -constexpr MacAddress BroadcastMac = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; +constexpr IPv4Address NoPreferredIP = {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 { @@ -42,15 +39,14 @@ enum RoomMessageTypes : u8 { IdJoinSuccess, IdRoomInformation, IdSetGameInfo, - IdWifiPacket, + IdProxyPacket, IdChatMessage, IdNameCollision, - IdMacCollision, + IdIpCollision, IdVersionMismatch, IdWrongPassword, IdCloseRoom, IdRoomIsFull, - IdConsoleIdCollision, IdStatusMessage, IdHostKicked, IdHostBanned, diff --git a/src/network/room_member.cpp b/src/network/room_member.cpp index e4f823e98..9f08bf611 100644 --- a/src/network/room_member.cpp +++ b/src/network/room_member.cpp @@ -7,6 +7,7 @@ #include #include #include "common/assert.h" +#include "common/socket_types.h" #include "enet/enet.h" #include "network/packet.h" #include "network/room_member.h" @@ -38,7 +39,7 @@ public: std::string username; ///< The username of this member. mutable std::mutex username_mutex; ///< Mutex for locking username. - MacAddress mac_address; ///< The mac_address of this member. + IPv4Address fake_ip; ///< The fake ip of this member. std::mutex network_mutex; ///< Mutex that controls access to the `client` variable. /// Thread that receives and dispatches network packets @@ -56,7 +57,7 @@ public: CallbackSet& Get(); private: - CallbackSet callback_set_wifi_packet; + CallbackSet callback_set_proxy_packet; CallbackSet callback_set_chat_messages; CallbackSet callback_set_status_messages; CallbackSet callback_set_room_information; @@ -78,15 +79,15 @@ public: /** * Sends a request to the server, asking for permission to join a room with the specified - * nickname and preferred mac. + * nickname and preferred fake ip. * @params nickname The desired nickname. - * @params console_id_hash A hash of the Console ID. - * @params preferred_mac The preferred MAC address to use in the room, the NoPreferredMac tells + * @params preferred_fake_ip The preferred IP address to use in the room, the NoPreferredIP + * tells * @params password The password for the room * the server to assign one for us. */ - void SendJoinRequest(const std::string& nickname_, const std::string& console_id_hash, - const MacAddress& preferred_mac = NoPreferredMac, + void SendJoinRequest(const std::string& nickname_, + const IPv4Address& preferred_fake_ip = NoPreferredIP, const std::string& password = "", const std::string& token = ""); /** @@ -101,10 +102,10 @@ public: void HandleRoomInformationPacket(const ENetEvent* event); /** - * Extracts a WifiPacket from a received ENet packet. + * Extracts a ProxyPacket from a received ENet packet. * @param event The ENet event that was received. */ - void HandleWifiPackets(const ENetEvent* event); + void HandleProxyPackets(const ENetEvent* event); /** * Extracts a chat entry from a received ENet packet and adds it to the chat queue. @@ -158,12 +159,12 @@ void RoomMember::RoomMemberImpl::MemberLoop() { while (IsConnected()) { std::lock_guard lock(network_mutex); ENetEvent event; - if (enet_host_service(client, &event, 16) > 0) { + 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); + case IdProxyPacket: + HandleProxyPackets(&event); break; case IdChatMessage: HandleChatPacket(&event); @@ -198,13 +199,9 @@ void RoomMember::RoomMemberImpl::MemberLoop() { SetState(State::Idle); SetError(Error::NameCollision); break; - case IdMacCollision: + case IdIpCollision: SetState(State::Idle); - SetError(Error::MacCollision); - break; - case IdConsoleIdCollision: - SetState(State::Idle); - SetError(Error::ConsoleIdCollision); + SetError(Error::IpCollision); break; case IdVersionMismatch: SetState(State::Idle); @@ -275,15 +272,13 @@ void RoomMember::RoomMemberImpl::Send(Packet&& packet) { } void RoomMember::RoomMemberImpl::SendJoinRequest(const std::string& nickname_, - const std::string& console_id_hash, - const MacAddress& preferred_mac, + const IPv4Address& preferred_fake_ip, const std::string& password, const std::string& token) { Packet packet; packet.Write(static_cast(IdJoinRequest)); packet.Write(nickname_); - packet.Write(console_id_hash); - packet.Write(preferred_mac); + packet.Write(preferred_fake_ip); packet.Write(network_version); packet.Write(password); packet.Write(token); @@ -317,7 +312,7 @@ void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* ev for (auto& member : member_information) { packet.Read(member.nickname); - packet.Read(member.mac_address); + packet.Read(member.fake_ip); packet.Read(member.game_info.name); packet.Read(member.game_info.id); packet.Read(member.username); @@ -342,29 +337,38 @@ void RoomMember::RoomMemberImpl::HandleJoinPacket(const ENetEvent* event) { packet.IgnoreBytes(sizeof(u8)); // Ignore the message type // Parse the MAC Address from the packet - packet.Read(mac_address); + packet.Read(fake_ip); } -void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) { - WifiPacket wifi_packet{}; +void RoomMember::RoomMemberImpl::HandleProxyPackets(const ENetEvent* event) { + ProxyPacket proxy_packet{}; Packet packet; packet.Append(event->packet->data, event->packet->dataLength); // Ignore the first byte, which is the message id. packet.IgnoreBytes(sizeof(u8)); // Ignore the message type - // Parse the WifiPacket from the packet - u8 frame_type; - packet.Read(frame_type); - WifiPacket::PacketType type = static_cast(frame_type); + // Parse the ProxyPacket from the packet + u8 local_family; + packet.Read(local_family); + proxy_packet.local_endpoint.family = static_cast(local_family); + packet.Read(proxy_packet.local_endpoint.ip); + packet.Read(proxy_packet.local_endpoint.portno); + + u8 remote_family; + packet.Read(remote_family); + proxy_packet.remote_endpoint.family = static_cast(remote_family); + packet.Read(proxy_packet.remote_endpoint.ip); + packet.Read(proxy_packet.remote_endpoint.portno); + + u8 protocol_type; + packet.Read(protocol_type); + proxy_packet.protocol = static_cast(protocol_type); - wifi_packet.type = type; - packet.Read(wifi_packet.channel); - packet.Read(wifi_packet.transmitter_address); - packet.Read(wifi_packet.destination_address); - packet.Read(wifi_packet.data); + packet.Read(proxy_packet.broadcast); + packet.Read(proxy_packet.data); - Invoke(wifi_packet); + Invoke(proxy_packet); } void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) { @@ -440,8 +444,8 @@ void RoomMember::RoomMemberImpl::Disconnect() { } template <> -RoomMember::RoomMemberImpl::CallbackSet& RoomMember::RoomMemberImpl::Callbacks::Get() { - return callback_set_wifi_packet; +RoomMember::RoomMemberImpl::CallbackSet& RoomMember::RoomMemberImpl::Callbacks::Get() { + return callback_set_proxy_packet; } template <> @@ -525,19 +529,18 @@ const std::string& RoomMember::GetUsername() const { return room_member_impl->username; } -const MacAddress& RoomMember::GetMacAddress() const { - ASSERT_MSG(IsConnected(), "Tried to get MAC address while not connected"); - return room_member_impl->mac_address; +const IPv4Address& RoomMember::GetFakeIpAddress() const { + ASSERT_MSG(IsConnected(), "Tried to get fake ip address while not connected"); + return room_member_impl->fake_ip; } RoomInformation RoomMember::GetRoomInformation() const { return room_member_impl->room_information; } -void RoomMember::Join(const std::string& nick, const std::string& console_id_hash, - const char* server_addr, u16 server_port, u16 client_port, - const MacAddress& preferred_mac, const std::string& password, - const std::string& token) { +void RoomMember::Join(const std::string& nick, const char* server_addr, u16 server_port, + u16 client_port, const IPv4Address& preferred_fake_ip, + const std::string& password, const std::string& token) { // If the member is connected, kill the connection first if (room_member_impl->loop_thread && room_member_impl->loop_thread->joinable()) { Leave(); @@ -571,7 +574,7 @@ void RoomMember::Join(const std::string& nick, const std::string& console_id_has if (net > 0 && event.type == ENET_EVENT_TYPE_CONNECT) { room_member_impl->nickname = nick; room_member_impl->StartLoop(); - room_member_impl->SendJoinRequest(nick, console_id_hash, preferred_mac, password, token); + room_member_impl->SendJoinRequest(nick, preferred_fake_ip, password, token); SendGameInfo(room_member_impl->current_game_info); } else { enet_peer_disconnect(room_member_impl->server, 0); @@ -584,14 +587,22 @@ bool RoomMember::IsConnected() const { return room_member_impl->IsConnected(); } -void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) { +void RoomMember::SendProxyPacket(const ProxyPacket& proxy_packet) { Packet packet; - packet.Write(static_cast(IdWifiPacket)); - packet.Write(static_cast(wifi_packet.type)); - packet.Write(wifi_packet.channel); - packet.Write(wifi_packet.transmitter_address); - packet.Write(wifi_packet.destination_address); - packet.Write(wifi_packet.data); + packet.Write(static_cast(IdProxyPacket)); + + packet.Write(static_cast(proxy_packet.local_endpoint.family)); + packet.Write(proxy_packet.local_endpoint.ip); + packet.Write(proxy_packet.local_endpoint.portno); + + packet.Write(static_cast(proxy_packet.remote_endpoint.family)); + packet.Write(proxy_packet.remote_endpoint.ip); + packet.Write(proxy_packet.remote_endpoint.portno); + + packet.Write(static_cast(proxy_packet.protocol)); + packet.Write(proxy_packet.broadcast); + packet.Write(proxy_packet.data); + room_member_impl->Send(std::move(packet)); } @@ -645,8 +656,8 @@ RoomMember::CallbackHandle RoomMember::BindOnError( return room_member_impl->Bind(callback); } -RoomMember::CallbackHandle RoomMember::BindOnWifiPacketReceived( - std::function callback) { +RoomMember::CallbackHandle RoomMember::BindOnProxyPacketReceived( + std::function callback) { return room_member_impl->Bind(callback); } @@ -685,7 +696,7 @@ void RoomMember::Leave() { room_member_impl->client = nullptr; } -template void RoomMember::Unbind(CallbackHandle); +template void RoomMember::Unbind(CallbackHandle); template void RoomMember::Unbind(CallbackHandle); template void RoomMember::Unbind(CallbackHandle); template void RoomMember::Unbind(CallbackHandle); diff --git a/src/network/room_member.h b/src/network/room_member.h index bbb7d13d4..4252b7146 100644 --- a/src/network/room_member.h +++ b/src/network/room_member.h @@ -9,6 +9,7 @@ #include #include "common/announce_multiplayer_room.h" #include "common/common_types.h" +#include "common/socket_types.h" #include "network/room.h" namespace Network { @@ -17,22 +18,12 @@ using AnnounceMultiplayerRoom::GameInfo; using AnnounceMultiplayerRoom::RoomInformation; /// Information about the received WiFi packets. -/// Acts as our own 802.11 header. -struct WifiPacket { - enum class PacketType : u8 { - Beacon, - Data, - Authentication, - AssociationResponse, - Deauthentication, - NodeMap - }; - PacketType type; ///< The type of 802.11 frame. - std::vector 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. +struct ProxyPacket { + SockAddrIn local_endpoint; + SockAddrIn remote_endpoint; + Protocol protocol; + bool broadcast; + std::vector data; }; /// Represents a chat message. @@ -72,15 +63,14 @@ public: HostKicked, ///< Kicked by the host // Reasons why connection was rejected - UnknownError, ///< Some error [permissions to network device missing or something] - NameCollision, ///< Somebody is already using this name - MacCollision, ///< Somebody is already using that mac-address - ConsoleIdCollision, ///< Somebody in the room has the same Console ID - WrongVersion, ///< The room version is not the same as for this RoomMember - WrongPassword, ///< The password doesn't match the one from the Room - CouldNotConnect, ///< The room is not responding to a connection attempt - RoomIsFull, ///< Room is already at the maximum number of players - HostBanned, ///< The user is banned by the host + UnknownError, ///< Some error [permissions to network device missing or something] + NameCollision, ///< Somebody is already using this name + IpCollision, ///< Somebody is already using that fake-ip-address + WrongVersion, ///< The room version is not the same as for this RoomMember + WrongPassword, ///< The password doesn't match the one from the Room + CouldNotConnect, ///< The room is not responding to a connection attempt + RoomIsFull, ///< Room is already at the maximum number of players + HostBanned, ///< The user is banned by the host // Reasons why moderation request failed PermissionDenied, ///< The user does not have mod permissions @@ -92,9 +82,9 @@ public: std::string username; ///< The web services username of the member. Can be empty. std::string display_name; ///< The web services display name of the member. Can be empty. std::string avatar_url; ///< Url to the member's avatar. Can be empty. - GameInfo game_info; ///< 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. + GameInfo game_info; ///< Name of the game they're currently playing, or empty if they're + /// not playing anything. + IPv4Address fake_ip; ///< Fake Ip address associated with this member. }; using MemberList = std::vector; @@ -135,7 +125,7 @@ public: /** * Returns the MAC address of the RoomMember. */ - const MacAddress& GetMacAddress() const; + const IPv4Address& GetFakeIpAddress() const; /** * Returns information about the room we're currently connected to. @@ -149,19 +139,17 @@ public: /** * Attempts to join a room at the specified address and port, using the specified nickname. - * A console ID hash is passed in to check console ID conflicts. - * This may fail if the username or console ID is already taken. */ - void Join(const std::string& nickname, const std::string& console_id_hash, - const char* server_addr = "127.0.0.1", u16 server_port = DefaultRoomPort, - u16 client_port = 0, const MacAddress& preferred_mac = NoPreferredMac, + void Join(const std::string& nickname, const char* server_addr = "127.0.0.1", + u16 server_port = DefaultRoomPort, u16 client_port = 0, + const IPv4Address& preferred_fake_ip = NoPreferredIP, const std::string& password = "", const std::string& token = ""); /** * Sends a WiFi packet to the room. * @param packet The WiFi packet to send. */ - void SendWifiPacket(const WifiPacket& packet); + void SendProxyPacket(const ProxyPacket& packet); /** * Sends a chat message to the room. @@ -207,14 +195,14 @@ public: CallbackHandle BindOnError(std::function callback); /** - * Binds a function to an event that will be triggered every time a WifiPacket is received. + * Binds a function to an event that will be triggered every time a ProxyPacket is received. * The function wil be called everytime the event is triggered. * The callback function must not bind or unbind a function. Doing so will cause a deadlock * @param callback The function to call * @return A handle used for removing the function from the registered list */ - CallbackHandle BindOnWifiPacketReceived( - std::function callback); + CallbackHandle BindOnProxyPacketReceived( + std::function callback); /** * Binds a function to an event that will be triggered every time the RoomInformation changes. @@ -292,10 +280,8 @@ inline const char* GetErrorStr(const RoomMember::Error& e) { return "UnknownError"; case RoomMember::Error::NameCollision: return "NameCollision"; - case RoomMember::Error::MacCollision: - return "MaxCollision"; - case RoomMember::Error::ConsoleIdCollision: - return "ConsoleIdCollision"; + case RoomMember::Error::IpCollision: + return "IpCollision"; case RoomMember::Error::WrongVersion: return "WrongVersion"; case RoomMember::Error::WrongPassword: -- cgit v1.2.3