]> git.stg.codes - stg.git/blob - projects/stargazer/plugins/configuration/rpcconfig/users_methods.cpp
Ticket. The stgTime argument added in TariffChangeIsAllowed() function
[stg.git] / projects / 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                 GetStgLogger()("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 }