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