Use async pool instead of EVENT_LOOP.

[stg.git] / projects / stargazer / plugins / authorization / inetaccess / inetaccess.h

diff --git a/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h b/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
index fe55649590990306bbeeee1a87d326b9def40a49..f9137c20437446a691a900556c1ff02565f8f2cf 100644 (file)
--- a/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
+++ b/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
@@ -17,42 +17,37 @@
 /*
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */
 /*
  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  */

+#pragma once

 
 

-/*
- $Revision: 1.34 $
- $Date: 2010/09/10 06:39:19 $
- $Author: faust $
- */
-
-#ifndef INETACCESS_H
-#define INETACCESS_H
-
-#include <sys/time.h>
-#include <pthread.h>
-
-#include <cstring>
-#include <ctime>
-#include <string>
-#include <map>
-#include <list>
-#include <functional>
-#include <utility>
-
-#include "stg/os_int.h"

 #include "stg/auth.h"
 #include "stg/store.h"
 #include "stg/auth.h"
 #include "stg/store.h"

+#include "stg/module_settings.h"

 #include "stg/notifer.h"
 #include "stg/user_ips.h"
 #include "stg/user.h"
 #include "stg/users.h"
 #include "stg/notifer.h"
 #include "stg/user_ips.h"
 #include "stg/user.h"
 #include "stg/users.h"

+#include "stg/user_property.h"

 #include "stg/ia_packets.h"
 #include "stg/blowfish.h"
 #include "stg/logger.h"
 #include "stg/utime.h"
 #include "stg/ia_packets.h"
 #include "stg/blowfish.h"
 #include "stg/logger.h"
 #include "stg/utime.h"

+#include "stg/logger.h"

 
 

-extern "C" PLUGIN * GetPlugin();
+#include <cstring>
+#include <ctime>
+#include <cstdint>
+#include <string>
+#include <map>
+#include <list>
+#include <functional>
+#include <utility>
+#include <mutex>
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#include <jthread.hpp>
+#pragma GCC diagnostic pop

 
 

-#define IA_PROTO_VER    (6)
+#include <sys/time.h>

 
 //#define IA_DEBUG (1)
 //#define IA_PHASE_DEBUG (1)
 
 //#define IA_DEBUG (1)
 //#define IA_PHASE_DEBUG (1)


@@ -93,7 +88,6 @@ public:
     void    SetPhase2();
     void    SetPhase3();
     void    SetPhase4();
     void    SetPhase2();
     void    SetPhase3();
     void    SetPhase4();

-    void    SetPhase5();

     int     GetPhase() const;
 
     void    UpdateTime();
     int     GetPhase() const;
 
     void    UpdateTime();


@@ -117,65 +111,95 @@ private:
 };
 //-----------------------------------------------------------------------------
 struct IA_USER {
 };
 //-----------------------------------------------------------------------------
 struct IA_USER {

+    using ConstUserPtr = const STG::User*;

     IA_USER()
         : user(NULL),
           lastSendAlive(0),
     IA_USER()
         : user(NULL),
           lastSendAlive(0),

-          rnd(random()),
+          rnd(static_cast<uint32_t>(random())),

           port(0),
           protoVer(0),
           password("NO PASSWORD")
     {
           port(0),
           protoVer(0),
           password("NO PASSWORD")
     {

-        // +++ Preparing CTX +++
-        unsigned char keyL[PASSWD_LEN];
-        memset(keyL, 0, PASSWD_LEN);
-        strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
-        Blowfish_Init(&ctx, keyL, PASSWD_LEN);
-        // --- Preparing CTX ---
-        #ifdef IA_DEBUG
-        aliveSent = false;
-        #endif
-    };
+    char keyL[PASSWD_LEN];
+    memset(keyL, 0, PASSWD_LEN);
+    strncpy(keyL, password.c_str(), PASSWD_LEN);
+    Blowfish_Init(&ctx, keyL, PASSWD_LEN);
+
+    #ifdef IA_DEBUG
+    aliveSent = false;
+    #endif
+    }

 
     IA_USER(const IA_USER & u)
 
     IA_USER(const IA_USER & u)

-        : user(u.user),
+        : login(u.login),
+          user(u.user),

           phase(u.phase),
           lastSendAlive(u.lastSendAlive),
           rnd(u.rnd),
           port(u.port),
           phase(u.phase),
           lastSendAlive(u.lastSendAlive),
           rnd(u.rnd),
           port(u.port),

+          ctx(),

           messagesToSend(u.messagesToSend),
           protoVer(u.protoVer),
           password(u.password)
     {
           messagesToSend(u.messagesToSend),
           protoVer(u.protoVer),
           password(u.password)
     {

-        #ifdef IA_DEBUG
-        aliveSent  = u.aliveSent;
-        #endif
-        memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
-    };
+    #ifdef IA_DEBUG
+    aliveSent  = u.aliveSent;
+    #endif
+    memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
+    }
+
+    IA_USER(const std::string & l,
+            ConstUserPtr u,
+            uint16_t p,
+            int ver)
+        : login(l),
+          user(u),
+          lastSendAlive(0),
+          rnd(static_cast<uint32_t>(random())),
+          port(p),
+          messagesToSend(),
+          protoVer(ver),
+          password(user->GetProperties().password.Get())
+    {
+    char keyL[PASSWD_LEN];
+    memset(keyL, 0, PASSWD_LEN);
+    strncpy(keyL, password.c_str(), PASSWD_LEN);
+    Blowfish_Init(&ctx, keyL, PASSWD_LEN);

 
 

-    USER_PTR        user;
+    #ifdef IA_DEBUG
+    aliveSent = false;
+    #endif
+    }
+
+    std::string     login;
+    ConstUserPtr  user;

     IA_PHASE        phase;
     UTIME           lastSendAlive;
     uint32_t        rnd;
     uint16_t        port;
     BLOWFISH_CTX    ctx;
     IA_PHASE        phase;
     UTIME           lastSendAlive;
     uint32_t        rnd;
     uint16_t        port;
     BLOWFISH_CTX    ctx;

-    std::list<STG_MSG> messagesToSend;
+    std::vector<STG::Message> messagesToSend;

     int             protoVer;
     std::string     password;
     #ifdef IA_DEBUG
     bool            aliveSent;
     #endif
     int             protoVer;
     std::string     password;
     #ifdef IA_DEBUG
     bool            aliveSent;
     #endif

+
+private:
+    IA_USER & operator=(const IA_USER & rvalue);

 };
 //-----------------------------------------------------------------------------
 class AUTH_IA_SETTINGS {
 public:
                     AUTH_IA_SETTINGS();
 };
 //-----------------------------------------------------------------------------
 class AUTH_IA_SETTINGS {
 public:
                     AUTH_IA_SETTINGS();

-    virtual         ~AUTH_IA_SETTINGS() {};
-    const std::string & GetStrError() const { return errorStr; };
-    int             ParseSettings(const MODULE_SETTINGS & s);
-    int             GetUserDelay() const { return userDelay; };
-    int             GetUserTimeout() const { return userTimeout; };
-    int             GetUserPort() const { return port; };
-    FREEMB          GetFreeMbShowType() const { return freeMbShowType; };
+    virtual         ~AUTH_IA_SETTINGS() {}
+    const std::string & GetStrError() const { return errorStr; }
+    int             ParseSettings(const STG::ModuleSettings & s);
+    UTIME           GetUserDelay() const { return UTIME(userDelay); }
+    UTIME           GetUserTimeout() const { return UTIME(userTimeout); }
+    uint16_t        GetUserPort() const { return port; }
+    FREEMB          GetFreeMbShowType() const { return freeMbShowType; }
+    bool            LogProtocolErrors() const { return logProtocolErrors; }

 
 private:
     int             userDelay;
 
 private:
     int             userDelay;


@@ -183,56 +207,60 @@ private:
     uint16_t        port;
     std::string     errorStr;
     FREEMB          freeMbShowType;
     uint16_t        port;
     std::string     errorStr;
     FREEMB          freeMbShowType;

+    bool            logProtocolErrors;

 };
 //-----------------------------------------------------------------------------
 class AUTH_IA;
 };
 //-----------------------------------------------------------------------------
 class AUTH_IA;

+using UserPtr = STG::User*;

 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

-class DEL_USER_NOTIFIER: public NOTIFIER_BASE<USER_PTR> {
+class DEL_USER_NOTIFIER: public STG::NotifierBase<UserPtr> {

 public:
 public:

-    DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}
+    explicit DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}

     virtual ~DEL_USER_NOTIFIER() {}
 
     virtual ~DEL_USER_NOTIFIER() {}
 

-    void Notify(const USER_PTR & user);
+    void notify(const UserPtr & user) override;

 private:
 private:

+    DEL_USER_NOTIFIER(const DEL_USER_NOTIFIER & rvalue);
+    DEL_USER_NOTIFIER & operator=(const DEL_USER_NOTIFIER & rvalue);
+

     AUTH_IA & auth;
 };
 //-----------------------------------------------------------------------------
     AUTH_IA & auth;
 };
 //-----------------------------------------------------------------------------

-class AUTH_IA :public AUTH {
+class AUTH_IA : public STG::Auth {

 friend class DEL_USER_NOTIFIER;
 public:
                         AUTH_IA();
 friend class DEL_USER_NOTIFIER;
 public:
                         AUTH_IA();

-    virtual             ~AUTH_IA();
-
-    void                SetUsers(USERS * u) { users = u; }
-    void                SetTariffs(TARIFFS *) {}
-    void                SetAdmins(ADMINS *) {}
-    void                SetTraffcounter(TRAFFCOUNTER *) {}
-    void                SetStore(STORE *) {}
-    void                SetStgSettings(const SETTINGS * s) { stgSettings = s; }
-    void                SetSettings(const MODULE_SETTINGS & s) { settings = s; }
-    int                 ParseSettings();
-
-    int                 Start();
-    int                 Stop();
-    int                 Reload() { return 0; }
-    bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; }
+                        ~AUTH_IA() override;

 
 

-    const std::string & GetStrError() const { return errorStr; }
-    const std::string   GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
-    uint16_t            GetStartPosition() const { return 50; }
-    uint16_t            GetStopPosition() const { return 50; }
+    void                SetUsers(STG::Users * u) override { users = u; }
+    void                SetStgSettings(const STG::Settings * s) override { stgSettings = s; }
+    void                SetSettings(const STG::ModuleSettings & s) override { settings = s; }
+    int                 ParseSettings() override;
+
+    int                 Start() override;
+    int                 Stop() override;
+    int                 Reload(const STG::ModuleSettings & ms) override;
+    bool                IsRunning() override { return isRunningRunTimeouter || isRunningRun; }

 
 

-    int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
+    const std::string & GetStrError() const override { return errorStr; }
+    std::string         GetVersion() const override { return "InetAccess authorization plugin v.1.4"; }
+    uint16_t            GetStartPosition() const override { return 30; }
+    uint16_t            GetStopPosition() const override { return 30; }
+
+    int                 SendMessage(const STG::Message & msg, uint32_t ip) const override;

 
 private:
 
 private:

-    static void *       Run(void *);
-    static void *       RunTimeouter(void * d);
+    AUTH_IA(const AUTH_IA & rvalue);
+    AUTH_IA & operator=(const AUTH_IA & rvalue);
+
+    void                Run(std::stop_token token);
+    void                RunTimeouter(std::stop_token token);

     int                 PrepareNet();
     int                 FinalizeNet();
     int                 PrepareNet();
     int                 FinalizeNet();

-    void                DelUser(USER_PTR u);
+    void                DelUser(UserPtr u);

     int                 RecvData(char * buffer, int bufferSize);
     int                 RecvData(char * buffer, int bufferSize);

-    int                 CheckHeader(const char * buffer, int * protoVer);
-    int                 PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR * user);
+    int                 CheckHeader(const char * buffer, uint32_t sip, int * protoVer);
+    int                 PacketProcessor(void * buff, size_t dataLen, uint32_t sip, uint16_t sport, int protoVer, UserPtr user);

 
     int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, uint32_t sip);
     int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, uint32_t sip);
 
     int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, uint32_t sip);
     int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, uint32_t sip);


@@ -253,15 +281,15 @@ private:
     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,
     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,

-                                              map<uint32_t, IA_USER>::iterator it);
+                                              std::map<uint32_t, IA_USER>::iterator it);

     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,
     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,

-                                              map<uint32_t, IA_USER>::iterator it);
+                                              std::map<uint32_t, IA_USER>::iterator it);

     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,
     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
                                               IA_USER * iaUser,
                                               uint32_t sip,

-                                              map<uint32_t, IA_USER>::iterator it);
+                                              std::map<uint32_t, IA_USER>::iterator it);

 
     int                 Send_CONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
     int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
 
     int                 Send_CONN_SYN_ACK_6(IA_USER * iaUser, uint32_t sip);
     int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);


@@ -275,39 +303,35 @@ private:
     int                 Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
     int                 Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
 
     int                 Send_DISCONN_SYN_ACK_7(IA_USER * iaUser, uint32_t sip);
     int                 Send_DISCONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
 

-    int                 Send_FIN_6(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
-    int                 Send_FIN_7(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
-    int                 Send_FIN_8(IA_USER * iaUser, uint32_t sip, map<uint32_t, IA_USER>::iterator it);
+    int                 Send_FIN_6(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
+    int                 Send_FIN_7(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);
+    int                 Send_FIN_8(IA_USER * iaUser, uint32_t sip, std::map<uint32_t, IA_USER>::iterator it);

 
     int                 Timeouter();
 
     int                 SendError(uint32_t ip, uint16_t port, int protoVer, const std::string & text);
 
     int                 Timeouter();
 
     int                 SendError(uint32_t ip, uint16_t port, int protoVer, const std::string & text);

-    int                 Send(uint32_t ip, uint16_t port, const char * buffer, int len);
-    int                 RealSendMessage6(const STG_MSG & msg, uint32_t ip, IA_USER & user);
-    int                 RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
-    int                 RealSendMessage8(const STG_MSG & msg, uint32_t ip, IA_USER & user);
-
-    bool                WaitPackets(int sd) const;
+    int                 Send(uint32_t ip, uint16_t port, const void* buffer, size_t len);
+    int                 RealSendMessage6(const STG::Message & msg, uint32_t ip, IA_USER & user);
+    int                 RealSendMessage7(const STG::Message & msg, uint32_t ip, IA_USER & user);
+    int                 RealSendMessage8(const STG::Message & msg, uint32_t ip, IA_USER & user);

 
     BLOWFISH_CTX        ctxS;        //for loginS
 
     mutable std::string errorStr;
     AUTH_IA_SETTINGS    iaSettings;
 
     BLOWFISH_CTX        ctxS;        //for loginS
 
     mutable std::string errorStr;
     AUTH_IA_SETTINGS    iaSettings;

-    MODULE_SETTINGS     settings;
-
-    bool                nonstop;
+    STG::ModuleSettings settings;

 
     bool                isRunningRun;
     bool                isRunningRunTimeouter;
 
 
     bool                isRunningRun;
     bool                isRunningRunTimeouter;
 

-    USERS *             users;
-    const SETTINGS *    stgSettings;
+    STG::Users *             users;
+    const STG::Settings *    stgSettings;

 
     mutable std::map<uint32_t, IA_USER> ip2user;
 
 
     mutable std::map<uint32_t, IA_USER> ip2user;
 

-    pthread_t           recvThread;
-    pthread_t           timeouterThread;
-    mutable pthread_mutex_t mutex;
+    std::jthread        m_thread;
+    std::jthread        m_timeouterThread;
+    mutable std::mutex  m_mutex;

 
     int                 listenSocket;
 
 
     int                 listenSocket;
 


@@ -324,29 +348,31 @@ private:
 
     std::map<std::string, int> packetTypes;
 
 
     std::map<std::string, int> packetTypes;
 

-    STG_LOGGER &        WriteServLog;
-

     uint32_t            enabledDirs;
 
     DEL_USER_NOTIFIER   onDelUserNotifier;
 
     uint32_t            enabledDirs;
 
     DEL_USER_NOTIFIER   onDelUserNotifier;
 

-    class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
-        public:
-            UnauthorizeUser(AUTH_IA * a) : auth(a) {}
-            void operator()(const std::pair<uint32_t, IA_USER> & p)
-            {
-                p.second.user->Unauthorize(auth);
-            }
-        private:
-            AUTH_IA * auth;
-    };
+    STG::PluginLogger   logger;

 
 

+    friend class UnauthorizeUser;
+};
+//-----------------------------------------------------------------------------
+class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
+    public:
+        explicit UnauthorizeUser(AUTH_IA * a) : auth(a) {}
+        UnauthorizeUser(const UnauthorizeUser & rvalue) : auth(rvalue.auth) {}
+        void operator()(const std::pair<uint32_t, IA_USER> & p)
+        {
+            auth->users->Unauthorize(p.second.user->GetLogin(), auth);
+        }
+    private:
+        UnauthorizeUser & operator=(const UnauthorizeUser & rvalue);
+
+        AUTH_IA * auth;

 };
 //-----------------------------------------------------------------------------
 inline
 };
 //-----------------------------------------------------------------------------
 inline

-void DEL_USER_NOTIFIER::Notify(const USER_PTR & user)
+void DEL_USER_NOTIFIER::notify(const UserPtr & user)

 {
     auth.DelUser(user);
 }
 {
     auth.DelUser(user);
 }

-
-#endif