//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-PLUGIN_CREATOR<AUTH_AO> aoc;
+static PLUGIN_CREATOR<AUTH_AO> aoc;
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
template <typename varType>
-class IS_CONTAINS_USER: public binary_function<varType, USER_PTR, bool>
+class IS_CONTAINS_USER: public std::binary_function<varType, USER_PTR, bool>
{
public:
bool operator()(varType notifier, USER_PTR user) const
{
return notifier.GetUser() == user;
- };
+ }
};
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
-const string AUTH_AO::GetVersion() const
+std::string AUTH_AO::GetVersion() const
{
return "Always Online authorizator v.1.0";
}
: users(NULL),
isRunning(false),
onAddUserNotifier(*this),
- onDelUserNotifier(*this)
+ onDelUserNotifier(*this),
+ logger(GetPluginLogger(GetStgLogger(), "auth_ao"))
{
}
//-----------------------------------------------------------------------------
users->DelNotifierUserAdd(&onAddUserNotifier);
users->DelNotifierUserDel(&onDelUserNotifier);
-list<USER_PTR>::iterator users_iter;
+std::list<USER_PTR>::iterator users_iter;
users_iter = usersList.begin();
while (users_iter != usersList.end())
{
- Unauthorize(*users_iter);
+ if ((*users_iter)->IsAuthorizedBy(this))
+ users->Unauthorize((*users_iter)->GetLogin(), this);
UnSetUserNotifiers(*users_iter);
++users_iter;
}
IS_CONTAINS_USER<CHG_BEFORE_NOTIFIER<int> > IsContainsUserAOB;
IS_CONTAINS_USER<CHG_AFTER_NOTIFIER<int> > IsContainsUserAOA;
-list<CHG_BEFORE_NOTIFIER<int> >::iterator aoBIter;
-list<CHG_AFTER_NOTIFIER<int> >::iterator aoAIter;
+std::list<CHG_BEFORE_NOTIFIER<int> >::iterator aoBIter;
+std::list<CHG_AFTER_NOTIFIER<int> >::iterator aoAIter;
aoBIter = find_if(BeforeChgAONotifierList.begin(),
BeforeChgAONotifierList.end(),
IS_CONTAINS_USER<CHG_BEFORE_NOTIFIER<USER_IPS> > IsContainsUserIPB;
IS_CONTAINS_USER<CHG_AFTER_NOTIFIER<USER_IPS> > IsContainsUserIPA;
-list<CHG_BEFORE_NOTIFIER<USER_IPS> >::iterator ipBIter;
-list<CHG_AFTER_NOTIFIER<USER_IPS> >::iterator ipAIter;
+std::list<CHG_BEFORE_NOTIFIER<USER_IPS> >::iterator ipBIter;
+std::list<CHG_AFTER_NOTIFIER<USER_IPS> >::iterator ipAIter;
-ipBIter = find_if(BeforeChgIPNotifierList.begin(),
- BeforeChgIPNotifierList.end(),
- bind2nd(IsContainsUserIPB, u));
+ipBIter = std::find_if(BeforeChgIPNotifierList.begin(),
+ BeforeChgIPNotifierList.end(),
+ bind2nd(IsContainsUserIPB, u));
if (ipBIter != BeforeChgIPNotifierList.end())
{
users->CloseSearch(h);
}
//-----------------------------------------------------------------------------
-void AUTH_AO::Unauthorize(USER_PTR u) const
-{
-u->Unauthorize(this);
-}
-//-----------------------------------------------------------------------------
-void AUTH_AO::UpdateUserAuthorization(USER_PTR u) const
+void AUTH_AO::UpdateUserAuthorization(CONST_USER_PTR u) const
{
if (u->GetProperty().alwaysOnline)
{
USER_IPS ips = u->GetProperty().ips;
if (ips.OnlyOneIP())
{
- if (u->Authorize(ips[0].ip, 0xFFffFFff, this) == 0)
- {
- }
+ users->Authorize(u->GetLogin(), ips[0].ip, 0xFFffFFff, this);
}
}
}
//-----------------------------------------------------------------------------
void AUTH_AO::DelUser(USER_PTR u)
{
-Unauthorize(u);
+if (u->IsAuthorizedBy(this))
+ users->Unauthorize(u->GetLogin(), this);
UnSetUserNotifiers(u);
usersList.remove(u);
}
void CHG_BEFORE_NOTIFIER<varParamType>::Notify(const varParamType &, const varParamType &)
{
//EVENT_LOOP_SINGLETON::GetInstance().Enqueue(auth, &AUTH_AO::Unauthorize, user);
-auth.Unauthorize(user);
+if (user->IsAuthorizedBy(&auth))
+ auth.users->Unauthorize(user->GetLogin(), &auth);
}
//-----------------------------------------------------------------------------
template <typename varParamType>