summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGravatar FearlessTobi2022-07-25 19:16:59 +0200
committerGravatar FearlessTobi2022-07-25 21:59:31 +0200
commita41baaa181f30229d3552caa69135be978c1ddb5 (patch)
tree999411f1ca76390654d1034c6d0bd2c47c3f101c
parentnetwork, yuzu: Make copyright headers SPDX-compliant (diff)
downloadyuzu-a41baaa181f30229d3552caa69135be978c1ddb5.tar.gz
yuzu-a41baaa181f30229d3552caa69135be978c1ddb5.tar.xz
yuzu-a41baaa181f30229d3552caa69135be978c1ddb5.zip
network: Address review comments
Diffstat
-rw-r--r--src/network/packet.cpp64
-rw-r--r--src/network/packet.h86
-rw-r--r--src/network/room.cpp142
-rw-r--r--src/network/room_member.cpp98
-rw-r--r--src/yuzu/multiplayer/state.cpp12
5 files changed, 203 insertions, 199 deletions
diff --git a/src/network/packet.cpp b/src/network/packet.cpp
index d6c8dc646..0e22f1eb4 100644
--- a/src/network/packet.cpp
+++ b/src/network/packet.cpp
@@ -65,80 +65,80 @@ Packet::operator bool() const {
65 return is_valid; 65 return is_valid;
66} 66}
67 67
68Packet& Packet::operator>>(bool& out_data) { 68Packet& Packet::Read(bool& out_data) {
69 u8 value{}; 69 u8 value{};
70 if (*this >> value) { 70 if (Read(value)) {
71 out_data = (value != 0); 71 out_data = (value != 0);
72 } 72 }
73 return *this; 73 return *this;
74} 74}
75 75
76Packet& Packet::operator>>(s8& out_data) { 76Packet& Packet::Read(s8& out_data) {
77 Read(&out_data, sizeof(out_data)); 77 Read(&out_data, sizeof(out_data));
78 return *this; 78 return *this;
79} 79}
80 80
81Packet& Packet::operator>>(u8& out_data) { 81Packet& Packet::Read(u8& out_data) {
82 Read(&out_data, sizeof(out_data)); 82 Read(&out_data, sizeof(out_data));
83 return *this; 83 return *this;
84} 84}
85 85
86Packet& Packet::operator>>(s16& out_data) { 86Packet& Packet::Read(s16& out_data) {
87 s16 value{}; 87 s16 value{};
88 Read(&value, sizeof(value)); 88 Read(&value, sizeof(value));
89 out_data = ntohs(value); 89 out_data = ntohs(value);
90 return *this; 90 return *this;
91} 91}
92 92
93Packet& Packet::operator>>(u16& out_data) { 93Packet& Packet::Read(u16& out_data) {
94 u16 value{}; 94 u16 value{};
95 Read(&value, sizeof(value)); 95 Read(&value, sizeof(value));
96 out_data = ntohs(value); 96 out_data = ntohs(value);
97 return *this; 97 return *this;
98} 98}
99 99
100Packet& Packet::operator>>(s32& out_data) { 100Packet& Packet::Read(s32& out_data) {
101 s32 value{}; 101 s32 value{};
102 Read(&value, sizeof(value)); 102 Read(&value, sizeof(value));
103 out_data = ntohl(value); 103 out_data = ntohl(value);
104 return *this; 104 return *this;
105} 105}
106 106
107Packet& Packet::operator>>(u32& out_data) { 107Packet& Packet::Read(u32& out_data) {
108 u32 value{}; 108 u32 value{};
109 Read(&value, sizeof(value)); 109 Read(&value, sizeof(value));
110 out_data = ntohl(value); 110 out_data = ntohl(value);
111 return *this; 111 return *this;
112} 112}
113 113
114Packet& Packet::operator>>(s64& out_data) { 114Packet& Packet::Read(s64& out_data) {
115 s64 value{}; 115 s64 value{};
116 Read(&value, sizeof(value)); 116 Read(&value, sizeof(value));
117 out_data = ntohll(value); 117 out_data = ntohll(value);
118 return *this; 118 return *this;
119} 119}
120 120
121Packet& Packet::operator>>(u64& out_data) { 121Packet& Packet::Read(u64& out_data) {
122 u64 value{}; 122 u64 value{};
123 Read(&value, sizeof(value)); 123 Read(&value, sizeof(value));
124 out_data = ntohll(value); 124 out_data = ntohll(value);
125 return *this; 125 return *this;
126} 126}
127 127
128Packet& Packet::operator>>(float& out_data) { 128Packet& Packet::Read(float& out_data) {
129 Read(&out_data, sizeof(out_data)); 129 Read(&out_data, sizeof(out_data));
130 return *this; 130 return *this;
131} 131}
132 132
133Packet& Packet::operator>>(double& out_data) { 133Packet& Packet::Read(double& out_data) {
134 Read(&out_data, sizeof(out_data)); 134 Read(&out_data, sizeof(out_data));
135 return *this; 135 return *this;
136} 136}
137 137
138Packet& Packet::operator>>(char* out_data) { 138Packet& Packet::Read(char* out_data) {
139 // First extract string length 139 // First extract string length
140 u32 length = 0; 140 u32 length = 0;
141 *this >> length; 141 Read(length);
142 142
143 if ((length > 0) && CheckSize(length)) { 143 if ((length > 0) && CheckSize(length)) {
144 // Then extract characters 144 // Then extract characters
@@ -152,10 +152,10 @@ Packet& Packet::operator>>(char* out_data) {
152 return *this; 152 return *this;
153} 153}
154 154
155Packet& Packet::operator>>(std::string& out_data) { 155Packet& Packet::Read(std::string& out_data) {
156 // First extract string length 156 // First extract string length
157 u32 length = 0; 157 u32 length = 0;
158 *this >> length; 158 Read(length);
159 159
160 out_data.clear(); 160 out_data.clear();
161 if ((length > 0) && CheckSize(length)) { 161 if ((length > 0) && CheckSize(length)) {
@@ -169,71 +169,71 @@ Packet& Packet::operator>>(std::string& out_data) {
169 return *this; 169 return *this;
170} 170}
171 171
172Packet& Packet::operator<<(bool in_data) { 172Packet& Packet::Write(bool in_data) {
173 *this << static_cast<u8>(in_data); 173 Write(static_cast<u8>(in_data));
174 return *this; 174 return *this;
175} 175}
176 176
177Packet& Packet::operator<<(s8 in_data) { 177Packet& Packet::Write(s8 in_data) {
178 Append(&in_data, sizeof(in_data)); 178 Append(&in_data, sizeof(in_data));
179 return *this; 179 return *this;
180} 180}
181 181
182Packet& Packet::operator<<(u8 in_data) { 182Packet& Packet::Write(u8 in_data) {
183 Append(&in_data, sizeof(in_data)); 183 Append(&in_data, sizeof(in_data));
184 return *this; 184 return *this;
185} 185}
186 186
187Packet& Packet::operator<<(s16 in_data) { 187Packet& Packet::Write(s16 in_data) {
188 s16 toWrite = htons(in_data); 188 s16 toWrite = htons(in_data);
189 Append(&toWrite, sizeof(toWrite)); 189 Append(&toWrite, sizeof(toWrite));
190 return *this; 190 return *this;
191} 191}
192 192
193Packet& Packet::operator<<(u16 in_data) { 193Packet& Packet::Write(u16 in_data) {
194 u16 toWrite = htons(in_data); 194 u16 toWrite = htons(in_data);
195 Append(&toWrite, sizeof(toWrite)); 195 Append(&toWrite, sizeof(toWrite));
196 return *this; 196 return *this;
197} 197}
198 198
199Packet& Packet::operator<<(s32 in_data) { 199Packet& Packet::Write(s32 in_data) {
200 s32 toWrite = htonl(in_data); 200 s32 toWrite = htonl(in_data);
201 Append(&toWrite, sizeof(toWrite)); 201 Append(&toWrite, sizeof(toWrite));
202 return *this; 202 return *this;
203} 203}
204 204
205Packet& Packet::operator<<(u32 in_data) { 205Packet& Packet::Write(u32 in_data) {
206 u32 toWrite = htonl(in_data); 206 u32 toWrite = htonl(in_data);
207 Append(&toWrite, sizeof(toWrite)); 207 Append(&toWrite, sizeof(toWrite));
208 return *this; 208 return *this;
209} 209}
210 210
211Packet& Packet::operator<<(s64 in_data) { 211Packet& Packet::Write(s64 in_data) {
212 s64 toWrite = htonll(in_data); 212 s64 toWrite = htonll(in_data);
213 Append(&toWrite, sizeof(toWrite)); 213 Append(&toWrite, sizeof(toWrite));
214 return *this; 214 return *this;
215} 215}
216 216
217Packet& Packet::operator<<(u64 in_data) { 217Packet& Packet::Write(u64 in_data) {
218 u64 toWrite = htonll(in_data); 218 u64 toWrite = htonll(in_data);
219 Append(&toWrite, sizeof(toWrite)); 219 Append(&toWrite, sizeof(toWrite));
220 return *this; 220 return *this;
221} 221}
222 222
223Packet& Packet::operator<<(float in_data) { 223Packet& Packet::Write(float in_data) {
224 Append(&in_data, sizeof(in_data)); 224 Append(&in_data, sizeof(in_data));
225 return *this; 225 return *this;
226} 226}
227 227
228Packet& Packet::operator<<(double in_data) { 228Packet& Packet::Write(double in_data) {
229 Append(&in_data, sizeof(in_data)); 229 Append(&in_data, sizeof(in_data));
230 return *this; 230 return *this;
231} 231}
232 232
233Packet& Packet::operator<<(const char* in_data) { 233Packet& Packet::Write(const char* in_data) {
234 // First insert string length 234 // First insert string length
235 u32 length = static_cast<u32>(std::strlen(in_data)); 235 u32 length = static_cast<u32>(std::strlen(in_data));
236 *this << length; 236 Write(length);
237 237
238 // Then insert characters 238 // Then insert characters
239 Append(in_data, length * sizeof(char)); 239 Append(in_data, length * sizeof(char));
@@ -241,10 +241,10 @@ Packet& Packet::operator<<(const char* in_data) {
241 return *this; 241 return *this;
242} 242}
243 243
244Packet& Packet::operator<<(const std::string& in_data) { 244Packet& Packet::Write(const std::string& in_data) {
245 // First insert string length 245 // First insert string length
246 u32 length = static_cast<u32>(in_data.size()); 246 u32 length = static_cast<u32>(in_data.size());
247 *this << length; 247 Write(length);
248 248
249 // Then insert characters 249 // Then insert characters
250 if (length > 0) 250 if (length > 0)
diff --git a/src/network/packet.h b/src/network/packet.h
index aa9fa39e2..e69217488 100644
--- a/src/network/packet.h
+++ b/src/network/packet.h
@@ -63,43 +63,43 @@ public:
63 63
64 explicit operator bool() const; 64 explicit operator bool() const;
65 65
66 /// Overloads of operator >> to read data from the packet 66 /// Overloads of read function to read data from the packet
67 Packet& operator>>(bool& out_data); 67 Packet& Read(bool& out_data);
68 Packet& operator>>(s8& out_data); 68 Packet& Read(s8& out_data);
69 Packet& operator>>(u8& out_data); 69 Packet& Read(u8& out_data);
70 Packet& operator>>(s16& out_data); 70 Packet& Read(s16& out_data);
71 Packet& operator>>(u16& out_data); 71 Packet& Read(u16& out_data);
72 Packet& operator>>(s32& out_data); 72 Packet& Read(s32& out_data);
73 Packet& operator>>(u32& out_data); 73 Packet& Read(u32& out_data);
74 Packet& operator>>(s64& out_data); 74 Packet& Read(s64& out_data);
75 Packet& operator>>(u64& out_data); 75 Packet& Read(u64& out_data);
76 Packet& operator>>(float& out_data); 76 Packet& Read(float& out_data);
77 Packet& operator>>(double& out_data); 77 Packet& Read(double& out_data);
78 Packet& operator>>(char* out_data); 78 Packet& Read(char* out_data);
79 Packet& operator>>(std::string& out_data); 79 Packet& Read(std::string& out_data);
80 template <typename T> 80 template <typename T>
81 Packet& operator>>(std::vector<T>& out_data); 81 Packet& Read(std::vector<T>& out_data);
82 template <typename T, std::size_t S> 82 template <typename T, std::size_t S>
83 Packet& operator>>(std::array<T, S>& out_data); 83 Packet& Read(std::array<T, S>& out_data);
84 84
85 /// Overloads of operator << to write data into the packet 85 /// Overloads of write function to write data into the packet
86 Packet& operator<<(bool in_data); 86 Packet& Write(bool in_data);
87 Packet& operator<<(s8 in_data); 87 Packet& Write(s8 in_data);
88 Packet& operator<<(u8 in_data); 88 Packet& Write(u8 in_data);
89 Packet& operator<<(s16 in_data); 89 Packet& Write(s16 in_data);
90 Packet& operator<<(u16 in_data); 90 Packet& Write(u16 in_data);
91 Packet& operator<<(s32 in_data); 91 Packet& Write(s32 in_data);
92 Packet& operator<<(u32 in_data); 92 Packet& Write(u32 in_data);
93 Packet& operator<<(s64 in_data); 93 Packet& Write(s64 in_data);
94 Packet& operator<<(u64 in_data); 94 Packet& Write(u64 in_data);
95 Packet& operator<<(float in_data); 95 Packet& Write(float in_data);
96 Packet& operator<<(double in_data); 96 Packet& Write(double in_data);
97 Packet& operator<<(const char* in_data); 97 Packet& Write(const char* in_data);
98 Packet& operator<<(const std::string& in_data); 98 Packet& Write(const std::string& in_data);
99 template <typename T> 99 template <typename T>
100 Packet& operator<<(const std::vector<T>& in_data); 100 Packet& Write(const std::vector<T>& in_data);
101 template <typename T, std::size_t S> 101 template <typename T, std::size_t S>
102 Packet& operator<<(const std::array<T, S>& data); 102 Packet& Write(const std::array<T, S>& data);
103 103
104private: 104private:
105 /** 105 /**
@@ -117,47 +117,47 @@ private:
117}; 117};
118 118
119template <typename T> 119template <typename T>
120Packet& Packet::operator>>(std::vector<T>& out_data) { 120Packet& Packet::Read(std::vector<T>& out_data) {
121 // First extract the size 121 // First extract the size
122 u32 size = 0; 122 u32 size = 0;
123 *this >> size; 123 Read(size);
124 out_data.resize(size); 124 out_data.resize(size);
125 125
126 // Then extract the data 126 // Then extract the data
127 for (std::size_t i = 0; i < out_data.size(); ++i) { 127 for (std::size_t i = 0; i < out_data.size(); ++i) {
128 T character; 128 T character;
129 *this >> character; 129 Read(character);
130 out_data[i] = character; 130 out_data[i] = character;
131 } 131 }
132 return *this; 132 return *this;
133} 133}
134 134
135template <typename T, std::size_t S> 135template <typename T, std::size_t S>
136Packet& Packet::operator>>(std::array<T, S>& out_data) { 136Packet& Packet::Read(std::array<T, S>& out_data) {
137 for (std::size_t i = 0; i < out_data.size(); ++i) { 137 for (std::size_t i = 0; i < out_data.size(); ++i) {
138 T character; 138 T character;
139 *this >> character; 139 Read(character);
140 out_data[i] = character; 140 out_data[i] = character;
141 } 141 }
142 return *this; 142 return *this;
143} 143}
144 144
145template <typename T> 145template <typename T>
146Packet& Packet::operator<<(const std::vector<T>& in_data) { 146Packet& Packet::Write(const std::vector<T>& in_data) {
147 // First insert the size 147 // First insert the size
148 *this << static_cast<u32>(in_data.size()); 148 Write(static_cast<u32>(in_data.size()));
149 149
150 // Then insert the data 150 // Then insert the data
151 for (std::size_t i = 0; i < in_data.size(); ++i) { 151 for (std::size_t i = 0; i < in_data.size(); ++i) {
152 *this << in_data[i]; 152 Write(in_data[i]);
153 } 153 }
154 return *this; 154 return *this;
155} 155}
156 156
157template <typename T, std::size_t S> 157template <typename T, std::size_t S>
158Packet& Packet::operator<<(const std::array<T, S>& in_data) { 158Packet& Packet::Write(const std::array<T, S>& in_data) {
159 for (std::size_t i = 0; i < in_data.size(); ++i) { 159 for (std::size_t i = 0; i < in_data.size(); ++i) {
160 *this << in_data[i]; 160 Write(in_data[i]);
161 } 161 }
162 return *this; 162 return *this;
163} 163}
diff --git a/src/network/room.cpp b/src/network/room.cpp
index d5f0bb723..3fc3a0383 100644
--- a/src/network/room.cpp
+++ b/src/network/room.cpp
@@ -7,6 +7,7 @@
7#include <mutex> 7#include <mutex>
8#include <random> 8#include <random>
9#include <regex> 9#include <regex>
10#include <shared_mutex>
10#include <sstream> 11#include <sstream>
11#include <thread> 12#include <thread>
12#include "common/logging/log.h" 13#include "common/logging/log.h"
@@ -43,9 +44,8 @@ public:
43 ENetPeer* peer; ///< The remote peer. 44 ENetPeer* peer; ///< The remote peer.
44 }; 45 };
45 using MemberList = std::vector<Member>; 46 using MemberList = std::vector<Member>;
46 MemberList members; ///< Information about the members of this room 47 MemberList members; ///< Information about the members of this room
47 mutable std::mutex member_mutex; ///< Mutex for locking the members list 48 mutable std::shared_mutex member_mutex; ///< Mutex for locking the members list
48 /// This should be a std::shared_mutex as soon as C++17 is supported
49 49
50 UsernameBanList username_ban_list; ///< List of banned usernames 50 UsernameBanList username_ban_list; ///< List of banned usernames
51 IPBanList ip_ban_list; ///< List of banned IP addresses 51 IPBanList ip_ban_list; ///< List of banned IP addresses
@@ -311,22 +311,22 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
311 packet.Append(event->packet->data, event->packet->dataLength); 311 packet.Append(event->packet->data, event->packet->dataLength);
312 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 312 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
313 std::string nickname; 313 std::string nickname;
314 packet >> nickname; 314 packet.Read(nickname);
315 315
316 std::string console_id_hash; 316 std::string console_id_hash;
317 packet >> console_id_hash; 317 packet.Read(console_id_hash);
318 318
319 MacAddress preferred_mac; 319 MacAddress preferred_mac;
320 packet >> preferred_mac; 320 packet.Read(preferred_mac);
321 321
322 u32 client_version; 322 u32 client_version;
323 packet >> client_version; 323 packet.Read(client_version);
324 324
325 std::string pass; 325 std::string pass;
326 packet >> pass; 326 packet.Read(pass);
327 327
328 std::string token; 328 std::string token;
329 packet >> token; 329 packet.Read(token);
330 330
331 if (pass != password) { 331 if (pass != password) {
332 SendWrongPassword(event->peer); 332 SendWrongPassword(event->peer);
@@ -387,9 +387,9 @@ void Room::RoomImpl::HandleJoinRequest(const ENetEvent* event) {
387 } 387 }
388 388
389 // Check IP ban 389 // Check IP ban
390 char ip_raw[256]; 390 std::array<char, 256> ip_raw{};
391 enet_address_get_host_ip(&event->peer->address, ip_raw, sizeof(ip_raw) - 1); 391 enet_address_get_host_ip(&event->peer->address, ip_raw.data(), sizeof(ip_raw) - 1);
392 ip = ip_raw; 392 ip = ip_raw.data();
393 393
394 if (std::find(ip_ban_list.begin(), ip_ban_list.end(), ip) != ip_ban_list.end()) { 394 if (std::find(ip_ban_list.begin(), ip_ban_list.end(), ip) != ip_ban_list.end()) {
395 SendUserBanned(event->peer); 395 SendUserBanned(event->peer);
@@ -425,7 +425,7 @@ void Room::RoomImpl::HandleModKickPacket(const ENetEvent* event) {
425 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 425 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
426 426
427 std::string nickname; 427 std::string nickname;
428 packet >> nickname; 428 packet.Read(nickname);
429 429
430 std::string username, ip; 430 std::string username, ip;
431 { 431 {
@@ -443,9 +443,9 @@ void Room::RoomImpl::HandleModKickPacket(const ENetEvent* event) {
443 443
444 username = target_member->user_data.username; 444 username = target_member->user_data.username;
445 445
446 char ip_raw[256]; 446 std::array<char, 256> ip_raw{};
447 enet_address_get_host_ip(&target_member->peer->address, ip_raw, sizeof(ip_raw) - 1); 447 enet_address_get_host_ip(&target_member->peer->address, ip_raw.data(), sizeof(ip_raw) - 1);
448 ip = ip_raw; 448 ip = ip_raw.data();
449 449
450 enet_peer_disconnect(target_member->peer, 0); 450 enet_peer_disconnect(target_member->peer, 0);
451 members.erase(target_member); 451 members.erase(target_member);
@@ -467,7 +467,7 @@ void Room::RoomImpl::HandleModBanPacket(const ENetEvent* event) {
467 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 467 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
468 468
469 std::string nickname; 469 std::string nickname;
470 packet >> nickname; 470 packet.Read(nickname);
471 471
472 std::string username, ip; 472 std::string username, ip;
473 { 473 {
@@ -486,9 +486,9 @@ void Room::RoomImpl::HandleModBanPacket(const ENetEvent* event) {
486 nickname = target_member->nickname; 486 nickname = target_member->nickname;
487 username = target_member->user_data.username; 487 username = target_member->user_data.username;
488 488
489 char ip_raw[256]; 489 std::array<char, 256> ip_raw{};
490 enet_address_get_host_ip(&target_member->peer->address, ip_raw, sizeof(ip_raw) - 1); 490 enet_address_get_host_ip(&target_member->peer->address, ip_raw.data(), sizeof(ip_raw) - 1);
491 ip = ip_raw; 491 ip = ip_raw.data();
492 492
493 enet_peer_disconnect(target_member->peer, 0); 493 enet_peer_disconnect(target_member->peer, 0);
494 members.erase(target_member); 494 members.erase(target_member);
@@ -528,7 +528,7 @@ void Room::RoomImpl::HandleModUnbanPacket(const ENetEvent* event) {
528 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 528 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
529 529
530 std::string address; 530 std::string address;
531 packet >> address; 531 packet.Read(address);
532 532
533 bool unbanned = false; 533 bool unbanned = false;
534 { 534 {
@@ -613,7 +613,7 @@ bool Room::RoomImpl::HasModPermission(const ENetPeer* client) const {
613 613
614void Room::RoomImpl::SendNameCollision(ENetPeer* client) { 614void Room::RoomImpl::SendNameCollision(ENetPeer* client) {
615 Packet packet; 615 Packet packet;
616 packet << static_cast<u8>(IdNameCollision); 616 packet.Write(static_cast<u8>(IdNameCollision));
617 617
618 ENetPacket* enet_packet = 618 ENetPacket* enet_packet =
619 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 619 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -623,7 +623,7 @@ void Room::RoomImpl::SendNameCollision(ENetPeer* client) {
623 623
624void Room::RoomImpl::SendMacCollision(ENetPeer* client) { 624void Room::RoomImpl::SendMacCollision(ENetPeer* client) {
625 Packet packet; 625 Packet packet;
626 packet << static_cast<u8>(IdMacCollision); 626 packet.Write(static_cast<u8>(IdMacCollision));
627 627
628 ENetPacket* enet_packet = 628 ENetPacket* enet_packet =
629 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 629 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -633,7 +633,7 @@ void Room::RoomImpl::SendMacCollision(ENetPeer* client) {
633 633
634void Room::RoomImpl::SendConsoleIdCollision(ENetPeer* client) { 634void Room::RoomImpl::SendConsoleIdCollision(ENetPeer* client) {
635 Packet packet; 635 Packet packet;
636 packet << static_cast<u8>(IdConsoleIdCollision); 636 packet.Write(static_cast<u8>(IdConsoleIdCollision));
637 637
638 ENetPacket* enet_packet = 638 ENetPacket* enet_packet =
639 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 639 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -643,7 +643,7 @@ void Room::RoomImpl::SendConsoleIdCollision(ENetPeer* client) {
643 643
644void Room::RoomImpl::SendWrongPassword(ENetPeer* client) { 644void Room::RoomImpl::SendWrongPassword(ENetPeer* client) {
645 Packet packet; 645 Packet packet;
646 packet << static_cast<u8>(IdWrongPassword); 646 packet.Write(static_cast<u8>(IdWrongPassword));
647 647
648 ENetPacket* enet_packet = 648 ENetPacket* enet_packet =
649 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 649 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -653,7 +653,7 @@ void Room::RoomImpl::SendWrongPassword(ENetPeer* client) {
653 653
654void Room::RoomImpl::SendRoomIsFull(ENetPeer* client) { 654void Room::RoomImpl::SendRoomIsFull(ENetPeer* client) {
655 Packet packet; 655 Packet packet;
656 packet << static_cast<u8>(IdRoomIsFull); 656 packet.Write(static_cast<u8>(IdRoomIsFull));
657 657
658 ENetPacket* enet_packet = 658 ENetPacket* enet_packet =
659 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 659 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -663,8 +663,8 @@ void Room::RoomImpl::SendRoomIsFull(ENetPeer* client) {
663 663
664void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) { 664void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) {
665 Packet packet; 665 Packet packet;
666 packet << static_cast<u8>(IdVersionMismatch); 666 packet.Write(static_cast<u8>(IdVersionMismatch));
667 packet << network_version; 667 packet.Write(network_version);
668 668
669 ENetPacket* enet_packet = 669 ENetPacket* enet_packet =
670 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 670 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -674,8 +674,8 @@ void Room::RoomImpl::SendVersionMismatch(ENetPeer* client) {
674 674
675void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) { 675void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) {
676 Packet packet; 676 Packet packet;
677 packet << static_cast<u8>(IdJoinSuccess); 677 packet.Write(static_cast<u8>(IdJoinSuccess));
678 packet << mac_address; 678 packet.Write(mac_address);
679 ENetPacket* enet_packet = 679 ENetPacket* enet_packet =
680 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 680 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
681 enet_peer_send(client, 0, enet_packet); 681 enet_peer_send(client, 0, enet_packet);
@@ -684,8 +684,8 @@ void Room::RoomImpl::SendJoinSuccess(ENetPeer* client, MacAddress mac_address) {
684 684
685void Room::RoomImpl::SendJoinSuccessAsMod(ENetPeer* client, MacAddress mac_address) { 685void Room::RoomImpl::SendJoinSuccessAsMod(ENetPeer* client, MacAddress mac_address) {
686 Packet packet; 686 Packet packet;
687 packet << static_cast<u8>(IdJoinSuccessAsMod); 687 packet.Write(static_cast<u8>(IdJoinSuccessAsMod));
688 packet << mac_address; 688 packet.Write(mac_address);
689 ENetPacket* enet_packet = 689 ENetPacket* enet_packet =
690 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 690 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
691 enet_peer_send(client, 0, enet_packet); 691 enet_peer_send(client, 0, enet_packet);
@@ -694,7 +694,7 @@ void Room::RoomImpl::SendJoinSuccessAsMod(ENetPeer* client, MacAddress mac_addre
694 694
695void Room::RoomImpl::SendUserKicked(ENetPeer* client) { 695void Room::RoomImpl::SendUserKicked(ENetPeer* client) {
696 Packet packet; 696 Packet packet;
697 packet << static_cast<u8>(IdHostKicked); 697 packet.Write(static_cast<u8>(IdHostKicked));
698 698
699 ENetPacket* enet_packet = 699 ENetPacket* enet_packet =
700 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 700 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -704,7 +704,7 @@ void Room::RoomImpl::SendUserKicked(ENetPeer* client) {
704 704
705void Room::RoomImpl::SendUserBanned(ENetPeer* client) { 705void Room::RoomImpl::SendUserBanned(ENetPeer* client) {
706 Packet packet; 706 Packet packet;
707 packet << static_cast<u8>(IdHostBanned); 707 packet.Write(static_cast<u8>(IdHostBanned));
708 708
709 ENetPacket* enet_packet = 709 ENetPacket* enet_packet =
710 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 710 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -714,7 +714,7 @@ void Room::RoomImpl::SendUserBanned(ENetPeer* client) {
714 714
715void Room::RoomImpl::SendModPermissionDenied(ENetPeer* client) { 715void Room::RoomImpl::SendModPermissionDenied(ENetPeer* client) {
716 Packet packet; 716 Packet packet;
717 packet << static_cast<u8>(IdModPermissionDenied); 717 packet.Write(static_cast<u8>(IdModPermissionDenied));
718 718
719 ENetPacket* enet_packet = 719 ENetPacket* enet_packet =
720 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 720 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -724,7 +724,7 @@ void Room::RoomImpl::SendModPermissionDenied(ENetPeer* client) {
724 724
725void Room::RoomImpl::SendModNoSuchUser(ENetPeer* client) { 725void Room::RoomImpl::SendModNoSuchUser(ENetPeer* client) {
726 Packet packet; 726 Packet packet;
727 packet << static_cast<u8>(IdModNoSuchUser); 727 packet.Write(static_cast<u8>(IdModNoSuchUser));
728 728
729 ENetPacket* enet_packet = 729 ENetPacket* enet_packet =
730 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE); 730 enet_packet_create(packet.GetData(), packet.GetDataSize(), ENET_PACKET_FLAG_RELIABLE);
@@ -734,11 +734,11 @@ void Room::RoomImpl::SendModNoSuchUser(ENetPeer* client) {
734 734
735void Room::RoomImpl::SendModBanListResponse(ENetPeer* client) { 735void Room::RoomImpl::SendModBanListResponse(ENetPeer* client) {
736 Packet packet; 736 Packet packet;
737 packet << static_cast<u8>(IdModBanListResponse); 737 packet.Write(static_cast<u8>(IdModBanListResponse));
738 { 738 {
739 std::lock_guard lock(ban_list_mutex); 739 std::lock_guard lock(ban_list_mutex);
740 packet << username_ban_list; 740 packet.Write(username_ban_list);
741 packet << ip_ban_list; 741 packet.Write(ip_ban_list);
742 } 742 }
743 743
744 ENetPacket* enet_packet = 744 ENetPacket* enet_packet =
@@ -749,7 +749,7 @@ void Room::RoomImpl::SendModBanListResponse(ENetPeer* client) {
749 749
750void Room::RoomImpl::SendCloseMessage() { 750void Room::RoomImpl::SendCloseMessage() {
751 Packet packet; 751 Packet packet;
752 packet << static_cast<u8>(IdCloseRoom); 752 packet.Write(static_cast<u8>(IdCloseRoom));
753 std::lock_guard lock(member_mutex); 753 std::lock_guard lock(member_mutex);
754 if (!members.empty()) { 754 if (!members.empty()) {
755 ENetPacket* enet_packet = 755 ENetPacket* enet_packet =
@@ -767,10 +767,10 @@ void Room::RoomImpl::SendCloseMessage() {
767void Room::RoomImpl::SendStatusMessage(StatusMessageTypes type, const std::string& nickname, 767void Room::RoomImpl::SendStatusMessage(StatusMessageTypes type, const std::string& nickname,
768 const std::string& username, const std::string& ip) { 768 const std::string& username, const std::string& ip) {
769 Packet packet; 769 Packet packet;
770 packet << static_cast<u8>(IdStatusMessage); 770 packet.Write(static_cast<u8>(IdStatusMessage));
771 packet << static_cast<u8>(type); 771 packet.Write(static_cast<u8>(type));
772 packet << nickname; 772 packet.Write(nickname);
773 packet << username; 773 packet.Write(username);
774 std::lock_guard lock(member_mutex); 774 std::lock_guard lock(member_mutex);
775 if (!members.empty()) { 775 if (!members.empty()) {
776 ENetPacket* enet_packet = 776 ENetPacket* enet_packet =
@@ -805,25 +805,25 @@ void Room::RoomImpl::SendStatusMessage(StatusMessageTypes type, const std::strin
805 805
806void Room::RoomImpl::BroadcastRoomInformation() { 806void Room::RoomImpl::BroadcastRoomInformation() {
807 Packet packet; 807 Packet packet;
808 packet << static_cast<u8>(IdRoomInformation); 808 packet.Write(static_cast<u8>(IdRoomInformation));
809 packet << room_information.name; 809 packet.Write(room_information.name);
810 packet << room_information.description; 810 packet.Write(room_information.description);
811 packet << room_information.member_slots; 811 packet.Write(room_information.member_slots);
812 packet << room_information.port; 812 packet.Write(room_information.port);
813 packet << room_information.preferred_game.name; 813 packet.Write(room_information.preferred_game.name);
814 packet << room_information.host_username; 814 packet.Write(room_information.host_username);
815 815
816 packet << static_cast<u32>(members.size()); 816 packet.Write(static_cast<u32>(members.size()));
817 { 817 {
818 std::lock_guard lock(member_mutex); 818 std::lock_guard lock(member_mutex);
819 for (const auto& member : members) { 819 for (const auto& member : members) {
820 packet << member.nickname; 820 packet.Write(member.nickname);
821 packet << member.mac_address; 821 packet.Write(member.mac_address);
822 packet << member.game_info.name; 822 packet.Write(member.game_info.name);
823 packet << member.game_info.id; 823 packet.Write(member.game_info.id);
824 packet << member.user_data.username; 824 packet.Write(member.user_data.username);
825 packet << member.user_data.display_name; 825 packet.Write(member.user_data.display_name);
826 packet << member.user_data.avatar_url; 826 packet.Write(member.user_data.avatar_url);
827 } 827 }
828 } 828 }
829 829
@@ -853,7 +853,7 @@ void Room::RoomImpl::HandleWifiPacket(const ENetEvent* event) {
853 in_packet.IgnoreBytes(sizeof(u8)); // WifiPacket Channel 853 in_packet.IgnoreBytes(sizeof(u8)); // WifiPacket Channel
854 in_packet.IgnoreBytes(sizeof(MacAddress)); // WifiPacket Transmitter Address 854 in_packet.IgnoreBytes(sizeof(MacAddress)); // WifiPacket Transmitter Address
855 MacAddress destination_address; 855 MacAddress destination_address;
856 in_packet >> destination_address; 856 in_packet.Read(destination_address);
857 857
858 Packet out_packet; 858 Packet out_packet;
859 out_packet.Append(event->packet->data, event->packet->dataLength); 859 out_packet.Append(event->packet->data, event->packet->dataLength);
@@ -899,7 +899,7 @@ void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) {
899 899
900 in_packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 900 in_packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
901 std::string message; 901 std::string message;
902 in_packet >> message; 902 in_packet.Read(message);
903 auto CompareNetworkAddress = [event](const Member member) -> bool { 903 auto CompareNetworkAddress = [event](const Member member) -> bool {
904 return member.peer == event->peer; 904 return member.peer == event->peer;
905 }; 905 };
@@ -914,10 +914,10 @@ void Room::RoomImpl::HandleChatPacket(const ENetEvent* event) {
914 message.resize(std::min(static_cast<u32>(message.size()), MaxMessageSize)); 914 message.resize(std::min(static_cast<u32>(message.size()), MaxMessageSize));
915 915
916 Packet out_packet; 916 Packet out_packet;
917 out_packet << static_cast<u8>(IdChatMessage); 917 out_packet.Write(static_cast<u8>(IdChatMessage));
918 out_packet << sending_member->nickname; 918 out_packet.Write(sending_member->nickname);
919 out_packet << sending_member->user_data.username; 919 out_packet.Write(sending_member->user_data.username);
920 out_packet << message; 920 out_packet.Write(message);
921 921
922 ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(), 922 ENetPacket* enet_packet = enet_packet_create(out_packet.GetData(), out_packet.GetDataSize(),
923 ENET_PACKET_FLAG_RELIABLE); 923 ENET_PACKET_FLAG_RELIABLE);
@@ -949,8 +949,8 @@ void Room::RoomImpl::HandleGameNamePacket(const ENetEvent* event) {
949 949
950 in_packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 950 in_packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
951 GameInfo game_info; 951 GameInfo game_info;
952 in_packet >> game_info.name; 952 in_packet.Read(game_info.name);
953 in_packet >> game_info.id; 953 in_packet.Read(game_info.id);
954 954
955 { 955 {
956 std::lock_guard lock(member_mutex); 956 std::lock_guard lock(member_mutex);
@@ -989,9 +989,9 @@ void Room::RoomImpl::HandleClientDisconnection(ENetPeer* client) {
989 nickname = member->nickname; 989 nickname = member->nickname;
990 username = member->user_data.username; 990 username = member->user_data.username;
991 991
992 char ip_raw[256]; 992 std::array<char, 256> ip_raw{};
993 enet_address_get_host_ip(&member->peer->address, ip_raw, sizeof(ip_raw) - 1); 993 enet_address_get_host_ip(&member->peer->address, ip_raw.data(), sizeof(ip_raw) - 1);
994 ip = ip_raw; 994 ip = ip_raw.data();
995 995
996 members.erase(member); 996 members.erase(member);
997 } 997 }
diff --git a/src/network/room_member.cpp b/src/network/room_member.cpp
index 38a6f6bfd..e4f823e98 100644
--- a/src/network/room_member.cpp
+++ b/src/network/room_member.cpp
@@ -280,13 +280,13 @@ void RoomMember::RoomMemberImpl::SendJoinRequest(const std::string& nickname_,
280 const std::string& password, 280 const std::string& password,
281 const std::string& token) { 281 const std::string& token) {
282 Packet packet; 282 Packet packet;
283 packet << static_cast<u8>(IdJoinRequest); 283 packet.Write(static_cast<u8>(IdJoinRequest));
284 packet << nickname_; 284 packet.Write(nickname_);
285 packet << console_id_hash; 285 packet.Write(console_id_hash);
286 packet << preferred_mac; 286 packet.Write(preferred_mac);
287 packet << network_version; 287 packet.Write(network_version);
288 packet << password; 288 packet.Write(password);
289 packet << token; 289 packet.Write(token);
290 Send(std::move(packet)); 290 Send(std::move(packet));
291} 291}
292 292
@@ -298,12 +298,12 @@ void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* ev
298 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 298 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
299 299
300 RoomInformation info{}; 300 RoomInformation info{};
301 packet >> info.name; 301 packet.Read(info.name);
302 packet >> info.description; 302 packet.Read(info.description);
303 packet >> info.member_slots; 303 packet.Read(info.member_slots);
304 packet >> info.port; 304 packet.Read(info.port);
305 packet >> info.preferred_game.name; 305 packet.Read(info.preferred_game.name);
306 packet >> info.host_username; 306 packet.Read(info.host_username);
307 room_information.name = info.name; 307 room_information.name = info.name;
308 room_information.description = info.description; 308 room_information.description = info.description;
309 room_information.member_slots = info.member_slots; 309 room_information.member_slots = info.member_slots;
@@ -312,17 +312,17 @@ void RoomMember::RoomMemberImpl::HandleRoomInformationPacket(const ENetEvent* ev
312 room_information.host_username = info.host_username; 312 room_information.host_username = info.host_username;
313 313
314 u32 num_members; 314 u32 num_members;
315 packet >> num_members; 315 packet.Read(num_members);
316 member_information.resize(num_members); 316 member_information.resize(num_members);
317 317
318 for (auto& member : member_information) { 318 for (auto& member : member_information) {
319 packet >> member.nickname; 319 packet.Read(member.nickname);
320 packet >> member.mac_address; 320 packet.Read(member.mac_address);
321 packet >> member.game_info.name; 321 packet.Read(member.game_info.name);
322 packet >> member.game_info.id; 322 packet.Read(member.game_info.id);
323 packet >> member.username; 323 packet.Read(member.username);
324 packet >> member.display_name; 324 packet.Read(member.display_name);
325 packet >> member.avatar_url; 325 packet.Read(member.avatar_url);
326 326
327 { 327 {
328 std::lock_guard lock(username_mutex); 328 std::lock_guard lock(username_mutex);
@@ -342,7 +342,7 @@ void RoomMember::RoomMemberImpl::HandleJoinPacket(const ENetEvent* event) {
342 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type 342 packet.IgnoreBytes(sizeof(u8)); // Ignore the message type
343 343
344 // Parse the MAC Address from the packet 344 // Parse the MAC Address from the packet
345 packet >> mac_address; 345 packet.Read(mac_address);
346} 346}
347 347
348void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) { 348void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) {
@@ -355,14 +355,14 @@ void RoomMember::RoomMemberImpl::HandleWifiPackets(const ENetEvent* event) {
355 355
356 // Parse the WifiPacket from the packet 356 // Parse the WifiPacket from the packet
357 u8 frame_type; 357 u8 frame_type;
358 packet >> frame_type; 358 packet.Read(frame_type);
359 WifiPacket::PacketType type = static_cast<WifiPacket::PacketType>(frame_type); 359 WifiPacket::PacketType type = static_cast<WifiPacket::PacketType>(frame_type);
360 360
361 wifi_packet.type = type; 361 wifi_packet.type = type;
362 packet >> wifi_packet.channel; 362 packet.Read(wifi_packet.channel);
363 packet >> wifi_packet.transmitter_address; 363 packet.Read(wifi_packet.transmitter_address);
364 packet >> wifi_packet.destination_address; 364 packet.Read(wifi_packet.destination_address);
365 packet >> wifi_packet.data; 365 packet.Read(wifi_packet.data);
366 366
367 Invoke<WifiPacket>(wifi_packet); 367 Invoke<WifiPacket>(wifi_packet);
368} 368}
@@ -375,9 +375,9 @@ void RoomMember::RoomMemberImpl::HandleChatPacket(const ENetEvent* event) {
375 packet.IgnoreBytes(sizeof(u8)); 375 packet.IgnoreBytes(sizeof(u8));
376 376
377 ChatEntry chat_entry{}; 377 ChatEntry chat_entry{};
378 packet >> chat_entry.nickname; 378 packet.Read(chat_entry.nickname);
379 packet >> chat_entry.username; 379 packet.Read(chat_entry.username);
380 packet >> chat_entry.message; 380 packet.Read(chat_entry.message);
381 Invoke<ChatEntry>(chat_entry); 381 Invoke<ChatEntry>(chat_entry);
382} 382}
383 383
@@ -390,10 +390,10 @@ void RoomMember::RoomMemberImpl::HandleStatusMessagePacket(const ENetEvent* even
390 390
391 StatusMessageEntry status_message_entry{}; 391 StatusMessageEntry status_message_entry{};
392 u8 type{}; 392 u8 type{};
393 packet >> type; 393 packet.Read(type);
394 status_message_entry.type = static_cast<StatusMessageTypes>(type); 394 status_message_entry.type = static_cast<StatusMessageTypes>(type);
395 packet >> status_message_entry.nickname; 395 packet.Read(status_message_entry.nickname);
396 packet >> status_message_entry.username; 396 packet.Read(status_message_entry.username);
397 Invoke<StatusMessageEntry>(status_message_entry); 397 Invoke<StatusMessageEntry>(status_message_entry);
398} 398}
399 399
@@ -405,8 +405,8 @@ void RoomMember::RoomMemberImpl::HandleModBanListResponsePacket(const ENetEvent*
405 packet.IgnoreBytes(sizeof(u8)); 405 packet.IgnoreBytes(sizeof(u8));
406 406
407 Room::BanList ban_list = {}; 407 Room::BanList ban_list = {};
408 packet >> ban_list.first; 408 packet.Read(ban_list.first);
409 packet >> ban_list.second; 409 packet.Read(ban_list.second);
410 Invoke<Room::BanList>(ban_list); 410 Invoke<Room::BanList>(ban_list);
411} 411}
412 412
@@ -586,19 +586,19 @@ bool RoomMember::IsConnected() const {
586 586
587void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) { 587void RoomMember::SendWifiPacket(const WifiPacket& wifi_packet) {
588 Packet packet; 588 Packet packet;
589 packet << static_cast<u8>(IdWifiPacket); 589 packet.Write(static_cast<u8>(IdWifiPacket));
590 packet << static_cast<u8>(wifi_packet.type); 590 packet.Write(static_cast<u8>(wifi_packet.type));
591 packet << wifi_packet.channel; 591 packet.Write(wifi_packet.channel);
592 packet << wifi_packet.transmitter_address; 592 packet.Write(wifi_packet.transmitter_address);
593 packet << wifi_packet.destination_address; 593 packet.Write(wifi_packet.destination_address);
594 packet << wifi_packet.data; 594 packet.Write(wifi_packet.data);
595 room_member_impl->Send(std::move(packet)); 595 room_member_impl->Send(std::move(packet));
596} 596}
597 597
598void RoomMember::SendChatMessage(const std::string& message) { 598void RoomMember::SendChatMessage(const std::string& message) {
599 Packet packet; 599 Packet packet;
600 packet << static_cast<u8>(IdChatMessage); 600 packet.Write(static_cast<u8>(IdChatMessage));
601 packet << message; 601 packet.Write(message);
602 room_member_impl->Send(std::move(packet)); 602 room_member_impl->Send(std::move(packet));
603} 603}
604 604
@@ -608,9 +608,9 @@ void RoomMember::SendGameInfo(const GameInfo& game_info) {
608 return; 608 return;
609 609
610 Packet packet; 610 Packet packet;
611 packet << static_cast<u8>(IdSetGameInfo); 611 packet.Write(static_cast<u8>(IdSetGameInfo));
612 packet << game_info.name; 612 packet.Write(game_info.name);
613 packet << game_info.id; 613 packet.Write(game_info.id);
614 room_member_impl->Send(std::move(packet)); 614 room_member_impl->Send(std::move(packet));
615} 615}
616 616
@@ -621,8 +621,8 @@ void RoomMember::SendModerationRequest(RoomMessageTypes type, const std::string&
621 return; 621 return;
622 622
623 Packet packet; 623 Packet packet;
624 packet << static_cast<u8>(type); 624 packet.Write(static_cast<u8>(type));
625 packet << nickname; 625 packet.Write(nickname);
626 room_member_impl->Send(std::move(packet)); 626 room_member_impl->Send(std::move(packet));
627} 627}
628 628
@@ -631,7 +631,7 @@ void RoomMember::RequestBanList() {
631 return; 631 return;
632 632
633 Packet packet; 633 Packet packet;
634 packet << static_cast<u8>(IdModGetBanList); 634 packet.Write(static_cast<u8>(IdModGetBanList));
635 room_member_impl->Send(std::move(packet)); 635 room_member_impl->Send(std::move(packet));
636} 636}
637 637
diff --git a/src/yuzu/multiplayer/state.cpp b/src/yuzu/multiplayer/state.cpp
index 015c59788..4149b5232 100644
--- a/src/yuzu/multiplayer/state.cpp
+++ b/src/yuzu/multiplayer/state.cpp
@@ -74,14 +74,18 @@ MultiplayerState::~MultiplayerState() {
74} 74}
75 75
76void MultiplayerState::Close() { 76void MultiplayerState::Close() {
77 if (host_room) 77 if (host_room) {
78 host_room->close(); 78 host_room->close();
79 if (direct_connect) 79 }
80 if (direct_connect) {
80 direct_connect->close(); 81 direct_connect->close();
81 if (client_room) 82 }
83 if (client_room) {
82 client_room->close(); 84 client_room->close();
83 if (lobby) 85 }
86 if (lobby) {
84 lobby->close(); 87 lobby->close();
88 }
85} 89}
86 90
87void MultiplayerState::retranslateUi() { 91void MultiplayerState::retranslateUi() {
HIC SVNT DRACONES