stargazer/plugins/configuration/rpcconfig/users_methods.cpp

   1 #include <cerrno>
   2
   3 #include "stg/users.h"
   4 #include "stg/admins.h"
   5 #include "stg/tariffs.h"
   6 #include "stg/user_ips.h"
   7 #include "stg/common.h"
   8 #include "stg/user_property.h"
   9
  10 #include "users_methods.h"
  11 #include "rpcconfig.h"
  12 #include "user_helper.h"
  13
  14 //------------------------------------------------------------------------------
  15
  16 void METHOD_USER_GET::execute(xmlrpc_c::paramList const & paramList,
  17                               xmlrpc_c::value *   const   retvalPtr)
  18 {
  19 std::string cookie = paramList.getString(0);
  20 std::string login = paramList.getString(1);
  21 paramList.verifyEnd(2);
  22
  23 std::map<std::string, xmlrpc_c::value> structVal;
  24 ADMIN_INFO adminInfo;
  25
  26 if (config->GetAdminInfo(cookie, &adminInfo))
  27     {
  28     structVal["result"] = xmlrpc_c::value_boolean(false);
  29     *retvalPtr = xmlrpc_c::value_struct(structVal);
  30     return;
  31     }
  32
  33 USER_PTR u;
  34
  35 if (users->FindByName(login, &u))
  36     {
  37     structVal["result"] = xmlrpc_c::value_boolean(false);
  38     *retvalPtr = xmlrpc_c::value_struct(structVal);
  39     return;
  40     }
  41
  42 USER_HELPER uhelper(u, *users);
  43
  44 if (!adminInfo.priviledges.userConf || !adminInfo.priviledges.userPasswd)
  45     {
  46     uhelper.GetUserInfo(retvalPtr, true);
  47     return;
  48     }
  49
  50 uhelper.GetUserInfo(retvalPtr);
  51 }
  52
  53 //------------------------------------------------------------------------------
  54
  55 void METHOD_USER_ADD::execute(xmlrpc_c::paramList const & paramList,
  56                               xmlrpc_c::value *   const   retvalPtr)
  57 {
  58 std::string cookie = paramList.getString(0);
  59 std::string login = paramList.getString(1);
  60 paramList.verifyEnd(2);
  61
  62 ADMIN_INFO adminInfo;
  63
  64 if (config->GetAdminInfo(cookie, &adminInfo))
  65     {
  66     *retvalPtr = xmlrpc_c::value_boolean(false);
  67     return;
  68     }
  69
  70 ADMIN * admin = NULL;
  71
  72 if (admins->Find(adminInfo.admin, &admin))
  73     {
  74     *retvalPtr = xmlrpc_c::value_boolean(false);
  75     return;
  76     }
  77
  78 USER_PTR u;
  79
  80 if (users->FindByName(login, &u))
  81     {
  82     if (users->Add(login, admin))
  83         {
  84         *retvalPtr = xmlrpc_c::value_boolean(false);
  85         return;
  86         }
  87
  88     *retvalPtr = xmlrpc_c::value_boolean(true);
  89     return;
  90     }
  91
  92 *retvalPtr = xmlrpc_c::value_boolean(false);
  93 return;
  94 }
  95
  96 //------------------------------------------------------------------------------
  97
  98 void METHOD_USER_DEL::execute(xmlrpc_c::paramList const & paramList,
  99                               xmlrpc_c::value *   const   retvalPtr)
 100 {
 101 std::string cookie = paramList.getString(0);
 102 std::string login = paramList.getString(1);
 103 paramList.verifyEnd(2);
 104
 105 ADMIN_INFO adminInfo;
 106
 107 if (config->GetAdminInfo(cookie, &adminInfo))
 108     {
 109     *retvalPtr = xmlrpc_c::value_boolean(false);
 110     return;
 111     }
 112
 113 ADMIN * admin;
 114
 115 if (admins->Find(adminInfo.admin, &admin))
 116     {
 117     *retvalPtr = xmlrpc_c::value_boolean(false);
 118     return;
 119     }
 120
 121 USER_PTR u;
 122
 123 if (!users->FindByName(login, &u))
 124     {
 125     users->Del(login, admin);
 126     *retvalPtr = xmlrpc_c::value_boolean(true);
 127     return;
 128     }
 129
 130 *retvalPtr = xmlrpc_c::value_boolean(false);
 131 return;
 132 }
 133
 134 //------------------------------------------------------------------------------
 135
 136 void METHOD_USERS_GET::execute(xmlrpc_c::paramList const & paramList,
 137                                xmlrpc_c::value *   const   retvalPtr)
 138 {
 139 std::string cookie = paramList.getString(0);
 140 paramList.verifyEnd(1);
 141
 142 std::map<std::string, xmlrpc_c::value> structVal;
 143 std::vector<xmlrpc_c::value> retval;
 144 ADMIN_INFO adminInfo;
 145
 146 if (config->GetAdminInfo(cookie, &adminInfo))
 147     {
 148     structVal["result"] = xmlrpc_c::value_boolean(false);
 149     *retvalPtr = xmlrpc_c::value_struct(structVal);
 150     return;
 151     }
 152
 153 bool hidePassword = !adminInfo.priviledges.userConf ||
 154                     !adminInfo.priviledges.userPasswd;
 155
 156 USER_PTR u;
 157
 158 int h = users->OpenSearch();
 159 if (!h)
 160     {
 161     printfd(__FILE__, "users->OpenSearch() error\n");
 162     users->CloseSearch(h);
 163     return;
 164     }
 165
 166 while (1)
 167     {
 168     if (users->SearchNext(h, &u))
 169         {
 170         break;
 171         }
 172
 173     xmlrpc_c::value info;
 174
 175     USER_HELPER uhelper(u, *users);
 176
 177     uhelper.GetUserInfo(&info, hidePassword);
 178
 179     retval.push_back(info);
 180     }
 181
 182 *retvalPtr = xmlrpc_c::value_array(retval);
 183 }
 184
 185 //------------------------------------------------------------------------------
 186
 187 void METHOD_USER_CHG::execute(xmlrpc_c::paramList const & paramList,
 188                               xmlrpc_c::value *   const   retvalPtr)
 189 {
 190 std::string cookie = paramList.getString(0);
 191 std::string login = paramList.getString(1);
 192 xmlrpc_c::value_struct info(paramList.getStruct(2));
 193 paramList.verifyEnd(3);
 194
 195 ADMIN_INFO adminInfo;
 196
 197 if (config->GetAdminInfo(cookie, &adminInfo))
 198     {
 199     *retvalPtr = xmlrpc_c::value_boolean(false);
 200     return;
 201     }
 202
 203 ADMIN * admin;
 204
 205 if (admins->Find(adminInfo.admin, &admin))
 206     {
 207     *retvalPtr = xmlrpc_c::value_boolean(false);
 208     return;
 209     }
 210
 211 USER_PTR u;
 212
 213 if (users->FindByName(login, &u))
 214     {
 215     *retvalPtr = xmlrpc_c::value_boolean(false);
 216     return;
 217     }
 218
 219 USER_HELPER uhelper(u, *users);
 220
 221 if (!adminInfo.priviledges.userConf || !adminInfo.priviledges.userPasswd)
 222     {
 223     uhelper.SetUserInfo(info, admin, login, *store, tariffs);
 224     }
 225 else
 226     {
 227     uhelper.SetUserInfo(info, admin, login, *store, tariffs);
 228     }
 229
 230 u->WriteConf();
 231 u->WriteStat();
 232
 233 *retvalPtr = xmlrpc_c::value_boolean(true);
 234 }
 235
 236 //------------------------------------------------------------------------------
 237
 238 void METHOD_USER_CASH_ADD::execute(xmlrpc_c::paramList const & paramList,
 239                                    xmlrpc_c::value *   const   retvalPtr)
 240 {
 241 std::string cookie = paramList.getString(0);
 242 std::string login = paramList.getString(1);
 243 double amount = paramList.getDouble(2);
 244 std::string comment = IconvString(paramList.getString(3), "UTF-8", "KOI8-R");
 245 paramList.verifyEnd(4);
 246
 247 ADMIN_INFO adminInfo;
 248
 249 if (config->GetAdminInfo(cookie, &adminInfo))
 250     {
 251     *retvalPtr = xmlrpc_c::value_boolean(false);
 252     return;
 253     }
 254
 255 ADMIN * admin;
 256
 257 if (admins->Find(adminInfo.admin, &admin))
 258     {
 259     *retvalPtr = xmlrpc_c::value_boolean(false);
 260     return;
 261     }
 262
 263 USER_PTR u;
 264
 265 if (users->FindByName(login, &u))
 266     {
 267     *retvalPtr = xmlrpc_c::value_boolean(false);
 268     return;
 269     }
 270
 271 double cash = u->GetProperty().cash.Get();
 272 cash += amount;
 273
 274 if (!u->GetProperty().cash.Set(cash, admin, login, store, comment))
 275     {
 276     *retvalPtr = xmlrpc_c::value_boolean(false);
 277     return;
 278     }
 279
 280 u->WriteStat();
 281
 282 *retvalPtr = xmlrpc_c::value_boolean(true);
 283 }
 284
 285 //------------------------------------------------------------------------------
 286
 287 void METHOD_USER_CASH_SET::execute(xmlrpc_c::paramList const & paramList,
 288                                    xmlrpc_c::value *   const   retvalPtr)
 289 {
 290 std::string cookie = paramList.getString(0);
 291 std::string login = paramList.getString(1);
 292 double cash = paramList.getDouble(2);
 293 std::string comment = IconvString(paramList.getString(3), "UTF-8", "KOI8-R");
 294 paramList.verifyEnd(4);
 295
 296 ADMIN_INFO adminInfo;
 297
 298 if (config->GetAdminInfo(cookie, &adminInfo))
 299     {
 300     *retvalPtr = xmlrpc_c::value_boolean(false);
 301     return;
 302     }
 303
 304 ADMIN * admin;
 305
 306 if (admins->Find(adminInfo.admin, &admin))
 307     {
 308     *retvalPtr = xmlrpc_c::value_boolean(false);
 309     return;
 310     }
 311
 312 USER_PTR u;
 313
 314 if (users->FindByName(login, &u))
 315     {
 316     *retvalPtr = xmlrpc_c::value_boolean(false);
 317     return;
 318     }
 319
 320 if (!u->GetProperty().cash.Set(cash, admin, login, store, comment))
 321     {
 322     *retvalPtr = xmlrpc_c::value_boolean(false);
 323     return;
 324     }
 325
 326 u->WriteStat();
 327
 328 *retvalPtr = xmlrpc_c::value_boolean(true);
 329 }
 330
 331 //------------------------------------------------------------------------------
 332
 333 void METHOD_USER_TARIFF_CHANGE::execute(xmlrpc_c::paramList const & paramList,
 334                                         xmlrpc_c::value *   const   retvalPtr)
 335 {
 336 std::string cookie = paramList.getString(0);
 337 std::string login = paramList.getString(1);
 338 std::string tariff = paramList.getString(2);
 339 bool delayed = paramList.getBoolean(3);
 340 std::string comment = IconvString(paramList.getString(4), "UTF-8", "KOI8-R");
 341 paramList.verifyEnd(5);
 342
 343 ADMIN_INFO adminInfo;
 344
 345 if (config->GetAdminInfo(cookie, &adminInfo))
 346     {
 347     *retvalPtr = xmlrpc_c::value_boolean(false);
 348     return;
 349     }
 350
 351 ADMIN * admin;
 352
 353 if (admins->Find(adminInfo.admin, &admin))
 354     {
 355     *retvalPtr = xmlrpc_c::value_boolean(false);
 356     return;
 357     }
 358
 359 USER_PTR u;
 360
 361 if (users->FindByName(login, &u))
 362     {
 363     *retvalPtr = xmlrpc_c::value_boolean(false);
 364     return;
 365     }
 366
 367 if (tariffs->FindByName(tariff))
 368     {
 369     if (delayed)
 370         {
 371         if (u->GetProperty().nextTariff.Set(tariff,
 372                                             admin,
 373                                             login,
 374                                             store,
 375                                             comment))
 376             {
 377             u->WriteConf();
 378             *retvalPtr = xmlrpc_c::value_boolean(true);
 379             return;
 380             }
 381         }
 382     else
 383         {
 384         const TARIFF * newTariff = tariffs->FindByName(tariff);
 385         if (newTariff)
 386             {
 387             const TARIFF * currentTariff = u->GetTariff();
 388             std::string message = currentTariff->TariffChangeIsAllowed(*newTariff, stgTime);
 389             if (message.empty())
 390                 {
 391                 if (u->GetProperty().tariffName.Set(tariff,
 392                                             admin,
 393                                             login,
 394                                             store,
 395                                             comment))
 396                     {
 397                     u->ResetNextTariff();
 398                     u->WriteConf();
 399                     *retvalPtr = xmlrpc_c::value_boolean(true);
 400                     return;
 401                     }
 402                 }
 403             else
 404                 {
 405                     PluginLogger::get("conf_rpc")("Tariff change is prohibited for user %s. %s", u->GetLogin().c_str(), message.c_str());
 406                 }
 407             }
 408         }
 409     }
 410
 411 *retvalPtr = xmlrpc_c::value_boolean(false);
 412 }
 413
 414 //------------------------------------------------------------------------------
 415
 416 void METHOD_GET_ONLINE_IPS::execute(xmlrpc_c::paramList const & paramList,
 417                                     xmlrpc_c::value *   const   retvalPtr)
 418 {
 419 std::string cookie = paramList.getString(0);
 420 typedef std::vector<xmlrpc_c::value> ValueVector;
 421 ValueVector subnetsStr = paramList.getArray(1);
 422 paramList.verifyEnd(2);
 423
 424 std::vector<IP_MASK> subnets;
 425
 426 for (ValueVector::const_iterator it(subnetsStr.begin()); it != subnetsStr.end(); ++it)
 427     {
 428     IP_MASK ipm;
 429     if (ParseNet(xmlrpc_c::value_string(*it), ipm))
 430         {
 431         printfd(__FILE__, "METHOD_GET_ONLINE_IPS::execute(): Failed to parse subnet ('%s')\n", std::string(xmlrpc_c::value_string(*it)).c_str());
 432         }
 433     else
 434         {
 435         subnets.push_back(ipm);
 436         }
 437     }
 438
 439 std::map<std::string, xmlrpc_c::value> structVal;
 440 ADMIN_INFO adminInfo;
 441
 442 if (config->GetAdminInfo(cookie, &adminInfo))
 443     {
 444     structVal["result"] = xmlrpc_c::value_boolean(false);
 445     *retvalPtr = xmlrpc_c::value_struct(structVal);
 446     return;
 447     }
 448
 449 ValueVector ips;
 450
 451 USER_PTR u;
 452
 453 int handle = users->OpenSearch();
 454 if (!handle)
 455     {
 456     printfd(__FILE__, "users->OpenSearch() error\n");
 457     users->CloseSearch(handle);
 458     return;
 459     }
 460
 461 while (1)
 462     {
 463     if (users->SearchNext(handle, &u))
 464         {
 465         break;
 466         }
 467
 468     if (u->GetAuthorized())
 469         {
 470         uint32_t ip = u->GetCurrIP();
 471
 472         for (std::vector<IP_MASK>::const_iterator it(subnets.begin()); it != subnets.end(); ++it)
 473             {
 474             if ((it->ip & it->mask) == (ip & it->mask))
 475                 {
 476                 ips.push_back(xmlrpc_c::value_string(inet_ntostring(u->GetCurrIP())));
 477                 break;
 478                 }
 479             }
 480         }
 481     }
 482
 483 structVal["ips"] = xmlrpc_c::value_array(ips);
 484
 485 *retvalPtr = xmlrpc_c::value_struct(structVal);
 486 }
 487
 488 bool METHOD_GET_ONLINE_IPS::ParseNet(const std::string & net, IP_MASK & ipm) const
 489 {
 490 size_t pos = net.find_first_of('/');
 491
 492 if (pos == std::string::npos)
 493     {
 494     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Network address is not in CIDR-notation\n");
 495     return true;
 496     }
 497
 498 int res = inet_pton(AF_INET, net.substr(0, pos).c_str(), &ipm.ip);
 499
 500 if (res < 0)
 501     {
 502     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): '%s'\n", strerror(errno));
 503     return true;
 504     }
 505 else if (res == 0)
 506     {
 507     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Invalid network address\n", strerror(errno));
 508     return true;
 509     }
 510
 511 if (str2x(net.substr(pos + 1, net.length() - pos - 1), ipm.mask))
 512     {
 513     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Invalid network mask\n");
 514     return true;
 515     }
 516 if (ipm.mask > 32)
 517     {
 518     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Network mask is out of range\n");
 519     return true;
 520     }
 521 ipm.mask = htonl(0xffFFffFF << (32 - ipm.mask));
 522
 523 return false;
 524 }
 525
 526 void METHOD_GET_USER_AUTH_BY::execute(xmlrpc_c::paramList const & paramList,
 527                                       xmlrpc_c::value *   const   retvalPtr)
 528 {
 529 std::string cookie = paramList.getString(0);
 530 std::string login = paramList.getString(1);
 531 paramList.verifyEnd(2);
 532
 533 std::map<std::string, xmlrpc_c::value> structVal;
 534 ADMIN_INFO adminInfo;
 535
 536 if (config->GetAdminInfo(cookie, &adminInfo))
 537     {
 538     structVal["result"] = xmlrpc_c::value_boolean(false);
 539     *retvalPtr = xmlrpc_c::value_struct(structVal);
 540     return;
 541     }
 542
 543 USER_PTR u;
 544
 545 if (users->FindByName(login, &u))
 546     {
 547     structVal["result"] = xmlrpc_c::value_boolean(false);
 548     *retvalPtr = xmlrpc_c::value_struct(structVal);
 549     return;
 550     }
 551
 552 std::vector<std::string> list(u->GetAuthorizers());
 553 std::vector<xmlrpc_c::value> authList;
 554 for (std::vector<std::string>::const_iterator it = list.begin(); it != list.end(); ++it)
 555     authList.push_back(xmlrpc_c::value_string(*it));
 556 *retvalPtr = xmlrpc_c::value_array(authList);
 557 }