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