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