projects/rscriptd/listener.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  20  */
  21
  22 #include <arpa/inet.h>
  23 #include <sys/uio.h> // readv
  24 #include <sys/types.h> // for historical versions of BSD
  25 #include <sys/socket.h>
  26 #include <netinet/in.h>
  27 #include <unistd.h>
  28
  29 #include <csignal>
  30 #include <cerrno>
  31 #include <ctime>
  32 #include <cstring>
  33 #include <sstream>
  34 #include <algorithm>
  35
  36 #include "stg/scriptexecuter.h"
  37 #include "stg/locker.h"
  38 #include "stg/common.h"
  39 #include "listener.h"
  40
  41 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password);
  42 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
  43
  44 //-----------------------------------------------------------------------------
  45 LISTENER::LISTENER()
  46     : WriteServLog(GetStgLogger()),
  47       port(0),
  48       running(false),
  49       receiverStopped(true),
  50       processorStopped(true),
  51       userTimeout(0),
  52       listenSocket(0),
  53       version("rscriptd listener v.1.2")
  54 {
  55 pthread_mutex_init(&mutex, NULL);
  56 }
  57 //-----------------------------------------------------------------------------
  58 void LISTENER::SetPassword(const std::string & p)
  59 {
  60 password = p;
  61 printfd(__FILE__, "Encryption initiated with password \'%s\'\n", password.c_str());
  62 InitEncrypt(&ctxS, password);
  63 }
  64 //-----------------------------------------------------------------------------
  65 bool LISTENER::Start()
  66 {
  67 printfd(__FILE__, "LISTENER::Start()\n");
  68 running = true;
  69
  70 if (PrepareNet())
  71     {
  72     return true;
  73     }
  74
  75 if (receiverStopped)
  76     {
  77     if (pthread_create(&receiverThread, NULL, Run, this))
  78         {
  79         errorStr = "Cannot create thread.";
  80         return true;
  81         }
  82     }
  83
  84 if (processorStopped)
  85     {
  86     if (pthread_create(&processorThread, NULL, RunProcessor, this))
  87         {
  88         errorStr = "Cannot create thread.";
  89         return true;
  90         }
  91     }
  92
  93 errorStr = "";
  94
  95 return false;
  96 }
  97 //-----------------------------------------------------------------------------
  98 bool LISTENER::Stop()
  99 {
 100 running = false;
 101
 102 printfd(__FILE__, "LISTENER::Stop()\n");
 103
 104 struct timespec ts = {0, 500000000};
 105 nanosleep(&ts, NULL);
 106
 107 if (!processorStopped)
 108     {
 109     //5 seconds to thread stops itself
 110     for (int i = 0; i < 25 && !processorStopped; i++)
 111         {
 112         struct timespec ts = {0, 200000000};
 113         nanosleep(&ts, NULL);
 114         }
 115
 116     //after 5 seconds waiting thread still running. now killing it
 117     if (!processorStopped)
 118         {
 119         //TODO pthread_cancel()
 120         if (pthread_kill(processorThread, SIGINT))
 121             {
 122             errorStr = "Cannot kill thread.";
 123             return true;
 124             }
 125         printfd(__FILE__, "LISTENER killed Timeouter\n");
 126         }
 127     }
 128
 129 if (!receiverStopped)
 130     {
 131     //5 seconds to thread stops itself
 132     for (int i = 0; i < 25 && !receiverStopped; i++)
 133         {
 134         struct timespec ts = {0, 200000000};
 135         nanosleep(&ts, NULL);
 136         }
 137
 138     //after 5 seconds waiting thread still running. now killing it
 139     if (!receiverStopped)
 140         {
 141         //TODO pthread_cancel()
 142         if (pthread_kill(receiverThread, SIGINT))
 143             {
 144             errorStr = "Cannot kill thread.";
 145             return true;
 146             }
 147         printfd(__FILE__, "LISTENER killed Run\n");
 148         }
 149     }
 150
 151 pthread_join(receiverThread, NULL);
 152 pthread_join(processorThread, NULL);
 153
 154 pthread_mutex_destroy(&mutex);
 155
 156 FinalizeNet();
 157
 158 std::for_each(users.begin(), users.end(), DisconnectUser(*this));
 159
 160 printfd(__FILE__, "LISTENER::Stoped successfully.\n");
 161
 162 return false;
 163 }
 164 //-----------------------------------------------------------------------------
 165 void * LISTENER::Run(void * d)
 166 {
 167 sigset_t signalSet;
 168 sigfillset(&signalSet);
 169 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 170
 171 LISTENER * listener = static_cast<LISTENER *>(d);
 172
 173 listener->Runner();
 174
 175 return NULL;
 176 }
 177 //-----------------------------------------------------------------------------
 178 void LISTENER::Runner()
 179 {
 180 receiverStopped = false;
 181
 182 while (running)
 183     {
 184     RecvPacket();
 185     }
 186
 187 receiverStopped = true;
 188 }
 189 //-----------------------------------------------------------------------------
 190 void * LISTENER::RunProcessor(void * d)
 191 {
 192 sigset_t signalSet;
 193 sigfillset(&signalSet);
 194 pthread_sigmask(SIG_BLOCK, &signalSet, NULL);
 195
 196 LISTENER * listener = static_cast<LISTENER *>(d);
 197
 198 listener->ProcessorRunner();
 199
 200 return NULL;
 201 }
 202 //-----------------------------------------------------------------------------
 203 void LISTENER::ProcessorRunner()
 204 {
 205 processorStopped = false;
 206
 207 while (running)
 208     {
 209     struct timespec ts = {0, 500000000};
 210     nanosleep(&ts, NULL);
 211     if (!pending.empty())
 212         ProcessPending();
 213     ProcessTimeouts();
 214     }
 215
 216 processorStopped = true;
 217 }
 218 //-----------------------------------------------------------------------------
 219 bool LISTENER::PrepareNet()
 220 {
 221 listenSocket = socket(AF_INET, SOCK_DGRAM, 0);
 222
 223 if (listenSocket < 0)
 224     {
 225     errorStr = "Cannot create socket.";
 226     return true;
 227     }
 228
 229 struct sockaddr_in listenAddr;
 230 listenAddr.sin_family = AF_INET;
 231 listenAddr.sin_port = htons(port);
 232 listenAddr.sin_addr.s_addr = inet_addr("0.0.0.0");
 233
 234 if (bind(listenSocket, (struct sockaddr*)&listenAddr, sizeof(listenAddr)) < 0)
 235     {
 236     errorStr = "LISTENER: Bind failed.";
 237     return true;
 238     }
 239
 240 printfd(__FILE__, "LISTENER::PrepareNet() >>>> Start successfull.\n");
 241
 242 return false;
 243 }
 244 //-----------------------------------------------------------------------------
 245 bool LISTENER::FinalizeNet()
 246 {
 247 close(listenSocket);
 248
 249 return false;
 250 }
 251 //-----------------------------------------------------------------------------
 252 bool LISTENER::RecvPacket()
 253 {
 254 struct iovec iov[2];
 255
 256 char buffer[RS_MAX_PACKET_LEN];
 257 RS::PACKET_HEADER packetHead;
 258
 259 iov[0].iov_base = reinterpret_cast<char *>(&packetHead);
 260 iov[0].iov_len = sizeof(packetHead);
 261 iov[1].iov_base = buffer;
 262 iov[1].iov_len = sizeof(buffer) - sizeof(packetHead);
 263
 264 size_t dataLen = 0;
 265 while (dataLen < sizeof(buffer))
 266     {
 267     if (!WaitPackets(listenSocket))
 268         {
 269         if (!running)
 270             return false;
 271         continue;
 272         }
 273     int portion = readv(listenSocket, iov, 2);
 274     if (portion < 0)
 275         {
 276         return true;
 277         }
 278     dataLen += portion;
 279     }
 280
 281 if (CheckHeader(packetHead))
 282     {
 283     printfd(__FILE__, "Invalid packet or incorrect protocol version!\n");
 284     return true;
 285     }
 286
 287 std::string userLogin((char *)packetHead.login);
 288 PendingData data;
 289 data.login = userLogin;
 290 data.ip = ntohl(packetHead.ip);
 291 data.id = ntohl(packetHead.id);
 292
 293 if (packetHead.packetType == RS_ALIVE_PACKET)
 294     {
 295     data.type = PendingData::ALIVE;
 296     }
 297 else if (packetHead.packetType == RS_CONNECT_PACKET)
 298     {
 299     data.type = PendingData::CONNECT;
 300     if (GetParams(buffer, data))
 301         {
 302         return true;
 303         }
 304     }
 305 else if (packetHead.packetType == RS_DISCONNECT_PACKET)
 306     {
 307     data.type = PendingData::DISCONNECT;
 308     if (GetParams(buffer, data))
 309         {
 310         return true;
 311         }
 312     }
 313
 314 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 315 pending.push_back(data);
 316
 317 return false;
 318 }
 319 //-----------------------------------------------------------------------------
 320 bool LISTENER::GetParams(char * buffer, UserData & data)
 321 {
 322 RS::PACKET_TAIL packetTail;
 323
 324 Decrypt(&ctxS, (char *)&packetTail, buffer, sizeof(packetTail) / 8);
 325
 326 if (strncmp((char *)packetTail.magic, RS_ID, RS_MAGIC_LEN))
 327     {
 328     printfd(__FILE__, "Invalid crypto magic\n");
 329     return true;
 330     }
 331
 332 std::ostringstream params;
 333 params << "\"" << data.login << "\" "
 334        << inet_ntostring(data.ip) << " "
 335        << data.id << " "
 336        << (char *)packetTail.params;
 337
 338 data.params = params.str();
 339
 340 return false;
 341 }
 342 //-----------------------------------------------------------------------------
 343 void LISTENER::ProcessPending()
 344 {
 345 std::list<PendingData>::iterator it(pending.begin());
 346 size_t count = 0;
 347 printfd(__FILE__, "Pending: %d\n", pending.size());
 348 while (it != pending.end() && count < 256)
 349     {
 350     std::vector<AliveData>::iterator uit(
 351             std::lower_bound(
 352                 users.begin(),
 353                 users.end(),
 354                 it->login)
 355             );
 356     if (it->type == PendingData::CONNECT)
 357         {
 358         printfd(__FILE__, "Connect packet\n");
 359         if (uit == users.end() || uit->login != it->login)
 360             {
 361             printfd(__FILE__, "Connect new user '%s'\n", it->login.c_str());
 362             // Add new user
 363             Connect(*it);
 364             users.insert(uit, AliveData(static_cast<UserData>(*it)));
 365             }
 366         else if (uit->login == it->login)
 367             {
 368             printfd(__FILE__, "Update existing user '%s'\n", it->login.c_str());
 369             // Update already existing user
 370             time(&uit->lastAlive);
 371             uit->params = it->params;
 372             }
 373         else
 374             {
 375             printfd(__FILE__, "Hmmm... Strange connect for '%s'\n", it->login.c_str());
 376             }
 377         }
 378     else if (it->type == PendingData::ALIVE)
 379         {
 380         printfd(__FILE__, "Alive packet\n");
 381         if (uit != users.end() && uit->login == it->login)
 382             {
 383             printfd(__FILE__, "Alive user '%s'\n", it->login.c_str());
 384             // Update existing user
 385             time(&uit->lastAlive);
 386             }
 387         else
 388             {
 389             printfd(__FILE__, "Alive user '%s' is not found\n", it->login.c_str());
 390             }
 391         }
 392     else if (it->type == PendingData::DISCONNECT)
 393         {
 394         printfd(__FILE__, "Disconnect packet\n");
 395         if (uit != users.end() && uit->login == it->login.c_str())
 396             {
 397             printfd(__FILE__, "Disconnect user '%s'\n", it->login.c_str());
 398             // Disconnect existing user
 399             Disconnect(*uit);
 400             users.erase(uit);
 401             }
 402         else
 403             {
 404             printfd(__FILE__, "Cannot find user '%s' for disconnect\n", it->login.c_str());
 405             }
 406         }
 407     else
 408         {
 409         printfd(__FILE__, "Unknown packet type\n");
 410         }
 411     ++it;
 412     ++count;
 413     }
 414 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 415 pending.erase(pending.begin(), it);
 416 }
 417 //-----------------------------------------------------------------------------
 418 void LISTENER::ProcessTimeouts()
 419 {
 420 const std::vector<AliveData>::iterator it(
 421         std::stable_partition(
 422             users.begin(),
 423             users.end(),
 424             IsNotTimedOut(userTimeout)
 425         )
 426     );
 427
 428 if (it != users.end())
 429     {
 430     printfd(__FILE__, "Total users: %d, users to disconnect: %d\n", users.size(), std::distance(it, users.end()));
 431
 432     std::for_each(
 433             it,
 434             users.end(),
 435             DisconnectUser(*this)
 436         );
 437
 438     users.erase(it, users.end());
 439     }
 440 }
 441 //-----------------------------------------------------------------------------
 442 bool LISTENER::Connect(const UserData & data) const
 443 {
 444 printfd(__FILE__, "Connect %s\n", data.login.c_str());
 445 if (access(scriptOnConnect.c_str(), X_OK) == 0)
 446     {
 447     if (ScriptExec((scriptOnConnect + " " + data.params).c_str()))
 448         {
 449         WriteServLog("Script %s cannot be executed for an unknown reason.", scriptOnConnect.c_str());
 450         return true;
 451         }
 452     }
 453 else
 454     {
 455     WriteServLog("Script %s cannot be executed. File not found.", scriptOnConnect.c_str());
 456     return true;
 457     }
 458 return false;
 459 }
 460 //-----------------------------------------------------------------------------
 461 bool LISTENER::Disconnect(const UserData & data) const
 462 {
 463 printfd(__FILE__, "Disconnect %s\n", data.login.c_str());
 464 if (access(scriptOnDisconnect.c_str(), X_OK) == 0)
 465     {
 466     if (ScriptExec((scriptOnDisconnect + " " + data.params).c_str()))
 467         {
 468         WriteServLog("Script %s cannot be executed for an unknown reson.", scriptOnDisconnect.c_str());
 469         return true;
 470         }
 471     }
 472 else
 473     {
 474     WriteServLog("Script %s cannot be executed. File not found.", scriptOnDisconnect.c_str());
 475     return true;
 476     }
 477 return false;
 478 }
 479 //-----------------------------------------------------------------------------
 480 bool LISTENER::CheckHeader(const RS::PACKET_HEADER & header) const
 481 {
 482 if (strncmp((char *)header.magic, RS_ID, RS_MAGIC_LEN))
 483     {
 484     return true;
 485     }
 486 if (strncmp((char *)header.protoVer, "02", RS_PROTO_VER_LEN))
 487     {
 488     return true;
 489     }
 490 return false;
 491 }
 492 //-----------------------------------------------------------------------------
 493 inline
 494 void InitEncrypt(BLOWFISH_CTX * ctx, const std::string & password)
 495 {
 496 unsigned char keyL[PASSWD_LEN];
 497 memset(keyL, 0, PASSWD_LEN);
 498 strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
 499 Blowfish_Init(ctx, keyL, PASSWD_LEN);
 500 }
 501 //-----------------------------------------------------------------------------
 502 inline
 503 void Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8)
 504 {
 505 if (dst != src)
 506     memcpy(dst, src, len8 * 8);
 507
 508 for (int i = 0; i < len8; i++)
 509     Blowfish_Decrypt(ctx, (uint32_t *)(dst + i * 8), (uint32_t *)(dst + i * 8 + 4));
 510 }
 511 //-----------------------------------------------------------------------------