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