]> git.stg.codes - stg.git/commitdiff
Move authorization from USER to USERS
authorMaxim Mamontov <faust.madf@gmail.com>
Sat, 10 Sep 2011 16:07:13 +0000 (19:07 +0300)
committerMaxim Mamontov <faust.madf@gmail.com>
Sat, 10 Sep 2011 16:07:13 +0000 (19:07 +0300)
include/stg/user.h
include/stg/users.h
projects/stargazer/users_impl.cpp
projects/stargazer/users_impl.h

index f0f77bc00b28c466f10ef0ee55581cbf06c90c17..9cc44df8e3f83d4faf7f2f782e969b2f116122f8 100644 (file)
@@ -68,10 +68,10 @@ public:
     virtual bool                GetConnected() const = 0;
     virtual time_t              GetConnectedModificationTime() const = 0;
     virtual int                 GetAuthorized() const = 0;
     virtual bool                GetConnected() const = 0;
     virtual time_t              GetConnectedModificationTime() const = 0;
     virtual int                 GetAuthorized() const = 0;
-    virtual int                 Authorize(uint32_t ip,
+    /*virtual int                 Authorize(uint32_t ip,
                                           uint32_t enabledDirs,
                                           const AUTH * auth) = 0;
                                           uint32_t enabledDirs,
                                           const AUTH * auth) = 0;
-    virtual void                Unauthorize(const AUTH * auth) = 0;
+    virtual void                Unauthorize(const AUTH * auth) = 0;*/
     virtual bool                IsAuthorizedBy(const AUTH * auth) const = 0;
 
     virtual int                 AddMessage(STG_MSG * msg) = 0;
     virtual bool                IsAuthorizedBy(const AUTH * auth) const = 0;
 
     virtual int                 AddMessage(STG_MSG * msg) = 0;
@@ -99,5 +99,6 @@ public:
 };
 
 typedef USER * USER_PTR;
 };
 
 typedef USER * USER_PTR;
+typedef const USER * CONST_USER_PTR;
 
 #endif
 
 #endif
index 862866564a5111f0a57f3fbbeb9b6587e44b55b3..80ee8478710d0a020f1dc3798ed78efee31d2c6f 100644 (file)
@@ -43,6 +43,10 @@ public:
     virtual int  Add(const std::string & login, const ADMIN * admin) = 0;
     virtual void Del(const std::string & login, const ADMIN * admin) = 0;
 
     virtual int  Add(const std::string & login, const ADMIN * admin) = 0;
     virtual void Del(const std::string & login, const ADMIN * admin) = 0;
 
+    virtual bool Authorize(const std::string & login, uint32_t ip,
+                           uint32_t enabledDirs, const AUTH * auth) = 0;
+    virtual bool Unauthorize(const std::string & login, const AUTH * auth) = 0;
+
     virtual int  ReadUsers() = 0;
     virtual size_t Count() const = 0;
 
     virtual int  ReadUsers() = 0;
     virtual size_t Count() const = 0;
 
index fa7265600c578e3b6faa622235c6e2087fc45e37..7b110431130fbcb50fe02fbf8091c396bd39f8b3 100644 (file)
@@ -56,8 +56,8 @@ USERS_IMPL::USERS_IMPL(SETTINGS_IMPL * s, STORE * st, TARIFFS * t, const ADMIN *
     : USERS(),
       users(),
       usersToDelete(),
     : USERS(),
       users(),
       usersToDelete(),
-      userIPNotifiersBefore(),
-      userIPNotifiersAfter(),
+      /*userIPNotifiersBefore(),
+      userIPNotifiersAfter(),*/
       ipIndex(),
       loginIndex(),
       settings(s),
       ipIndex(),
       loginIndex(),
       settings(s),
@@ -269,6 +269,56 @@ if (!priv->userAddDel)
     }
 }
 //-----------------------------------------------------------------------------
     }
 }
 //-----------------------------------------------------------------------------
+bool USERS_IMPL::Authorize(const std::string & login, uint32_t ip,
+                           uint32_t enabledDirs, const AUTH * auth)
+{
+user_iter iter;
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+if (FindByNameNonLock(login, &iter))
+    {
+    WriteServLog("Attempt to authorize non-existant user '%s'", login.c_str());
+    return false;
+    }
+
+if (iter->Authorize(ip, enabledDirs, auth))
+    return false;
+
+if (FindByIPIdx(ip, iter))
+    {
+    if (iter->GetLogin() != login)
+        {
+        WriteServLog("Attempt to authorize user '%s' from ip %s which already occupied by '%s'",
+                     login.c_str(), inet_ntostring(ip).c_str(),
+                     iter->GetLogin().c_str());
+        return false;
+        }
+    return true;
+    }
+
+AddToIPIdx(iter);
+return true;
+}
+//-----------------------------------------------------------------------------
+bool USERS_IMPL::Unauthorize(const std::string & login, const AUTH * auth)
+{
+user_iter iter;
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+if (FindByNameNonLock(login, &iter))
+    {
+    WriteServLog("Attempt to unauthorize non-existant user '%s'", login.c_str());
+    return false;
+    }
+
+uint32_t ip = iter->GetCurrIP();
+
+iter->Unauthorize(auth);
+
+if (!iter->GetAuthorized())
+    DelFromIPIdx(ip);
+
+return true;
+}
+//-----------------------------------------------------------------------------
 int USERS_IMPL::ReadUsers()
 {
 vector<string> usersList;
 int USERS_IMPL::ReadUsers()
 {
 vector<string> usersList;
@@ -592,45 +642,54 @@ const map<uint32_t, user_iter>::iterator it(
         ipIndex.find(ip)
 );
 
         ipIndex.find(ip)
 );
 
-//assert(it != ipIndex.end() && "User is in index");
 if (it == ipIndex.end())
 if (it == ipIndex.end())
-    return; // User has not been added
+    return;
 
 ipIndex.erase(it);
 }
 //-----------------------------------------------------------------------------
 
 ipIndex.erase(it);
 }
 //-----------------------------------------------------------------------------
+bool USERS_IMPL::FindByIPIdx(uint32_t ip, user_iter & iter) const
+{
+map<uint32_t, user_iter>::const_iterator it(ipIndex.find(ip));
+if (it == ipIndex.end())
+    return false;
+iter = it->second;
+return true;
+}
+//-----------------------------------------------------------------------------
 int USERS_IMPL::FindByIPIdx(uint32_t ip, USER_PTR * usr) const
 {
 int USERS_IMPL::FindByIPIdx(uint32_t ip, USER_PTR * usr) const
 {
-    USER_IMPL * ptr = NULL;
-    if (FindByIPIdx(ip, &ptr))
-        return -1;
-    *usr = ptr;
+STG_LOCKER lock(&mutex, __FILE__, __LINE__);
+
+user_iter iter;
+if (FindByIPIdx(ip, iter))
+    {
+    *usr = &(*iter);
     return 0;
     return 0;
+    }
+
+return -1;
 }
 //-----------------------------------------------------------------------------
 int USERS_IMPL::FindByIPIdx(uint32_t ip, USER_IMPL ** usr) const
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 }
 //-----------------------------------------------------------------------------
 int USERS_IMPL::FindByIPIdx(uint32_t ip, USER_IMPL ** usr) const
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-map<uint32_t, user_iter>::const_iterator it;
-it = ipIndex.find(ip);
-
-if (it == ipIndex.end())
+user_iter iter;
+if (FindByIPIdx(ip, iter))
     {
     {
-    //printfd(__FILE__, "User NOT found in IP_Index!!!\n");
-    return -1;
+    *usr = &(*iter);
+    return 0;
     }
     }
-*usr = &(*it->second);
-//printfd(__FILE__, "User found in IP_Index\n");
-return 0;
+
+return -1;
 }
 //-----------------------------------------------------------------------------
 bool USERS_IMPL::IsIPInIndex(uint32_t ip) const
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 }
 //-----------------------------------------------------------------------------
 bool USERS_IMPL::IsIPInIndex(uint32_t ip) const
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-map<uint32_t, user_iter>::const_iterator it;
-it = ipIndex.find(ip);
+map<uint32_t, user_iter>::const_iterator it(ipIndex.find(ip));
 
 return it != ipIndex.end();
 }
 
 return it != ipIndex.end();
 }
@@ -746,21 +805,21 @@ void USERS_IMPL::SetUserNotifiers(user_iter user)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-PROPERTY_NOTIFER_IP_BEFORE nb(*this, user);
+/*PROPERTY_NOTIFER_IP_BEFORE nb(*this, user);
 PROPERTY_NOTIFER_IP_AFTER  na(*this, user);
 
 userIPNotifiersBefore.push_front(nb);
 userIPNotifiersAfter.push_front(na);
 
 user->AddCurrIPBeforeNotifier(&(*userIPNotifiersBefore.begin()));
 PROPERTY_NOTIFER_IP_AFTER  na(*this, user);
 
 userIPNotifiersBefore.push_front(nb);
 userIPNotifiersAfter.push_front(na);
 
 user->AddCurrIPBeforeNotifier(&(*userIPNotifiersBefore.begin()));
-user->AddCurrIPAfterNotifier(&(*userIPNotifiersAfter.begin()));
+user->AddCurrIPAfterNotifier(&(*userIPNotifiersAfter.begin()));*/
 }
 //-----------------------------------------------------------------------------
 void USERS_IMPL::UnSetUserNotifiers(user_iter user)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
 }
 //-----------------------------------------------------------------------------
 void USERS_IMPL::UnSetUserNotifiers(user_iter user)
 {
 STG_LOCKER lock(&mutex, __FILE__, __LINE__);
 
-list<PROPERTY_NOTIFER_IP_BEFORE>::iterator  bi;
+/*list<PROPERTY_NOTIFER_IP_BEFORE>::iterator  bi;
 list<PROPERTY_NOTIFER_IP_AFTER>::iterator   ai;
 
 bi = userIPNotifiersBefore.begin();
 list<PROPERTY_NOTIFER_IP_AFTER>::iterator   ai;
 
 bi = userIPNotifiersBefore.begin();
@@ -787,7 +846,7 @@ while (ai != userIPNotifiersAfter.end())
         break;
         }
     ++ai;
         break;
         }
     ++ai;
-    }
+    }*/
 }
 //-----------------------------------------------------------------------------
 void USERS_IMPL::AddUserIntoIndexes(user_iter user)
 }
 //-----------------------------------------------------------------------------
 void USERS_IMPL::AddUserIntoIndexes(user_iter user)
index 4c586b0613363f30f45260fc8af4e90c404e72c5..de1a2d4081e5b3fc934ae26c6ca6a58d871e2182 100644 (file)
@@ -56,7 +56,7 @@ typedef std::list<USER_IMPL>::const_iterator const_user_iter;
 
 class USERS_IMPL;
 //-----------------------------------------------------------------------------
 
 class USERS_IMPL;
 //-----------------------------------------------------------------------------
-class PROPERTY_NOTIFER_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t> {
+/*class PROPERTY_NOTIFER_IP_BEFORE: public PROPERTY_NOTIFIER_BASE<uint32_t> {
 public:
     PROPERTY_NOTIFER_IP_BEFORE(USERS_IMPL & us, user_iter u) : users(us), user(u) {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
 public:
     PROPERTY_NOTIFER_IP_BEFORE(USERS_IMPL & us, user_iter u) : users(us), user(u) {}
     void        Notify(const uint32_t & oldValue, const uint32_t & newValue);
@@ -74,7 +74,7 @@ public:
 private:
     USERS_IMPL & users;
     user_iter    user;
 private:
     USERS_IMPL & users;
     user_iter    user;
-};
+};*/
 //-----------------------------------------------------------------------------
 struct USER_TO_DEL {
 USER_TO_DEL()
 //-----------------------------------------------------------------------------
 struct USER_TO_DEL {
 USER_TO_DEL()
@@ -113,6 +113,10 @@ public:
     int             Add(const std::string & login, const ADMIN * admin);
     void            Del(const std::string & login, const ADMIN * admin);
 
     int             Add(const std::string & login, const ADMIN * admin);
     void            Del(const std::string & login, const ADMIN * admin);
 
+    bool            Authorize(const std::string & login, uint32_t ip,
+                              uint32_t enabledDirs, const AUTH * auth);
+    bool            Unauthorize(const std::string & login, const AUTH * auth);
+
     int             ReadUsers();
     size_t          Count() const { return users.size(); }
 
     int             ReadUsers();
     size_t          Count() const { return users.size(); }
 
@@ -131,6 +135,7 @@ public:
 private:
     void            AddToIPIdx(user_iter user);
     void            DelFromIPIdx(uint32_t ip);
 private:
     void            AddToIPIdx(user_iter user);
     void            DelFromIPIdx(uint32_t ip);
+    bool            FindByIPIdx(uint32_t ip, user_iter & iter) const;
 
     int             FindByNameNonLock(const std::string & login, user_iter * user);
 
 
     int             FindByNameNonLock(const std::string & login, user_iter * user);
 
@@ -152,8 +157,8 @@ private:
 
     std::list<USER_IMPL>                  users;
     std::list<USER_TO_DEL>                usersToDelete;
 
     std::list<USER_IMPL>                  users;
     std::list<USER_TO_DEL>                usersToDelete;
-    std::list<PROPERTY_NOTIFER_IP_BEFORE> userIPNotifiersBefore;
-    std::list<PROPERTY_NOTIFER_IP_AFTER>  userIPNotifiersAfter;
+    /*std::list<PROPERTY_NOTIFER_IP_BEFORE> userIPNotifiersBefore;
+    std::list<PROPERTY_NOTIFER_IP_AFTER>  userIPNotifiersAfter;*/
 
     std::map<uint32_t, user_iter>         ipIndex;
     std::map<std::string, user_iter>      loginIndex;
 
     std::map<uint32_t, user_iter>         ipIndex;
     std::map<std::string, user_iter>      loginIndex;
@@ -179,7 +184,7 @@ private:
     std::set<NOTIFIER_BASE<USER_IMPL_PTR>*> onDelNotifiersImpl;
 };
 //-----------------------------------------------------------------------------
     std::set<NOTIFIER_BASE<USER_IMPL_PTR>*> onDelNotifiersImpl;
 };
 //-----------------------------------------------------------------------------
-inline
+/*inline
 void PROPERTY_NOTIFER_IP_BEFORE::Notify(const uint32_t & oldValue,
                                         const uint32_t &)
 {
 void PROPERTY_NOTIFER_IP_BEFORE::Notify(const uint32_t & oldValue,
                                         const uint32_t &)
 {
@@ -201,6 +206,6 @@ if (!newValue)
 //EVENT_LOOP_SINGLETON::GetInstance().Enqueue(users, &USERS::AddToIPIdx, user);
 // Using explicit call to assure that index is valid, because fast reconnect with delayed call can result in authorization error
 users.AddToIPIdx(user);
 //EVENT_LOOP_SINGLETON::GetInstance().Enqueue(users, &USERS::AddToIPIdx, user);
 // Using explicit call to assure that index is valid, because fast reconnect with delayed call can result in authorization error
 users.AddToIPIdx(user);
-}
+}*/
 //-----------------------------------------------------------------------------
 #endif
 //-----------------------------------------------------------------------------
 #endif