]> git.stg.codes - stg.git/blob - stargazer/plugins/configuration/rpcconfig/users_methods.cpp
650f7b37d3a88274ae290a78727bf968f3a4e46c
[stg.git] / stargazer / plugins / configuration / rpcconfig / users_methods.cpp
1 #include "users_methods.h"
2 #include "rpcconfig.h"
3 #include "user_helper.h"
4
5 #include "stg/users.h"
6 #include "stg/admins.h"
7 #include "stg/tariffs.h"
8 #include "stg/tariff.h"
9 #include "stg/user.h"
10 #include "stg/user_property.h"
11 #include "stg/common.h"
12
13 #include <cerrno>
14
15 using UserPtr = STG::User*;
16
17 //------------------------------------------------------------------------------
18
19 void METHOD_USER_GET::execute(xmlrpc_c::paramList const & paramList,
20                               xmlrpc_c::value *   const   retvalPtr)
21 {
22 std::string cookie = paramList.getString(0);
23 std::string login = paramList.getString(1);
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 UserPtr 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, *users);
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 paramList.verifyEnd(2);
64
65 ADMIN_INFO adminInfo;
66
67 if (config->GetAdminInfo(cookie, &adminInfo))
68     {
69     *retvalPtr = xmlrpc_c::value_boolean(false);
70     return;
71     }
72
73 STG::Admin * admin = NULL;
74
75 if (admins->find(adminInfo.admin, &admin))
76     {
77     *retvalPtr = xmlrpc_c::value_boolean(false);
78     return;
79     }
80
81 UserPtr u;
82
83 if (users->FindByName(login, &u))
84     {
85     if (users->Add(login, admin))
86         {
87         *retvalPtr = xmlrpc_c::value_boolean(false);
88         return;
89         }
90
91     *retvalPtr = xmlrpc_c::value_boolean(true);
92     return;
93     }
94
95 *retvalPtr = xmlrpc_c::value_boolean(false);
96 return;
97 }
98
99 //------------------------------------------------------------------------------
100
101 void METHOD_USER_DEL::execute(xmlrpc_c::paramList const & paramList,
102                               xmlrpc_c::value *   const   retvalPtr)
103 {
104 std::string cookie = paramList.getString(0);
105 std::string login = paramList.getString(1);
106 paramList.verifyEnd(2);
107
108 ADMIN_INFO adminInfo;
109
110 if (config->GetAdminInfo(cookie, &adminInfo))
111     {
112     *retvalPtr = xmlrpc_c::value_boolean(false);
113     return;
114     }
115
116 STG::Admin * admin;
117
118 if (admins->find(adminInfo.admin, &admin))
119     {
120     *retvalPtr = xmlrpc_c::value_boolean(false);
121     return;
122     }
123
124 UserPtr u;
125
126 if (!users->FindByName(login, &u))
127     {
128     users->Del(login, admin);
129     *retvalPtr = xmlrpc_c::value_boolean(true);
130     return;
131     }
132
133 *retvalPtr = xmlrpc_c::value_boolean(false);
134 return;
135 }
136
137 //------------------------------------------------------------------------------
138
139 void METHOD_USERS_GET::execute(xmlrpc_c::paramList const & paramList,
140                                xmlrpc_c::value *   const   retvalPtr)
141 {
142 std::string cookie = paramList.getString(0);
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 UserPtr 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, *users);
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 paramList.verifyEnd(3);
197
198 ADMIN_INFO adminInfo;
199
200 if (config->GetAdminInfo(cookie, &adminInfo))
201     {
202     *retvalPtr = xmlrpc_c::value_boolean(false);
203     return;
204     }
205
206 STG::Admin * admin;
207
208 if (admins->find(adminInfo.admin, &admin))
209     {
210     *retvalPtr = xmlrpc_c::value_boolean(false);
211     return;
212     }
213
214 UserPtr u;
215
216 if (users->FindByName(login, &u))
217     {
218     *retvalPtr = xmlrpc_c::value_boolean(false);
219     return;
220     }
221
222 USER_HELPER uhelper(u, *users);
223
224 if (!adminInfo.priviledges.userConf || !adminInfo.priviledges.userPasswd)
225     {
226     uhelper.SetUserInfo(info, *admin, login, *store, tariffs);
227     }
228 else
229     {
230     uhelper.SetUserInfo(info, *admin, login, *store, tariffs);
231     }
232
233 u->WriteConf();
234 u->WriteStat();
235
236 *retvalPtr = xmlrpc_c::value_boolean(true);
237 }
238
239 //------------------------------------------------------------------------------
240
241 void METHOD_USER_CASH_ADD::execute(xmlrpc_c::paramList const & paramList,
242                                    xmlrpc_c::value *   const   retvalPtr)
243 {
244 std::string cookie = paramList.getString(0);
245 std::string login = paramList.getString(1);
246 double amount = paramList.getDouble(2);
247 std::string comment = IconvString(paramList.getString(3), "UTF-8", "KOI8-R");
248 paramList.verifyEnd(4);
249
250 ADMIN_INFO adminInfo;
251
252 if (config->GetAdminInfo(cookie, &adminInfo))
253     {
254     *retvalPtr = xmlrpc_c::value_boolean(false);
255     return;
256     }
257
258 STG::Admin * admin;
259
260 if (admins->find(adminInfo.admin, &admin))
261     {
262     *retvalPtr = xmlrpc_c::value_boolean(false);
263     return;
264     }
265
266 UserPtr u;
267
268 if (users->FindByName(login, &u))
269     {
270     *retvalPtr = xmlrpc_c::value_boolean(false);
271     return;
272     }
273
274 double cash = u->GetProperties().cash.Get();
275 cash += amount;
276
277 if (!u->GetProperties().cash.Set(cash, *admin, login, *store, comment))
278     {
279     *retvalPtr = xmlrpc_c::value_boolean(false);
280     return;
281     }
282
283 u->WriteStat();
284
285 *retvalPtr = xmlrpc_c::value_boolean(true);
286 }
287
288 //------------------------------------------------------------------------------
289
290 void METHOD_USER_CASH_SET::execute(xmlrpc_c::paramList const & paramList,
291                                    xmlrpc_c::value *   const   retvalPtr)
292 {
293 std::string cookie = paramList.getString(0);
294 std::string login = paramList.getString(1);
295 double cash = paramList.getDouble(2);
296 std::string comment = IconvString(paramList.getString(3), "UTF-8", "KOI8-R");
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 STG::Admin * admin;
308
309 if (admins->find(adminInfo.admin, &admin))
310     {
311     *retvalPtr = xmlrpc_c::value_boolean(false);
312     return;
313     }
314
315 UserPtr u;
316
317 if (users->FindByName(login, &u))
318     {
319     *retvalPtr = xmlrpc_c::value_boolean(false);
320     return;
321     }
322
323 if (!u->GetProperties().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 paramList.verifyEnd(5);
345
346 ADMIN_INFO adminInfo;
347
348 if (config->GetAdminInfo(cookie, &adminInfo))
349     {
350     *retvalPtr = xmlrpc_c::value_boolean(false);
351     return;
352     }
353
354 STG::Admin * admin;
355
356 if (admins->find(adminInfo.admin, &admin))
357     {
358     *retvalPtr = xmlrpc_c::value_boolean(false);
359     return;
360     }
361
362 UserPtr u;
363
364 if (users->FindByName(login, &u))
365     {
366     *retvalPtr = xmlrpc_c::value_boolean(false);
367     return;
368     }
369
370 if (tariffs->FindByName(tariff))
371     {
372     if (delayed)
373         {
374         if (u->GetProperties().nextTariff.Set(tariff, *admin, login, *store, comment))
375             {
376             u->WriteConf();
377             *retvalPtr = xmlrpc_c::value_boolean(true);
378             return;
379             }
380         }
381     else
382         {
383         const auto newTariff = tariffs->FindByName(tariff);
384         if (newTariff)
385             {
386             const auto currentTariff = u->GetTariff();
387             std::string message = currentTariff->TariffChangeIsAllowed(*newTariff, stgTime);
388             if (message.empty())
389                 {
390                 if (u->GetProperties().tariffName.Set(tariff, *admin, login, *store, comment))
391                     {
392                     u->ResetNextTariff();
393                     u->WriteConf();
394                     *retvalPtr = xmlrpc_c::value_boolean(true);
395                     return;
396                     }
397                 }
398             else
399                 {
400                     STG::PluginLogger::get("conf_rpc")("Tariff change is prohibited for user %s. %s", u->GetLogin().c_str(), message.c_str());
401                 }
402             }
403         }
404     }
405
406 *retvalPtr = xmlrpc_c::value_boolean(false);
407 }
408
409 //------------------------------------------------------------------------------
410
411 void METHOD_GET_ONLINE_IPS::execute(xmlrpc_c::paramList const & paramList,
412                                     xmlrpc_c::value *   const   retvalPtr)
413 {
414 std::string cookie = paramList.getString(0);
415 typedef std::vector<xmlrpc_c::value> ValueVector;
416 ValueVector subnetsStr = paramList.getArray(1);
417 paramList.verifyEnd(2);
418
419 std::vector<STG::IPMask> subnets;
420
421 for (ValueVector::const_iterator it(subnetsStr.begin()); it != subnetsStr.end(); ++it)
422     {
423     STG::IPMask 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 ValueVector ips;
445
446 UserPtr 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         for (std::vector<STG::IPMask>::const_iterator it(subnets.begin()); it != subnets.end(); ++it)
468             {
469             if ((it->ip & it->mask) == (ip & it->mask))
470                 {
471                 ips.push_back(xmlrpc_c::value_string(inet_ntostring(u->GetCurrIP())));
472                 break;
473                 }
474             }
475         }
476     }
477
478 structVal["ips"] = xmlrpc_c::value_array(ips);
479
480 *retvalPtr = xmlrpc_c::value_struct(structVal);
481 }
482
483 bool METHOD_GET_ONLINE_IPS::ParseNet(const std::string & net, STG::IPMask & ipm) const
484 {
485 size_t pos = net.find_first_of('/');
486
487 if (pos == std::string::npos)
488     {
489     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Network address is not in CIDR-notation\n");
490     return true;
491     }
492
493 int res = inet_pton(AF_INET, net.substr(0, pos).c_str(), &ipm.ip);
494
495 if (res < 0)
496     {
497     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): '%s'\n", strerror(errno));
498     return true;
499     }
500 else if (res == 0)
501     {
502     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Invalid network address\n", strerror(errno));
503     return true;
504     }
505
506 if (str2x(net.substr(pos + 1, net.length() - pos - 1), ipm.mask))
507     {
508     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Invalid network mask\n");
509     return true;
510     }
511 if (ipm.mask > 32)
512     {
513     printfd(__FILE__, "METHOD_GET_ONLINE_IPS::ParseNet(): Network mask is out of range\n");
514     return true;
515     }
516 ipm.mask = htonl(0xffFFffFF << (32 - ipm.mask));
517
518 return false;
519 }
520
521 void METHOD_GET_USER_AUTH_BY::execute(xmlrpc_c::paramList const & paramList,
522                                       xmlrpc_c::value *   const   retvalPtr)
523 {
524 std::string cookie = paramList.getString(0);
525 std::string login = paramList.getString(1);
526 paramList.verifyEnd(2);
527
528 std::map<std::string, xmlrpc_c::value> structVal;
529 ADMIN_INFO adminInfo;
530
531 if (config->GetAdminInfo(cookie, &adminInfo))
532     {
533     structVal["result"] = xmlrpc_c::value_boolean(false);
534     *retvalPtr = xmlrpc_c::value_struct(structVal);
535     return;
536     }
537
538 UserPtr u;
539
540 if (users->FindByName(login, &u))
541     {
542     structVal["result"] = xmlrpc_c::value_boolean(false);
543     *retvalPtr = xmlrpc_c::value_struct(structVal);
544     return;
545     }
546
547 std::vector<std::string> list(u->GetAuthorizers());
548 std::vector<xmlrpc_c::value> authList;
549 for (std::vector<std::string>::const_iterator it = list.begin(); it != list.end(); ++it)
550     authList.push_back(xmlrpc_c::value_string(*it));
551 *retvalPtr = xmlrpc_c::value_array(authList);
552 }