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

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