]> git.stg.codes - stg.git/blobdiff - projects/stargazer/plugins/authorization/inetaccess/inetaccess.h
Added assignment operator for SGCONF::OPTION.
[stg.git] / projects / stargazer / plugins / authorization / inetaccess / inetaccess.h
index 0e194db6d18e6ba8b099d1365d7c448dbddc0971..873505566c8e699458d4eaf27324b956844774b6 100644 (file)
 
 #include <sys/time.h>
 #include <pthread.h>
 
 #include <sys/time.h>
 #include <pthread.h>
+
 #include <cstring>
 #include <ctime>
 #include <string>
 #include <map>
 #include <cstring>
 #include <ctime>
 #include <string>
 #include <map>
+#include <list>
 #include <functional>
 #include <utility>
 
 #include <functional>
 #include <utility>
 
-#include "os_int.h"
-#include "base_auth.h"
-#include "base_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"
-
-using namespace std;
-
-extern "C" BASE_PLUGIN * GetPlugin();
+#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"
 
 #define IA_PROTO_VER    (6)
 
 
 #define IA_PROTO_VER    (6)
 
@@ -59,8 +58,7 @@ extern "C" BASE_PLUGIN * GetPlugin();
 
 class AUTH_IA;
 //-----------------------------------------------------------------------------
 
 class AUTH_IA;
 //-----------------------------------------------------------------------------
-enum FREEMB
-{
+enum FREEMB {
     freeMb0 = 0,
     freeMb1,
     freeMb2,
     freeMb0 = 0,
     freeMb1,
     freeMb2,
@@ -85,8 +83,7 @@ enum FREEMB
     freeMbNone = 101
 };
 //-----------------------------------------------------------------------------
     freeMbNone = 101
 };
 //-----------------------------------------------------------------------------
-class IA_PHASE
-{
+class IA_PHASE {
 public:
     IA_PHASE();
     ~IA_PHASE();
 public:
     IA_PHASE();
     ~IA_PHASE();
@@ -102,8 +99,8 @@ public:
     const UTIME & GetTime() const;
 
     #ifdef IA_PHASE_DEBUG
     const UTIME & GetTime() const;
 
     #ifdef IA_PHASE_DEBUG
-    void    SetUserLogin(const string & login);
-    void    SetLogFileName(const string & logFileName);
+    void    SetUserLogin(const std::string & login);
+    void    SetLogFileName(const std::string & logFileName);
     #endif
 
 private:
     #endif
 
 private:
@@ -112,159 +109,200 @@ private:
 
     #ifdef IA_PHASE_DEBUG
     void WritePhaseChange(int newPhase);
 
     #ifdef IA_PHASE_DEBUG
     void WritePhaseChange(int newPhase);
-    string log;
-    string login;
+    std::string log;
+    std::string login;
     FILE * flog;
     #endif
 };
 //-----------------------------------------------------------------------------
     FILE * flog;
     #endif
 };
 //-----------------------------------------------------------------------------
-struct IA_USER
-{
+struct IA_USER {
     IA_USER()
     IA_USER()
+        : login(),
+          user(NULL),
+          phase(),
+          lastSendAlive(0),
+          rnd(static_cast<uint32_t>(random())),
+          port(0),
+          ctx(),
+          messagesToSend(),
+          protoVer(0),
+          password("NO PASSWORD")
     {
     {
-        //phase     = 1;
-        //phaseTime = 0;
-        lastSendAlive = 0;
-        rnd       = random();
-        port      = 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)
+        : login(u.login),
+          user(u.user),
+          phase(u.phase),
+          lastSendAlive(u.lastSendAlive),
+          rnd(u.rnd),
+          port(u.port),
+          ctx(),
+          messagesToSend(u.messagesToSend),
+          protoVer(u.protoVer),
+          password(u.password)
     {
     {
-        user          = u.user;
-        phase         = u.phase;
-        //phaseTime     = u.phaseTime;
-        lastSendAlive = u.lastSendAlive;
-        rnd           = u.rnd;
-        password      = u.password;
-        protoVer      = u.protoVer;
-        port          = u.port;
-        #ifdef IA_DEBUG
-        aliveSent  = u.aliveSent;
-        #endif
-        memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
-    };
-
-    user_iter       user;
-    //int             phase;
-    //UTIME           phaseTime;
+    #ifdef IA_DEBUG
+    aliveSent  = u.aliveSent;
+    #endif
+    memcpy(&ctx, &u.ctx, sizeof(BLOWFISH_CTX));
+    }
+
+    IA_USER(const std::string & l,
+            CONST_USER_PTR u,
+            uint16_t p,
+            int ver)
+        : login(l),
+          user(u),
+          phase(),
+          lastSendAlive(0),
+          rnd(static_cast<uint32_t>(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;
     uint16_t        port;
     BLOWFISH_CTX    ctx;
     IA_PHASE        phase;
     UTIME           lastSendAlive;
     uint32_t        rnd;
     uint16_t        port;
     BLOWFISH_CTX    ctx;
-    list<STG_MSG>   messagesToSend;
+    std::list<STG_MSG> messagesToSend;
     int             protoVer;
     int             protoVer;
-    string          password;
+    std::string     password;
     #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 {
 public:
                     AUTH_IA_SETTINGS();
 public:
                     AUTH_IA_SETTINGS();
-    virtual         ~AUTH_IA_SETTINGS() {};
-    const string&   GetStrError() const { return errorStr; };
+    virtual         ~AUTH_IA_SETTINGS() {}
+    const std::string & GetStrError() const { return errorStr; }
     int             ParseSettings(const MODULE_SETTINGS & s);
     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; };
+    int             GetUserDelay() const { return userDelay; }
+    int             GetUserTimeout() const { return userTimeout; }
+    uint16_t        GetUserPort() const { return port; }
+    FREEMB          GetFreeMbShowType() const { return freeMbShowType; }
+    bool            LogProtocolErrors() const { return logProtocolErrors; }
 
 private:
 
 private:
-    int             ParseIntInRange(const string & str, int min, int max, int * val);
     int             userDelay;
     int             userTimeout;
     uint16_t        port;
     int             userDelay;
     int             userTimeout;
     uint16_t        port;
-    string          errorStr;
+    std::string     errorStr;
     FREEMB          freeMbShowType;
     FREEMB          freeMbShowType;
+    bool            logProtocolErrors;
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
-class AUTH_IA :public BASE_AUTH
-{
+class AUTH_IA;
+//-----------------------------------------------------------------------------
+class DEL_USER_NOTIFIER: public NOTIFIER_BASE<USER_PTR> {
+public:
+    DEL_USER_NOTIFIER(AUTH_IA & a) : auth(a) {}
+    virtual ~DEL_USER_NOTIFIER() {}
+
+    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;
+};
+//-----------------------------------------------------------------------------
+class AUTH_IA :public AUTH {
+friend class DEL_USER_NOTIFIER;
 public:
                         AUTH_IA();
     virtual             ~AUTH_IA();
 
 public:
                         AUTH_IA();
     virtual             ~AUTH_IA();
 
-    void                SetUsers(USERS * u) { users = u; };
-    void                SetTariffs(TARIFFS *){};
-    void                SetAdmins(ADMINS *){};
-    void                SetTraffcounter(TRAFFCOUNTER *){};
-    void                SetStore(BASE_STORE *){};
-    void                SetStgSettings(const SETTINGS * s) { stgSettings = s; };
-    void                SetSettings(const MODULE_SETTINGS & s) { settings = s; };
+    void                SetUsers(USERS * u) { users = u; }
+    void                SetStgSettings(const SETTINGS * s) { stgSettings = s; }
+    void                SetSettings(const MODULE_SETTINGS & s) { settings = s; }
     int                 ParseSettings();
 
     int                 Start();
     int                 Stop();
     int                 ParseSettings();
 
     int                 Start();
     int                 Stop();
-    int                 Reload() { return 0; };
-    bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; };
-
-    const string      & GetStrError() const { return errorStr; };
-    const string        GetVersion() const { return "InetAccess authorization plugin v.1.4"; };
-    uint16_t            GetStartPosition() const { return 50; };
-    uint16_t            GetStopPosition() const { return 50; };
+    int                 Reload() { return 0; }
+    bool                IsRunning() { return isRunningRunTimeouter || isRunningRun; }
 
 
-    void                DelUser(user_iter u);
+    const std::string & GetStrError() const { return errorStr; }
+    std::string         GetVersion() const { return "InetAccess authorization plugin v.1.4"; }
+    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();
     int                 FinalizeNet();
     static void *       Run(void *);
     static void *       RunTimeouter(void * d);
     int                 PrepareNet();
     int                 FinalizeNet();
+    void                DelUser(USER_PTR 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_iter * 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, USER_PTR user);
 
 
-    int                 Process_CONN_SYN_6(CONN_SYN_6 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_CONN_SYN_7(CONN_SYN_7 * connSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, user_iter * user, 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);
+    int                 Process_CONN_SYN_8(CONN_SYN_8 * connSyn, IA_USER * iaUser, uint32_t sip);
 
 
-    int                 Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
+    int                 Process_CONN_ACK_6(CONN_ACK_6 * connAck, IA_USER * iaUser, uint32_t sip);
+    int                 Process_CONN_ACK_7(CONN_ACK_7 * connAck, IA_USER * iaUser, uint32_t sip);
+    int                 Process_CONN_ACK_8(CONN_ACK_8 * connAck, IA_USER * iaUser, uint32_t sip);
 
 
-    int                 Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, user_iter * user, uint32_t sip);
+    int                 Process_ALIVE_ACK_6(ALIVE_ACK_6 * aliveAck, IA_USER * iaUser, uint32_t sip);
+    int                 Process_ALIVE_ACK_7(ALIVE_ACK_7 * aliveAck, IA_USER * iaUser, uint32_t sip);
+    int                 Process_ALIVE_ACK_8(ALIVE_ACK_8 * aliveAck, IA_USER * iaUser, uint32_t sip);
 
 
-    int                 Process_DISCONN_SYN_6(DISCONN_SYN_6 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Process_DISCONN_SYN_8(DISCONN_SYN_8 * disconnSyn, IA_USER * iaUser, user_iter * user, uint32_t sip);
+    int                 Process_DISCONN_SYN_6(DISCONN_SYN_6 * disconnSyn, IA_USER * iaUser, uint32_t sip);
+    int                 Process_DISCONN_SYN_7(DISCONN_SYN_7 * disconnSyn, IA_USER * iaUser, uint32_t sip);
+    int                 Process_DISCONN_SYN_8(DISCONN_SYN_8 * disconnSyn, IA_USER * iaUser, uint32_t sip);
 
     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
                                               IA_USER * iaUser,
 
     int                 Process_DISCONN_ACK_6(DISCONN_ACK_6 * disconnSyn,
                                               IA_USER * iaUser,
-                                              user_iter * user,
                                               uint32_t sip,
                                               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,
     int                 Process_DISCONN_ACK_7(DISCONN_ACK_7 * disconnSyn,
                                               IA_USER * iaUser,
-                                              user_iter * user,
                                               uint32_t sip,
                                               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,
     int                 Process_DISCONN_ACK_8(DISCONN_ACK_8 * disconnSyn,
                                               IA_USER * iaUser,
-                                              user_iter * user,
                                               uint32_t sip,
                                               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, user_iter * user, uint32_t sip);
-    int                 Send_CONN_SYN_ACK_7(IA_USER * iaUser, user_iter * user, uint32_t sip);
-    int                 Send_CONN_SYN_ACK_8(IA_USER * iaUser, user_iter * user, 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);
+    int                 Send_CONN_SYN_ACK_8(IA_USER * iaUser, uint32_t sip);
 
     int                 Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip);
     int                 Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip);
 
     int                 Send_ALIVE_SYN_6(IA_USER * iaUser, uint32_t sip);
     int                 Send_ALIVE_SYN_7(IA_USER * iaUser, uint32_t sip);
@@ -274,27 +312,21 @@ 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                 Timeouter();
 
-    void                InitEncrypt(BLOWFISH_CTX * ctx, const string & password);
-    void                Decrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
-    void                Encrypt(BLOWFISH_CTX * ctx, char * dst, const char * src, int len8);
-
-    int                 SendError(uint32_t ip, uint16_t port, int protoVer, const string & text);
-    int                 Send(uint32_t ip, uint16_t port, const char * buffer, int len);
+    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, size_t 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);
 
     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;
-
     BLOWFISH_CTX        ctxS;        //for loginS
 
     BLOWFISH_CTX        ctxS;        //for loginS
 
-    mutable string      errorStr;
+    mutable std::string errorStr;
     AUTH_IA_SETTINGS    iaSettings;
     MODULE_SETTINGS     settings;
 
     AUTH_IA_SETTINGS    iaSettings;
     MODULE_SETTINGS     settings;
 
@@ -306,7 +338,7 @@ private:
     USERS *             users;
     const SETTINGS *    stgSettings;
 
     USERS *             users;
     const SETTINGS *    stgSettings;
 
-    mutable map<uint32_t, IA_USER>  ip2user;
+    mutable std::map<uint32_t, IA_USER> ip2user;
 
     pthread_t           recvThread;
     pthread_t           timeouterThread;
 
     pthread_t           recvThread;
     pthread_t           timeouterThread;
@@ -325,41 +357,35 @@ private:
     FIN_6               fin6;
     FIN_8               fin8;
 
     FIN_6               fin6;
     FIN_8               fin8;
 
-    map<string, int>    packetTypes;
-
-    STG_LOGGER &        WriteServLog;
+    std::map<std::string, int> packetTypes;
 
     uint32_t            enabledDirs;
 
 
     uint32_t            enabledDirs;
 
-    class DEL_USER_NONIFIER: public NOTIFIER_BASE<user_iter>
-    {
-    public:
-        DEL_USER_NONIFIER(AUTH_IA & a) : auth(a) {};
-        virtual ~DEL_USER_NONIFIER(){};
+    DEL_USER_NOTIFIER   onDelUserNotifier;
 
 
-        void Notify(const user_iter & user)
-            {
-            auth.DelUser(user);
-            }
+    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:
     private:
-        AUTH_IA & auth;
-    } 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;
-    };
+        UnauthorizeUser & operator=(const UnauthorizeUser & rvalue);
 
 
+        AUTH_IA * auth;
 };
 //-----------------------------------------------------------------------------
 };
 //-----------------------------------------------------------------------------
+inline
+void DEL_USER_NOTIFIER::Notify(const USER_PTR & user)
+{
+    auth.DelUser(user);
+}
 
 #endif
 
 #endif
-
-