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