projects/stargazer/plugins/authorization/ao/ao.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Boris Mikhailenko <stg34@stargazer.dp.ua>
  19  */
  20
  21 /*
  22 $Revision: 1.30 $
  23 $Date: 2010/03/04 12:29:06 $
  24 $Author: faust $
  25 */
  26
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <signal.h>
  30
  31 #include "ao.h"
  32 #include "../../../user.h"
  33 #include "../../../eventloop.h"
  34
  35 class AO_CREATOR
  36 {
  37 private:
  38     AUTH_AO * ao;
  39
  40 public:
  41     AO_CREATOR()
  42         : ao(new AUTH_AO())
  43         {
  44         };
  45     ~AO_CREATOR()
  46         {
  47         delete ao;
  48         };
  49
  50     AUTH_AO * GetPlugin()
  51         {
  52         return ao;
  53         };
  54 };
  55 //-----------------------------------------------------------------------------
  56 //-----------------------------------------------------------------------------
  57 //-----------------------------------------------------------------------------
  58 AO_CREATOR aoc;
  59 //-----------------------------------------------------------------------------
  60 //-----------------------------------------------------------------------------
  61 //-----------------------------------------------------------------------------
  62 // ëÌÁÓÓ ÄÌÑ ÐÏÉÓËÁ ÀÚÅÒÁ × ÓÐÉÓËÅ ÎÏÔÉÆÉËÁÔÏÒÏ×
  63 template <typename varType>
  64 class IS_CONTAINS_USER: public binary_function<varType, user_iter, bool>
  65 {
  66 public:
  67     bool operator()(varType notifier, user_iter user) const
  68         {
  69         return notifier.GetUser() == user;
  70         };
  71 };
  72 //-----------------------------------------------------------------------------
  73 //-----------------------------------------------------------------------------
  74 //-----------------------------------------------------------------------------
  75 BASE_PLUGIN * GetPlugin()
  76 {
  77 return aoc.GetPlugin();
  78 }
  79 //-----------------------------------------------------------------------------
  80 //-----------------------------------------------------------------------------
  81 //-----------------------------------------------------------------------------
  82 const string AUTH_AO::GetVersion() const
  83 {
  84 return "Always Online authorizator v.1.0";
  85 }
  86 //-----------------------------------------------------------------------------
  87 AUTH_AO::AUTH_AO()
  88     : users(NULL),
  89       isRunning(false),
  90       onAddUserNotifier(*this),
  91       onDelUserNotifier(*this)
  92 {
  93 }
  94 //-----------------------------------------------------------------------------
  95 void AUTH_AO::SetUsers(USERS * u)
  96 {
  97 users = u;
  98 }
  99 //-----------------------------------------------------------------------------
 100 void AUTH_AO::SetSettings(const MODULE_SETTINGS & s)
 101 {
 102 settings = s;
 103 }
 104 //-----------------------------------------------------------------------------
 105 int AUTH_AO::ParseSettings()
 106 {
 107 return 0;
 108 }
 109 //-----------------------------------------------------------------------------
 110 const string & AUTH_AO::GetStrError() const
 111 {
 112 return errorStr;
 113 }
 114 //-----------------------------------------------------------------------------
 115 int AUTH_AO::Start()
 116 {
 117 GetUsers();
 118
 119 list<user_iter>::iterator users_iter;
 120
 121 /*onAddUserNotifier.SetAuthorizator(this);
 122 onDelUserNotifier.SetAuthorizator(this);*/
 123 users->AddNotifierUserAdd(&onAddUserNotifier);
 124 users->AddNotifierUserDel(&onDelUserNotifier);
 125
 126 users_iter = usersList.begin();
 127 while (users_iter != usersList.end())
 128     {
 129     UpdateUserAuthorization(*users_iter);
 130     ++users_iter;
 131     }
 132 isRunning = true;
 133 return 0;
 134 }
 135 //-----------------------------------------------------------------------------
 136 int AUTH_AO::Stop()
 137 {
 138 if (!isRunning)
 139     return 0;
 140
 141 users->DelNotifierUserAdd(&onAddUserNotifier);
 142 users->DelNotifierUserDel(&onDelUserNotifier);
 143
 144 list<user_iter>::iterator users_iter;
 145 users_iter = usersList.begin();
 146 while (users_iter != usersList.end())
 147     {
 148     Unauthorize(*users_iter);
 149     UnSetUserNotifiers(*users_iter);
 150     ++users_iter;
 151     }
 152 isRunning = false;
 153 return 0;
 154 }
 155 //-----------------------------------------------------------------------------
 156 bool AUTH_AO::IsRunning()
 157 {
 158 return isRunning;
 159 }
 160 //-----------------------------------------------------------------------------
 161 uint16_t AUTH_AO::GetStartPosition() const
 162 {
 163 return 70;
 164 }
 165 //-----------------------------------------------------------------------------
 166 uint16_t AUTH_AO::GetStopPosition() const
 167 {
 168 return 70;
 169 }
 170 //-----------------------------------------------------------------------------
 171 void AUTH_AO::SetUserNotifiers(user_iter u)
 172 {
 173 // ---------- AlwaysOnline -------------------
 174 CHG_BEFORE_NOTIFIER<int> BeforeChgAONotifier(*this, u);
 175 CHG_AFTER_NOTIFIER<int>  AfterChgAONotifier(*this, u);
 176
 177 /*BeforeChgAONotifier.SetAuthorizator(this);
 178 BeforeChgAONotifier.SetUser(u);*/
 179 BeforeChgAONotifierList.push_front(BeforeChgAONotifier);
 180
 181 /*AfterChgAONotifier.SetAuthorizator(this);
 182 AfterChgAONotifier.SetUser(u);*/
 183 AfterChgAONotifierList.push_front(AfterChgAONotifier);
 184
 185 u->property.alwaysOnline.AddBeforeNotifier(&(*BeforeChgAONotifierList.begin()));
 186 u->property.alwaysOnline.AddAfterNotifier(&(*AfterChgAONotifierList.begin()));
 187 // ---------- AlwaysOnline end ---------------
 188
 189 // ---------- IP -------------------
 190 CHG_BEFORE_NOTIFIER<USER_IPS> BeforeChgIPNotifier(*this, u);
 191 CHG_AFTER_NOTIFIER<USER_IPS>  AfterChgIPNotifier(*this, u);
 192
 193 /*BeforeChgIPNotifier.SetAuthorizator(this);
 194 BeforeChgIPNotifier.SetUser(u);*/
 195 BeforeChgIPNotifierList.push_front(BeforeChgIPNotifier);
 196
 197 /*AfterChgIPNotifier.SetAuthorizator(this);
 198 AfterChgIPNotifier.SetUser(u);*/
 199 AfterChgIPNotifierList.push_front(AfterChgIPNotifier);
 200
 201 u->property.ips.AddBeforeNotifier(&(*BeforeChgIPNotifierList.begin()));
 202 u->property.ips.AddAfterNotifier(&(*AfterChgIPNotifierList.begin()));
 203 // ---------- IP end ---------------
 204 }
 205 //-----------------------------------------------------------------------------
 206 void AUTH_AO::UnSetUserNotifiers(user_iter u)
 207 {
 208 // ---      AlwaysOnline        ---
 209 IS_CONTAINS_USER<CHG_BEFORE_NOTIFIER<int> > IsContainsUserAOB;
 210 IS_CONTAINS_USER<CHG_AFTER_NOTIFIER<int> > IsContainsUserAOA;
 211
 212 list<CHG_BEFORE_NOTIFIER<int> >::iterator aoBIter;
 213 list<CHG_AFTER_NOTIFIER<int> >::iterator  aoAIter;
 214
 215 aoBIter = find_if(BeforeChgAONotifierList.begin(),
 216                   BeforeChgAONotifierList.end(),
 217                   bind2nd(IsContainsUserAOB, u));
 218
 219 if (aoBIter != BeforeChgAONotifierList.end())
 220     {
 221     aoBIter->GetUser()->property.alwaysOnline.DelBeforeNotifier(&(*aoBIter));
 222     BeforeChgAONotifierList.erase(aoBIter);
 223     }
 224
 225 aoAIter = find_if(AfterChgAONotifierList.begin(),
 226                   AfterChgAONotifierList.end(),
 227                   bind2nd(IsContainsUserAOA, u));
 228
 229 if (aoAIter != AfterChgAONotifierList.end())
 230     {
 231     aoAIter->GetUser()->property.alwaysOnline.DelAfterNotifier(&(*aoAIter));
 232     AfterChgAONotifierList.erase(aoAIter);
 233     }
 234 // ---      AlwaysOnline end    ---
 235
 236 // ---          IP              ---
 237 IS_CONTAINS_USER<CHG_BEFORE_NOTIFIER<USER_IPS> > IsContainsUserIPB;
 238 IS_CONTAINS_USER<CHG_AFTER_NOTIFIER<USER_IPS> >  IsContainsUserIPA;
 239
 240 list<CHG_BEFORE_NOTIFIER<USER_IPS> >::iterator ipBIter;
 241 list<CHG_AFTER_NOTIFIER<USER_IPS> >::iterator  ipAIter;
 242
 243 ipBIter = find_if(BeforeChgIPNotifierList.begin(),
 244                   BeforeChgIPNotifierList.end(),
 245                   bind2nd(IsContainsUserIPB, u));
 246
 247 if (ipBIter != BeforeChgIPNotifierList.end())
 248     {
 249     ipBIter->GetUser()->property.ips.DelBeforeNotifier(&(*ipBIter));
 250     BeforeChgIPNotifierList.erase(ipBIter);
 251     }
 252
 253 ipAIter = find_if(AfterChgIPNotifierList.begin(),
 254                   AfterChgIPNotifierList.end(),
 255                   bind2nd(IsContainsUserIPA, u));
 256
 257 if (ipAIter != AfterChgIPNotifierList.end())
 258     {
 259     ipAIter->GetUser()->property.ips.DelAfterNotifier(&(*ipAIter));
 260     AfterChgIPNotifierList.erase(ipAIter);
 261     }
 262 // ---          IP end          ---
 263 }
 264 //-----------------------------------------------------------------------------
 265 void AUTH_AO::GetUsers()
 266 {
 267 user_iter u;
 268 int h = users->OpenSearch();
 269 if (!h)
 270     {
 271     printfd(__FILE__, "users->OpenSearch() error\n");
 272     return;
 273     }
 274
 275 while (1)
 276     {
 277     if (users->SearchNext(h, &u))
 278         {
 279         break;
 280         }
 281     usersList.push_back(u);
 282     SetUserNotifiers(u);
 283     }
 284
 285 users->CloseSearch(h);
 286 }
 287 //-----------------------------------------------------------------------------
 288 void AUTH_AO::Unauthorize(user_iter u) const
 289 {
 290 u->Unauthorize(this);
 291 }
 292 //-----------------------------------------------------------------------------
 293 void AUTH_AO::UpdateUserAuthorization(user_iter u) const
 294 {
 295 if (u->property.alwaysOnline)
 296     {
 297     USER_IPS ips = u->property.ips;
 298     if (ips.OnlyOneIP())
 299         {
 300         if (u->Authorize(ips[0].ip, "", 0xFFffFFff, this) == 0)
 301             {
 302             }
 303         }
 304     }
 305 }
 306 //-----------------------------------------------------------------------------
 307 void AUTH_AO::AddUser(user_iter u)
 308 {
 309 SetUserNotifiers(u);
 310 usersList.push_back(u);
 311 UpdateUserAuthorization(u);
 312 }
 313 //-----------------------------------------------------------------------------
 314 void AUTH_AO::DelUser(user_iter u)
 315 {
 316 Unauthorize(u);
 317 UnSetUserNotifiers(u);
 318
 319 list<user_iter>::iterator users_iter;
 320 users_iter = usersList.begin();
 321
 322 while (users_iter != usersList.end())
 323     {
 324     if (u == *users_iter)
 325         {
 326         usersList.erase(users_iter);
 327         break;
 328         }
 329     ++users_iter;
 330     }
 331 }
 332 //-----------------------------------------------------------------------------
 333 int AUTH_AO::SendMessage(const STG_MSG &, uint32_t) const
 334 {
 335 errorStr = "Authorization modele \'AlwaysOnline\' does not support sending messages";
 336 return -1;
 337 }
 338 //-----------------------------------------------------------------------------
 339 template <typename varParamType>
 340 void CHG_BEFORE_NOTIFIER<varParamType>::Notify(const varParamType &, const varParamType &)
 341 {
 342 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(auth, &AUTH_AO::Unauthorize, user);
 343 }
 344 //-----------------------------------------------------------------------------
 345 template <typename varParamType>
 346 void CHG_AFTER_NOTIFIER<varParamType>::Notify(const varParamType &, const varParamType &)
 347 {
 348 EVENT_LOOP_SINGLETON::GetInstance().Enqueue(auth, &AUTH_AO::UpdateUserAuthorization, user);
 349 }
 350 //-----------------------------------------------------------------------------
 351