summaryrefslogtreecommitdiff
path: root/src/network/packet.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/network/packet.cpp')
-rw-r--r--src/network/packet.cpp263
1 files changed, 0 insertions, 263 deletions
diff --git a/src/network/packet.cpp b/src/network/packet.cpp
deleted file mode 100644
index 7e1a812f3..000000000
--- a/src/network/packet.cpp
+++ /dev/null
@@ -1,263 +0,0 @@
1// Copyright 2017 Citra Emulator Project
2// Licensed under GPLv2 or any later version
3// Refer to the license.txt file included.
4
5#ifdef _WIN32
6#include <winsock2.h>
7#else
8#include <arpa/inet.h>
9#endif
10#include <cstring>
11#include <string>
12#include "network/packet.h"
13
14namespace Network {
15
16#ifndef htonll
17u64 htonll(u64 x) {
18 return ((1 == htonl(1)) ? (x) : ((uint64_t)htonl((x)&0xFFFFFFFF) << 32) | htonl((x) >> 32));
19}
20#endif
21
22#ifndef ntohll
23u64 ntohll(u64 x) {
24 return ((1 == ntohl(1)) ? (x) : ((uint64_t)ntohl((x)&0xFFFFFFFF) << 32) | ntohl((x) >> 32));
25}
26#endif
27
28void Packet::Append(const void* in_data, std::size_t size_in_bytes) {
29 if (in_data && (size_in_bytes > 0)) {
30 std::size_t start = data.size();
31 data.resize(start + size_in_bytes);
32 std::memcpy(&data[start], in_data, size_in_bytes);
33 }
34}
35
36void Packet::Read(void* out_data, std::size_t size_in_bytes) {
37 if (out_data && CheckSize(size_in_bytes)) {
38 std::memcpy(out_data, &data[read_pos], size_in_bytes);
39 read_pos += size_in_bytes;
40 }
41}
42
43void Packet::Clear() {
44 data.clear();
45 read_pos = 0;
46 is_valid = true;
47}
48
49const void* Packet::GetData() const {
50 return !data.empty() ? &data[0] : nullptr;
51}
52
53void Packet::IgnoreBytes(u32 length) {
54 read_pos += length;
55}
56
57std::size_t Packet::GetDataSize() const {
58 return data.size();
59}
60
61bool Packet::EndOfPacket() const {
62 return read_pos >= data.size();
63}
64
65Packet::operator bool() const {
66 return is_valid ? &Packet::CheckSize : nullptr;
67}
68
69Packet& Packet::operator>>(bool& out_data) {
70 u8 value;
71 if (*this >> value) {
72 out_data = (value != 0);
73 }
74 return *this;
75}
76
77Packet& Packet::operator>>(s8& out_data) {
78 Read(&out_data, sizeof(out_data));
79 return *this;
80}
81
82Packet& Packet::operator>>(u8& out_data) {
83 Read(&out_data, sizeof(out_data));
84 return *this;
85}
86
87Packet& Packet::operator>>(s16& out_data) {
88 s16 value;
89 Read(&value, sizeof(value));
90 out_data = ntohs(value);
91 return *this;
92}
93
94Packet& Packet::operator>>(u16& out_data) {
95 u16 value;
96 Read(&value, sizeof(value));
97 out_data = ntohs(value);
98 return *this;
99}
100
101Packet& Packet::operator>>(s32& out_data) {
102 s32 value;
103 Read(&value, sizeof(value));
104 out_data = ntohl(value);
105 return *this;
106}
107
108Packet& Packet::operator>>(u32& out_data) {
109 u32 value;
110 Read(&value, sizeof(value));
111 out_data = ntohl(value);
112 return *this;
113}
114
115Packet& Packet::operator>>(s64& out_data) {
116 s64 value;
117 Read(&value, sizeof(value));
118 out_data = ntohll(value);
119 return *this;
120}
121
122Packet& Packet::operator>>(u64& out_data) {
123 u64 value;
124 Read(&value, sizeof(value));
125 out_data = ntohll(value);
126 return *this;
127}
128
129Packet& Packet::operator>>(float& out_data) {
130 Read(&out_data, sizeof(out_data));
131 return *this;
132}
133
134Packet& Packet::operator>>(double& out_data) {
135 Read(&out_data, sizeof(out_data));
136 return *this;
137}
138
139Packet& Packet::operator>>(char* out_data) {
140 // First extract string length
141 u32 length = 0;
142 *this >> length;
143
144 if ((length > 0) && CheckSize(length)) {
145 // Then extract characters
146 std::memcpy(out_data, &data[read_pos], length);
147 out_data[length] = '\0';
148
149 // Update reading position
150 read_pos += length;
151 }
152
153 return *this;
154}
155
156Packet& Packet::operator>>(std::string& out_data) {
157 // First extract string length
158 u32 length = 0;
159 *this >> length;
160
161 out_data.clear();
162 if ((length > 0) && CheckSize(length)) {
163 // Then extract characters
164 out_data.assign(&data[read_pos], length);
165
166 // Update reading position
167 read_pos += length;
168 }
169
170 return *this;
171}
172
173Packet& Packet::operator<<(bool in_data) {
174 *this << static_cast<u8>(in_data);
175 return *this;
176}
177
178Packet& Packet::operator<<(s8 in_data) {
179 Append(&in_data, sizeof(in_data));
180 return *this;
181}
182
183Packet& Packet::operator<<(u8 in_data) {
184 Append(&in_data, sizeof(in_data));
185 return *this;
186}
187
188Packet& Packet::operator<<(s16 in_data) {
189 s16 toWrite = htons(in_data);
190 Append(&toWrite, sizeof(toWrite));
191 return *this;
192}
193
194Packet& Packet::operator<<(u16 in_data) {
195 u16 toWrite = htons(in_data);
196 Append(&toWrite, sizeof(toWrite));
197 return *this;
198}
199
200Packet& Packet::operator<<(s32 in_data) {
201 s32 toWrite = htonl(in_data);
202 Append(&toWrite, sizeof(toWrite));
203 return *this;
204}
205
206Packet& Packet::operator<<(u32 in_data) {
207 u32 toWrite = htonl(in_data);
208 Append(&toWrite, sizeof(toWrite));
209 return *this;
210}
211
212Packet& Packet::operator<<(s64 in_data) {
213 s64 toWrite = htonll(in_data);
214 Append(&toWrite, sizeof(toWrite));
215 return *this;
216}
217
218Packet& Packet::operator<<(u64 in_data) {
219 u64 toWrite = htonll(in_data);
220 Append(&toWrite, sizeof(toWrite));
221 return *this;
222}
223
224Packet& Packet::operator<<(float in_data) {
225 Append(&in_data, sizeof(in_data));
226 return *this;
227}
228
229Packet& Packet::operator<<(double in_data) {
230 Append(&in_data, sizeof(in_data));
231 return *this;
232}
233
234Packet& Packet::operator<<(const char* in_data) {
235 // First insert string length
236 u32 length = static_cast<u32>(std::strlen(in_data));
237 *this << length;
238
239 // Then insert characters
240 Append(in_data, length * sizeof(char));
241
242 return *this;
243}
244
245Packet& Packet::operator<<(const std::string& in_data) {
246 // First insert string length
247 u32 length = static_cast<u32>(in_data.size());
248 *this << length;
249
250 // Then insert characters
251 if (length > 0)
252 Append(in_data.c_str(), length * sizeof(std::string::value_type));
253
254 return *this;
255}
256
257bool Packet::CheckSize(std::size_t size) {
258 is_valid = is_valid && (read_pos + size <= data.size());
259
260 return is_valid;
261}
262
263} // namespace Network