stargazer/plugins/authorization/inetaccess/inetaccess.h

   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  */
  20
  21 /*
  22  $Revision: 1.34 $
  23  $Date: 2010/09/10 06:39:19 $
  24  $Author: faust $
  25  */
  26
  27 #ifndef INETACCESS_H
  28 #define INETACCESS_H
  29
  30 #include "stg/auth.h"
  31 #include "stg/store.h"
  32 #include "stg/notifer.h"
  33 #include "stg/user_ips.h"
  34 #include "stg/user.h"
  35 #include "stg/users.h"
  36 #include "stg/ia_packets.h"
  37 #include "stg/blowfish.h"
  38 #include "stg/logger.h"
  39 #include "stg/utime.h"
  40 #include "stg/logger.h"
  41
  42 #include <cstring>
  43 #include <ctime>
  44 #include <cstdint>
  45 #include <string>
  46 #include <map>
  47 #include <list>
  48 #include <functional>
  49 #include <utility>
  50
  51 #include <sys/time.h>
  52 #include <pthread.h>
  53
  54 #define IA_PROTO_VER    (6)
  55
  56 //#define IA_DEBUG (1)
  57 //#define IA_PHASE_DEBUG (1)
  58
  59 class AUTH_IA;
  60 //-----------------------------------------------------------------------------
  61 enum FREEMB {
  62     freeMb0 = 0,
  63     freeMb1,
  64     freeMb2,
  65     freeMb3,
  66     freeMb4,
  67     freeMb5,
  68     freeMb6,
  69     freeMb7,
  70     freeMb8,
  71     freeMb9,
  72     freeMb10,
  73     freeMb11,
  74     freeMb12,
  75     freeMb13,
  76     freeMb14,
  77     freeMb15,
  78     freeMb16,
  79     freeMb17,
  80     freeMb18,
  81     freeMb19,
  82     freeMbCash = 100,
  83     freeMbNone = 101
  84 };
  85 //-----------------------------------------------------------------------------
  86 class IA_PHASE {
  87 public:
  88     IA_PHASE();
  89     ~IA_PHASE();
  90
  91     void    SetPhase1();
  92     void    SetPhase2();
  93     void    SetPhase3();
  94     void    SetPhase4();
  95     int     GetPhase() const;
  96
  97     void    UpdateTime();
  98     const UTIME & GetTime() const;
  99
 100     #ifdef IA_PHASE_DEBUG
 101     void    SetUserLogin(const std::string & login);
 102     void    SetLogFileName(const std::string & logFileName);
 103     #endif
 104
 105 private:
 106     int             phase;
 107     UTIME           phaseTime;
 108
 109     #ifdef IA_PHASE_DEBUG
 110     void WritePhaseChange(int newPhase);
 111     std::string log;
 112     std::string login;
 113     FILE * flog;
 114     #endif
 115 };
 116 //-----------------------------------------------------------------------------
 117 struct IA_USER {
 118     IA_USER()
 119         : login(),
 120           user(NULL),
 121           phase(),
 122           lastSendAlive(0),
 123           rnd(static_cast<uint32_t>(random())),
 124           port(0),
 125           ctx(),
 126           messagesToSend(),
 127           protoVer(0),
 128           password("NO PASSWORD")
 129     {
 130     unsigned char keyL[PASSWD_LEN];
 131     memset(keyL, 0, PASSWD_LEN);
 132     strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
 133     Blowfish_Init(&ctx, keyL, PASSWD_LEN);
 134
 135     #ifdef IA_DEBUG
 136     aliveSent = false;
 137     #endif
 138     }
 139
 140     IA_USER(const IA_USER & u)
 141         : login(u.login),
 142           user(u.user),
 143           phase(u.phase),
 144           lastSendAlive(u.lastSendAlive),
 145           rnd(u.rnd),
 146           port(u.port),
 147           ctx(),
 148           messagesToSend(u.messagesToSend),
 149           protoVer(u.protoVer),
 150           password(u.password)
 151     {
 152     #ifdef IA_DEBUG
 153     aliveSent  = u.aliveSent;
 154     #endif
 155     memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
 156     }
 157
 158     IA_USER(const std::string & l,
 159             CONST_USER_PTR u,
 160             uint16_t p,
 161             int ver)
 162         : login(l),
 163           user(u),
 164           phase(),
 165           lastSendAlive(0),
 166           rnd(static_cast<uint32_t>(random())),
 167           port(p),
 168           ctx(),
 169           messagesToSend(),
 170           protoVer(ver),
 171           password(user->GetProperty().password.Get())
 172     {
 173     unsigned char keyL[PASSWD_LEN];
 174     memset(keyL, 0, PASSWD_LEN);
 175     strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
 176     Blowfish_Init(&ctx, keyL, PASSWD_LEN);
 177
 178     #ifdef IA_DEBUG
 179     aliveSent = false;
 180     #endif
 181     }
 182
 183     std::string     login;
 184     CONST_USER_PTR  user;
 185     IA_PHASE        phase;
 186     UTIME           lastSendAlive;
 187     uint32_t        rnd;
 188     uint16_t        port;
 189     BLOWFISH_CTX    ctx;
 190     std::list<STG_MSG> messagesToSend;
 191     int             protoVer;
 192     std::string     password;
 193     #ifdef IA_DEBUG
 194     bool            aliveSent;
 195     #endif
 196
 197 private:
 198     IA_USER & operator=(const IA_USER & rvalue);
 199 };
 200 //-----------------------------------------------------------------------------
 201 class AUTH_IA_SETTINGS {
 202 public:
 203                     AUTH_IA_SETTINGS();
 204     virtual         ~AUTH_IA_SETTINGS() {}
 205     const std::string & GetStrError() const { return errorStr; }
 206     int             ParseSettings(const MODULE_SETTINGS & s);
 207     UTIME           GetUserDelay() const { return UTIME(userDelay); }
 208     UTIME           GetUserTimeout() const { return UTIME(userTimeout); }
 209     uint16_t        GetUserPort() const { return port; }
 210     FREEMB          GetFreeMbShowType() const { return freeMbShowType; }
 211     bool            LogProtocolErrors() const { return logProtocolErrors; }
 212
 213 private:
 214     int             userDelay;
 215     int             userTimeout;
 216     uint16_t        port;
 217     std::string     errorStr;
 218     FREEMB          freeMbShowType;
 219     bool            logProtocolErrors;
 220 };
 221 //-----------------------------------------------------------------------------
 222 class AUTH_IA;
 223 //-----------------------------------------------------------------------------
 224 class DEL_USER_NOTIFIER: public NOTIFIER_BASE<USER_PTR> {
 225 public:
 226     explicit DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}
 227     virtual ~DEL_USER_NOTIFIER() {}
 228
 229     void Notify(const USER_PTR & user);
 230 private:
 231     DEL_USER_NOTIFIER(const DEL_USER_NOTIFIER & rvalue);
 232     DEL_USER_NOTIFIER & operator=(const DEL_USER_NOTIFIER & rvalue);
 233
 234     AUTH_IA & auth;
 235 };
 236 //-----------------------------------------------------------------------------
 237 class AUTH_IA :public AUTH {
 238 friend class DEL_USER_NOTIFIER;
 239 public:
 240                         AUTH_IA();
 241     virtual             ~AUTH_IA();
 242
 243     void                SetUsers(USERS * u) { users = u; }
 244     void                SetStgSettings(const SETTINGS * s) { stgSettings = s; }
 245     void                SetSettings(const MODULE_SETTINGS & s) { settings = s; }
 246     int                 ParseSettings();
 247
 248     int                 Start();
 249     int                 Stop();
 250     int                 Reload(const MODULE_SETTINGS & ms);
 251     bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; }
 252
 253     const std::string & GetStrError() const { return errorStr; }
 254     std::string         GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
 255     uint16_t            GetStartPosition() const { return 30; }
 256     uint16_t            GetStopPosition() const { return 30; }
 257
 258     int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
 259
 260 private:
 261     AUTH_IA(const AUTH_IA & rvalue);
 262     AUTH_IA & operator=(const AUTH_IA & rvalue);
 263
 264     static void *       Run(void *);
 265     static void *       RunTimeouter(void * d);
 266     int                 PrepareNet();
 267     int                 FinalizeNet();
 268     void                DelUser(USER_PTR u);
 269     int                 RecvData(char * buffer, int bufferSize);
 270     int                 CheckHeader(const char * buffer, uint32_t sip, int * protoVer);
 271     int                 PacketProcessor(void * buff, size_t dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR user);
 272
 273     int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, uint32_t sip);
 274     int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, uint32_t sip);
 275     int                 Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, uint32_t sip);
 276
 277     int                 Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, uint32_t sip);
 278     int                 Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, uint32_t sip);
 279     int                 Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, uint32_t sip);
 280
 281     int                 Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, uint32_t sip);
 282     int                 Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, uint32_t sip);
 283     int                 Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, uint32_t sip);
 284
 285     int                 Process_DISCONN_SYN_6(DISCONN_SYN_6 * disconnSyn, IA_USER * iaUser, uint32_t sip);
 286     int                 Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, uint32_t sip);
 287     int                 Process_DISCONN_SYN_8(DISCONN_SYN_8 * disconnSyn, IA_USER * iaUser, uint32_t sip);
 288
 289     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
 290                                               IA_USER * iaUser,
 291                                               uint32_t sip,
 292                                               std::map<uint32_t, IA_USER>::iterator it);
 293     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
 294                                               IA_USER * iaUser,
 295                                               uint32_t sip,
 296                                               std::map<uint32_t, IA_USER>::iterator it);
 297     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
 298                                               IA_USER * iaUser,
 299                                               uint32_t sip,
 300                                               std::map<uint32_t, IA_USER>::iterator it);
 301
 302     int                 Send_CONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
 303     int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
 304     int                 Send_CONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
 305
 306     int                 Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip);
 307     int                 Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip);
 308     int                 Send_ALIVE_SYN_8(IA_USER * iaUser, uint32_t sip);
 309
 310     int                 Send_DISCONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
 311     int                 Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
 312     int                 Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
 313
 314     int                 Send_FIN_6(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
 315     int                 Send_FIN_7(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
 316     int                 Send_FIN_8(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
 317
 318     int                 Timeouter();
 319
 320     int                 SendError(uint32_t ip, uint16_t port, int protoVer, const std::string & text);
 321     int                 Send(uint32_t ip, uint16_t port, const char * buffer, size_t len);
 322     int                 RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user);
 323     int                 RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
 324     int                 RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user);
 325
 326     BLOWFISH_CTX        ctxS;        //for loginS
 327
 328     mutable std::string errorStr;
 329     AUTH_IA_SETTINGS    iaSettings;
 330     MODULE_SETTINGS     settings;
 331
 332     bool                nonstop;
 333
 334     bool                isRunningRun;
 335     bool                isRunningRunTimeouter;
 336
 337     USERS *             users;
 338     const SETTINGS *    stgSettings;
 339
 340     mutable std::map<uint32_t, IA_USER> ip2user;
 341
 342     pthread_t           recvThread;
 343     pthread_t           timeouterThread;
 344     mutable pthread_mutex_t mutex;
 345
 346     int                 listenSocket;
 347
 348     CONN_SYN_ACK_6      connSynAck6;
 349     CONN_SYN_ACK_8      connSynAck8;
 350
 351     DISCONN_SYN_ACK_6   disconnSynAck6;
 352     DISCONN_SYN_ACK_8   disconnSynAck8;
 353
 354     ALIVE_SYN_6         aliveSyn6;
 355     ALIVE_SYN_8         aliveSyn8;
 356     FIN_6               fin6;
 357     FIN_8               fin8;
 358
 359     std::map<std::string, int> packetTypes;
 360
 361     uint32_t            enabledDirs;
 362
 363     DEL_USER_NOTIFIER   onDelUserNotifier;
 364
 365     PLUGIN_LOGGER       logger;
 366
 367     friend class UnauthorizeUser;
 368 };
 369 //-----------------------------------------------------------------------------
 370 class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
 371     public:
 372         explicit UnauthorizeUser(AUTH_IA * a) : auth(a) {}
 373         UnauthorizeUser(const UnauthorizeUser & rvalue) : auth(rvalue.auth) {}
 374         void operator()(const std::pair<uint32_t, IA_USER> & p)
 375         {
 376             auth->users->Unauthorize(p.second.user->GetLogin(), auth);
 377         }
 378     private:
 379         UnauthorizeUser & operator=(const UnauthorizeUser & rvalue);
 380
 381         AUTH_IA * auth;
 382 };
 383 //-----------------------------------------------------------------------------
 384 inline
 385 void DEL_USER_NOTIFIER::Notify(const USER_PTR & user)
 386 {
 387     auth.DelUser(user);
 388 }
 389
 390 #endif