]> git.stg.codes - stg.git/blob - projects/sgauthstress/proto.cpp
40762b13b3857ed1d09d0a451c5b7d52f2a4bcb1
[stg.git] / projects / sgauthstress / proto.cpp
1 #include <netdb.h>
2 #include <arpa/inet.h>
3
4 #include <cerrno>
5 #include <cstring>
6 #include <cassert>
7 #include <stdexcept>
8
9 #include "stg/common.h"
10 #include "stg/ia_packets.h"
11
12 #include "proto.h"
13
14 PROTO::PROTO(const std::string & server,
15              uint16_t port,
16              uint16_t localPort,
17              int to)
18     : running(false),
19       stopped(true),
20       timeout(to)
21 {
22 uint32_t ip = inet_addr(server.c_str());
23 if (ip == INADDR_NONE)
24     {
25     struct hostent * hePtr = gethostbyname(server.c_str());
26     if (hePtr)
27         {
28         ip = *((uint32_t *)hePtr->h_addr_list[0]);
29         }
30     else
31         {
32         errorStr = "Unknown host: '";
33         errorStr += server;
34         errorStr += "'";
35         printfd(__FILE__, "PROTO::PROTO() - %s\n", errorStr.c_str());
36         throw std::runtime_error(errorStr);
37         }
38     }
39
40 localAddr.sin_family = AF_INET;
41 localAddr.sin_port = htons(localPort);
42 localAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
43
44 serverAddr.sin_family = AF_INET;
45 serverAddr.sin_port = htons(port);
46 serverAddr.sin_addr.s_addr = ip;
47
48 unsigned char key[IA_PASSWD_LEN];
49 memset(key, 0, IA_PASSWD_LEN);
50 strncpy(reinterpret_cast<char *>(key), "pr7Hhen", 8);
51 Blowfish_Init(&ctx, key, IA_PASSWD_LEN);
52
53 processors["CONN_SYN_ACK"] = &PROTO::CONN_SYN_ACK_Proc;
54 processors["ALIVE_SYN"] = &PROTO::ALIVE_SYN_Proc;
55 processors["DISCONN_SYN_ACK"] = &PROTO::DISCONN_SYN_ACK_Proc;
56 processors["FIN"] = &PROTO::FIN_Proc;
57 processors["INFO"] = &PROTO::INFO_Proc;
58 // ERR_Proc will be handled explicitly
59 }
60
61 PROTO::~PROTO()
62 {
63 }
64
65 void * PROTO::Runner(void * data)
66 {
67 PROTO * protoPtr = static_cast<PROTO *>(data);
68 protoPtr->Run();
69 }
70
71 bool PROTO::Start()
72 {
73 stopped = false;
74 running = true;
75 if (pthread_create(&tid, NULL, &Runner, NULL))
76     {
77     errorStr = "Failed to create listening thread: '";
78     errorStr += strerror(errno);
79     errorStr += "'";
80     printfd(__FILE__, "PROTO::Start() - %s\n", errorStr.c_str());
81     return false;
82     }
83 return true;
84 }
85
86 bool PROTO::Stop()
87 {
88 running = false;
89 int time = 0;
90 while (!stopped && time < timeout)
91     {
92     struct timespec ts = {1, 0};
93     nanosleep(&ts, NULL);
94     ++time;
95     }
96 if (!stopped)
97     {
98     errorStr = "Failed to stop listening thread - timed out";
99     printfd(__FILE__, "PROTO::Stop() - %s\n", errorStr.c_str());
100     return false;
101     }
102 if (pthread_join(tid, NULL))
103     {
104     errorStr = "Failed to join listening thread after stop: '";
105     errorStr += strerror(errno);
106     errorStr += "'";
107     printfd(__FILE__, "PROTO::Stop() - %s\n", errorStr.c_str());
108     return false;
109     }
110 return true;
111 }
112
113 void PROTO::AddUser(const USER & user)
114 {
115     users.push_back(std::make_pair(user.GetIP(), user));
116     struct pollfd pfd;
117     pfd.fd = user.GetSocket();
118     pfd.events = POLLIN;
119     pfd.revents = 0;
120     pollFds.push_back(pfd);
121 }
122
123 bool PROTO::Connect(uint32_t ip)
124 {
125 /*std::vector<std::pair<uint32_t, USER> >::const_iterator it;
126 it = users.find(ip);
127 if (it == users.end())
128     return false;*/
129
130 // Do something
131
132 return true;
133 }
134
135 bool PROTO::Disconnect(uint32_t ip)
136 {
137 /*std::vector<std::pair<uint32_t, USER> >::const_iterator it;
138 it = users.find(ip);
139 if (it == users.end())
140     return false;*/
141
142 // Do something
143
144 return true;
145 }
146
147 void PROTO::Run()
148 {
149 while (running)
150     {
151     int res = poll(&pollFds.front(), pollFds.size(), timeout);
152     if (res < 0)
153         break;
154     if (!running)
155         break;
156     if (res)
157         RecvPacket();
158     }
159
160 stopped = true;
161 }
162
163 bool PROTO::RecvPacket()
164 {
165 bool result = true;
166 std::vector<struct pollfd>::iterator it;
167 std::vector<std::pair<uint32_t, USER> >::iterator userIt;
168 for (it = pollFds.begin(), userIt = users.begin(); it != pollFds.end() && userIt != users.end(); ++it, ++userIt)
169     {
170     if (it->revents)
171         {
172         it->revents = 0;
173         assert(it->fd == userIt->second.GetSocket() && "File descriptors from poll fds and users must be syncked");
174         struct sockaddr_in addr;
175         socklen_t fromLen = sizeof(addr);
176         char buffer[2048];
177         int res = recvfrom(userIt->second.GetSocket(), buffer, sizeof(buffer), 0, (struct sockaddr *)&addr, &fromLen);
178
179         if (res == -1)
180             {
181             result = false;
182             continue;
183             }
184
185         result = result && HandlePacket(buffer, &(userIt->second));
186         }
187     }
188
189 return result;
190 }
191
192 bool PROTO::HandlePacket(const char * buffer, USER * user)
193 {
194 if (strcmp(buffer + 4 + sizeof(HDR_8), "ERR"))
195     {
196     return ERR_Proc(buffer, user);
197     }
198
199 std::string packetName(buffer + 12);
200 std::map<std::string, PacketProcessor>::const_iterator it;
201 it = processors.find(packetName);
202 if (it != processors.end())
203     return (this->*it->second)(buffer, user);
204
205 return false;
206 }
207
208 bool PROTO::CONN_SYN_ACK_Proc(const void * buffer, USER * user)
209 {
210 const CONN_SYN_ACK_8 * packet = static_cast<const CONN_SYN_ACK_8 *>(buffer);
211
212 uint32_t rnd = packet->rnd;
213 uint32_t userTimeout = packet->userTimeOut;
214 uint32_t aliveTimeout = packet->aliveDelay;
215
216 #ifdef ARCH_BE
217 SwapBytes(rnd);
218 SwapBytes(userTimeout);
219 SwapBytes(aliveDelay);
220 #endif
221
222 Send_CONN_ACK(user);
223
224 if (user->GetPhase() != 2)
225     {
226     errorStr = "Unexpected CONN_SYN_ACK";
227     printfd(__FILE__, "PROTO::CONN_SYN_ACK_Proc() - wrong phase: %d\n", user->GetPhase());
228     }
229
230 user->SetPhase(3);
231 user->SetAliveTimeout(aliveTimeout);
232 user->SetUserTimeout(userTimeout);
233 user->SetRnd(rnd);
234
235 return true;
236 }
237
238 bool PROTO::ALIVE_SYN_Proc(const void * buffer, USER * user)
239 {
240 const ALIVE_SYN_8 * packet = static_cast<const ALIVE_SYN_8 *>(buffer);
241
242 uint32_t rnd = packet->rnd;
243
244 #ifdef ARCH_BE
245 SwapBytes(rnd);
246 #endif
247
248 if (user->GetPhase() != 3)
249     {
250     errorStr = "Unexpected ALIVE_SYN";
251     printfd(__FILE__, "PROTO::ALIVE_SYN_Proc() - wrong phase: %d\n", user->GetPhase());
252     }
253
254 if (user->GetRnd() + 1 != rnd)
255     {
256     errorStr = "Wrong control value at ALIVE_SYN";
257     printfd(__FILE__, "PROTO::ALIVE_SYN_Proc() - wrong control value: %d, expected: %d\n", rnd, user->GetRnd() + 1);
258     }
259
260 user->SetPhase(3);
261 user->SetRnd(rnd);
262
263 Send_ALIVE_ACK(user);
264
265 return true;
266 }
267
268 bool PROTO::DISCONN_SYN_ACK_Proc(const void * buffer, USER * user)
269 {
270 const DISCONN_SYN_ACK_8 * packet = static_cast<const DISCONN_SYN_ACK_8 *>(buffer);
271
272 uint32_t rnd = packet->rnd;
273
274 #ifdef ARCH_BE
275 SwapBytes(rnd);
276 #endif
277
278 if (user->GetPhase() != 4)
279     {
280     errorStr = "Unexpected DISCONN_SYN_ACK";
281     printfd(__FILE__, "PROTO::DISCONN_SYN_ACK_Proc() - wrong phase: %d\n", user->GetPhase());
282     }
283
284 if (user->GetRnd() + 1 != rnd)
285     {
286     errorStr = "Wrong control value at DISCONN_SYN_ACK";
287     printfd(__FILE__, "PROTO::DISCONN_SYN_ACK_Proc() - wrong control value: %d, expected: %d\n", rnd, user->GetRnd() + 1);
288     }
289
290 user->SetPhase(5);
291 user->SetRnd(rnd);
292
293 Send_DISCONN_ACK(user);
294
295 return true;
296 }
297
298 bool PROTO::FIN_Proc(const void * buffer, USER * user)
299 {
300 if (user->GetPhase() != 5)
301     {
302     errorStr = "Unexpected FIN";
303     printfd(__FILE__, "PROTO::FIN_Proc() - wrong phase: %d\n", user->GetPhase());
304     }
305
306 user->SetPhase(1);
307
308 return true;
309 }
310
311 bool PROTO::INFO_Proc(const void * buffer, USER * user)
312 {
313 //const INFO_8 * packet = static_cast<const INFO_8 *>(buffer);
314
315 return true;
316 }
317
318 bool PROTO::ERR_Proc(const void * buffer, USER * user)
319 {
320 const ERR_8 * packet = static_cast<const ERR_8 *>(buffer);
321 const char * ptr = static_cast<const char *>(buffer);
322
323 for (int i = 0; i < sizeof(packet) / 8; i++)
324     Blowfish_Decrypt(user->GetCtx(), (uint32_t *)(ptr + i * 8), (uint32_t *)(ptr + i * 8 + 4));
325
326 //uint32_t len = packet->len;
327
328 #ifdef ARCH_BE
329 //SwapBytes(len);
330 #endif
331
332 user->SetPhase(1); //TODO: Check
333 /*KOIToWin((const char*)err.text, &messageText);
334 if (pErrorCb != NULL)
335     pErrorCb(messageText, IA_SERVER_ERROR, errorCbData);
336 phaseTime = GetTickCount();
337 codeError = IA_SERVER_ERROR;*/
338
339 return true;
340 }
341
342 bool PROTO::Send_CONN_SYN(USER * user)
343 {
344 CONN_SYN_8 packet;
345
346 packet.len = sizeof(packet);
347
348 #ifdef ARCH_BE
349 SwapBytes(packet.len);
350 #endif
351
352 strncpy((char *)packet.type, "CONN_SYN", sizeof(packet.type));
353 strncpy((char *)packet.login, user->GetLogin().c_str(), sizeof(packet.login));
354 packet.dirs = 0xFFffFFff;
355
356 return SendPacket(&packet, sizeof(packet), user);
357 }
358
359 bool PROTO::Send_CONN_ACK(USER * user)
360 {
361 CONN_ACK_8 packet;
362
363 packet.len = sizeof(packet);
364 packet.rnd = user->IncRnd();
365
366 #ifdef ARCH_BE
367 SwapBytes(packet.len);
368 SwapBytes(packet.rnd);
369 #endif
370
371 strncpy((char *)packet.loginS, user->GetLogin().c_str(), sizeof(packet.loginS));
372 strncpy((char *)packet.type, "CONN_ACK", sizeof(packet.type));
373
374 return SendPacket(&packet, sizeof(packet), user);
375 }
376
377 bool PROTO::Send_ALIVE_ACK(USER * user)
378 {
379 ALIVE_ACK_8 packet;
380
381 packet.len = sizeof(packet);
382 packet.rnd = user->IncRnd();
383
384 #ifdef ARCH_BE
385 SwapBytes(packet.len);
386 SwapBytes(packet.rnd);
387 #endif
388
389 strncpy((char *)packet.loginS, user->GetLogin().c_str(), sizeof(packet.loginS));
390 strncpy((char *)packet.type, "ALIVE_ACK", sizeof(packet.type));
391
392 return SendPacket(&packet, sizeof(packet), user);
393 }
394
395 bool PROTO::Send_DISCONN_SYN(USER * user)
396 {
397 DISCONN_SYN_8 packet;
398
399 packet.len = sizeof(packet);
400
401 #ifdef ARCH_BE
402 SwapBytes(packet.len);
403 #endif
404
405 strncpy((char *)packet.loginS, user->GetLogin().c_str(), sizeof(packet.loginS));
406 strncpy((char *)packet.type, "DISCONN_SYN", sizeof(packet.type));
407 strncpy((char *)packet.login, user->GetLogin().c_str(), sizeof(packet.login));
408
409 return SendPacket(&packet, sizeof(packet), user);
410 }
411
412 bool PROTO::Send_DISCONN_ACK(USER * user)
413 {
414 DISCONN_ACK_8 packet;
415
416 packet.len = sizeof(packet);
417 packet.rnd = user->IncRnd();
418
419 #ifdef ARCH_BE
420 SwapBytes(packet.len);
421 SwapBytes(packet.rnd);
422 #endif
423
424 strncpy((char *)packet.loginS, user->GetLogin().c_str(), sizeof(packet.loginS));
425 strncpy((char *)packet.type, "DISCONN_ACK", sizeof(packet.type));
426
427 return SendPacket(&packet, sizeof(packet), user);
428 }
429
430 bool PROTO::SendPacket(const void * packet, size_t length, USER * user)
431 {
432 HDR_8 hdr;
433
434 assert(sizeof(hdr) + length < 2048 && "Packet length must not exceed 2048 bytes");
435
436 strncpy((char *)hdr.magic, IA_ID, 6);
437 hdr.protoVer[0] = 0;
438 hdr.protoVer[1] = 8; // IA_PROTO_VER
439
440 unsigned char buffer[2048];
441 memcpy(buffer, &hdr, sizeof(hdr));
442 memcpy(buffer + sizeof(hdr), packet, length);
443
444 size_t offset = sizeof(HDR_8);
445 for (size_t i = 0; i < IA_LOGIN_LEN / 8; i++)
446     {
447     Blowfish_Encrypt(&ctx,
448                      (uint32_t *)(buffer + offset + i * 8),
449                      (uint32_t *)(buffer + offset + i * 8 + 4));
450     }
451
452 offset += IA_LOGIN_LEN;
453 size_t encLen = (length - IA_LOGIN_LEN) / 8;
454 for (size_t i = 0; i < encLen; i++)
455     {
456     Blowfish_Encrypt(user->GetCtx(),
457                      (uint32_t*)(buffer + offset + i * 8),
458                      (uint32_t*)(buffer + offset + i * 8 + 4));
459     }
460
461 int res = sendto(user->GetSocket(), buffer, sizeof(buffer), 0, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
462
463 if (res < 0)
464     {
465     errorStr = "Failed to send packet: '";
466     errorStr += strerror(errno);
467     errorStr += "'";
468     printfd(__FILE__, "PROTO::SendPacket() - %s\n", errorStr.c_str());
469     return false;
470     }
471
472 if (res < sizeof(buffer))
473     {
474     errorStr = "Packet sent partially";
475     printfd(__FILE__, "PROTO::SendPacket() - %s\n", errorStr.c_str());
476     return false;
477     }
478
479 return true;
480 }