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

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