Patch from SpiderX <spiderx@spiderx.dp.ua> - scripts.

[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 e28aad8f9c6c1fe7115a948eb0d27bb16ce1b9b3..08fd65128d835839cffbae170144d99014a06529 100644 (file)
--- a/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
+++ b/projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
@@ -38,17 +38,18 @@
 #include <functional>
 #include <utility>
 
 #include <functional>
 #include <utility>
 

-#include "os_int.h"
-#include "auth.h"
-#include "store.h"
-#include "notifer.h"
-#include "user_ips.h"
-#include "user.h"
-#include "users.h"
-#include "ia_packets.h"
-#include "blowfish.h"
-#include "stg_logger.h"
-#include "utime.h"
+#include "stg/os_int.h"
+#include "stg/auth.h"
+#include "stg/store.h"
+#include "stg/notifer.h"
+#include "stg/user_ips.h"
+#include "stg/user.h"
+#include "stg/users.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();
 
 
 extern "C" PLUGIN * GetPlugin();
 


@@ -118,40 +119,72 @@ private:
 //-----------------------------------------------------------------------------
 struct IA_USER {
     IA_USER()
 //-----------------------------------------------------------------------------
 struct IA_USER {
     IA_USER()

-        : lastSendAlive(0),
+        : login(),
+          user(NULL),
+          phase(),
+          lastSendAlive(0),

           rnd(random()),
           port(0),
           rnd(random()),
           port(0),

+          ctx(),
+          messagesToSend(),

           protoVer(0),
           password("NO PASSWORD")
     {
           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
+    unsigned char keyL[PASSWD_LEN];
+    memset(keyL, 0, PASSWD_LEN);
+    strncpy((char *)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));

     };
 
     };
 

-    USER_PTR        user;
+    IA_USER(const std::string & l,
+            CONST_USER_PTR u,
+            uint16_t p,
+            int ver)
+        : login(l),
+          user(u),
+          phase(),
+          lastSendAlive(0),
+          rnd(random()),
+          port(p),
+          ctx(),
+          messagesToSend(),
+          protoVer(ver),
+          password(user->GetProperty().password.Get())
+    {
+    unsigned char keyL[PASSWD_LEN];
+    memset(keyL, 0, PASSWD_LEN);
+    strncpy((char *)keyL, password.c_str(), PASSWD_LEN);
+    Blowfish_Init(&ctx, keyL, PASSWD_LEN);
+
+    #ifdef IA_DEBUG
+    aliveSent = false;
+    #endif
+    }
+
+    std::string     login;
+    CONST_USER_PTR  user;

     IA_PHASE        phase;
     UTIME           lastSendAlive;
     uint32_t        rnd;
     IA_PHASE        phase;
     UTIME           lastSendAlive;
     uint32_t        rnd;


@@ -163,6 +196,9 @@ struct IA_USER {
     #ifdef IA_DEBUG
     bool            aliveSent;
     #endif
     #ifdef IA_DEBUG
     bool            aliveSent;
     #endif

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

 };
 //-----------------------------------------------------------------------------
 class AUTH_IA_SETTINGS {
 };
 //-----------------------------------------------------------------------------
 class AUTH_IA_SETTINGS {


@@ -177,7 +213,6 @@ public:
     FREEMB          GetFreeMbShowType() const { return freeMbShowType; };
 
 private:
     FREEMB          GetFreeMbShowType() const { return freeMbShowType; };
 
 private:

-    int             ParseIntInRange(const std::string & str, int min, int max, int * val);

     int             userDelay;
     int             userTimeout;
     uint16_t        port;
     int             userDelay;
     int             userTimeout;
     uint16_t        port;


@@ -194,6 +229,9 @@ public:
 
     void Notify(const USER_PTR & user);
 private:
 
     void Notify(const USER_PTR & user);
 private:

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

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


@@ -204,10 +242,6 @@ public:
     virtual             ~AUTH_IA();
 
     void                SetUsers(USERS * u) { users = u; }
     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();
     void                SetStgSettings(const SETTINGS * s) { stgSettings = s; }
     void                SetSettings(const MODULE_SETTINGS & s) { settings = s; }
     int                 ParseSettings();


@@ -219,12 +253,15 @@ public:
 
     const std::string & GetStrError() const { return errorStr; }
     const std::string   GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
 
     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; }
+    uint16_t            GetStartPosition() const { return 30; }
+    uint16_t            GetStopPosition() const { return 30; }

 
     int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
 
 private:
 
     int                 SendMessage(const STG_MSG & msg, uint32_t ip) const;
 
 private:

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

     static void *       Run(void *);
     static void *       RunTimeouter(void * d);
     int                 PrepareNet();
     static void *       Run(void *);
     static void *       RunTimeouter(void * d);
     int                 PrepareNet();


@@ -232,7 +269,7 @@ private:
     void                DelUser(USER_PTR u);
     int                 RecvData(char * buffer, int bufferSize);
     int                 CheckHeader(const char * buffer, int * protoVer);
     void                DelUser(USER_PTR u);
     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                 PacketProcessor(char * buff, int dataLen, uint32_t sip, uint16_t sport, int protoVer, USER_PTR 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);


@@ -287,8 +324,6 @@ private:
     int                 RealSendMessage7(const STG_MSG & msg, uint32_t ip, IA_USER & user);
     int                 RealSendMessage8(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;
-

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


@@ -324,23 +359,27 @@ 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;
-    };
+    PLUGIN_LOGGER       logger;

 
 

+    friend class UnauthorizeUser;
+};
+//-----------------------------------------------------------------------------
+class UnauthorizeUser : std::unary_function<const std::pair<uint32_t, IA_USER> &, void> {
+    public:
+        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