projects/stargazer/plugins/configuration/rpcconfig/users_methods.cpp

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