request/request.c

   1  /* shroud's service request */
   2
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include "../localuser/localuser.h"
   6 #include "../localuser/localuserchannel.h"
   7 #include "../core/schedule.h"
   8 #include "../lib/irc_string.h"
   9 #include "../lib/splitline.h"
  10 #include "../lib/version.h"
  11 #include "../control/control.h"
  12 #include "../splitlist/splitlist.h"
  13 #include "request.h"
  14 #include "request_block.h"
  15 #include "lrequest.h"
  16 #include "sqrequest.h"
  17 #include "user.h"
  18
  19 MODULE_VERSION("");
  20
  21 nick *rqnick;
  22 CommandTree *rqcommands;
  23
  24 void rq_registeruser(void);
  25 void rq_handler(nick *target, int type, void **args);
  26
  27 int rqcmd_showcommands(void *user, int cargc, char **cargv);
  28 int rqcmd_request(void *user, int cargc, char **cargv);
  29 int rqcmd_requestspamscan(void *user, int cargc, char **cargv);
  30 int rqcmd_addblock(void *user, int cargc, char **cargv);
  31 int rqcmd_delblock(void *user, int cargc, char **cargv);
  32 int rqcmd_listblocks(void *user, int cargc, char **cargv);
  33 int rqcmd_stats(void *user, int cargc, char **cargv);
  34 int rqcmd_requestop(void *user, int cargc, char **cargv);
  35
  36 int rqcmd_adduser(void *user, int cargc, char **cargv);
  37 int rqcmd_deluser(void *user, int cargc, char **cargv);
  38 int rqcmd_changelev(void *user, int cargc, char **cargv);
  39 int rqcmd_userlist(void *user, int cargc, char **cargv);
  40
  41 #define min(a,b) ((a > b) ? b : a)
  42
  43 /* stats counters */
  44 int rq_count = 0;
  45 int rq_failed = 0;
  46 int rq_success = 0;
  47 int rq_blocked = 0;
  48
  49 /* log fd */
  50 FILE *rq_logfd;
  51
  52 static int extloaded = 0;
  53
  54 void _init(void) {
  55   if(!rq_initblocks())
  56     return;
  57
  58   extloaded = 1;
  59
  60   rqcommands = newcommandtree();
  61
  62   addcommandtotree(rqcommands, "showcommands", RQU_ANY, 1, &rqcmd_showcommands);
  63   addcommandtotree(rqcommands, "requestbot", RQU_ANY, 1, &rqcmd_request);
  64   addcommandtotree(rqcommands, "requestspamscan", RQU_ANY, 1, &rqcmd_requestspamscan);
  65   addcommandtotree(rqcommands, "requestop", RQU_ANY, 2, &rqcmd_requestop);
  66
  67   addcommandtotree(rqcommands, "addblock", RQU_ACCOUNT, 3, &rqcmd_addblock);
  68   addcommandtotree(rqcommands, "delblock", RQU_ACCOUNT, 1, &rqcmd_delblock);
  69   addcommandtotree(rqcommands, "listblocks", RQU_ACCOUNT, 1, &rqcmd_listblocks);
  70   addcommandtotree(rqcommands, "stats", RQU_ACCOUNT, 1, &rqcmd_stats);
  71
  72   addcommandtotree(rqcommands, "adduser", RQU_OPER, 2, &rqcmd_adduser);
  73   addcommandtotree(rqcommands, "deluser", RQU_OPER, 1, &rqcmd_deluser);
  74   addcommandtotree(rqcommands, "changelev", RQU_OPER, 2, &rqcmd_changelev);
  75   addcommandtotree(rqcommands, "userlist", RQU_OPER, 1, &rqcmd_userlist);
  76
  77   qr_initrequest();
  78   ru_load();
  79
  80   rq_logfd = fopen(RQ_LOGFILE, "a");
  81
  82   scheduleoneshot(time(NULL) + 1, (ScheduleCallback)&rq_registeruser, NULL);
  83 }
  84
  85 void _fini(void) {
  86   if(!extloaded)
  87     return;
  88
  89   deregisterlocaluser(rqnick, NULL);
  90
  91   deletecommandfromtree(rqcommands, "showcommands", &rqcmd_showcommands);
  92   deletecommandfromtree(rqcommands, "requestbot", &rqcmd_request);
  93   deletecommandfromtree(rqcommands, "requestspamscan", &rqcmd_requestspamscan);
  94   deletecommandfromtree(rqcommands, "requestop", &rqcmd_requestop);
  95
  96   deletecommandfromtree(rqcommands, "addblock", &rqcmd_addblock);
  97   deletecommandfromtree(rqcommands, "delblock", &rqcmd_delblock);
  98   deletecommandfromtree(rqcommands, "listblocks", &rqcmd_listblocks);
  99   deletecommandfromtree(rqcommands, "stats", &rqcmd_stats);
 100
 101   deletecommandfromtree(rqcommands, "adduser", &rqcmd_adduser);
 102   deletecommandfromtree(rqcommands, "deluser", &rqcmd_deluser);
 103   deletecommandfromtree(rqcommands, "changelev", &rqcmd_changelev);
 104   deletecommandfromtree(rqcommands, "userlist", &rqcmd_userlist);
 105
 106   destroycommandtree(rqcommands);
 107
 108   rq_finiblocks();
 109   qr_finirequest();
 110   ru_persist();
 111
 112   if (rq_logfd != NULL)
 113     fclose(rq_logfd);
 114
 115   deleteallschedules((ScheduleCallback)&rq_registeruser);
 116 }
 117
 118 void rq_registeruser(void) {
 119   channel *cp;
 120
 121   rqnick = registerlocaluserflags(RQ_REQUEST_NICK, RQ_REQUEST_USER, RQ_REQUEST_HOST,
 122                              RQ_REQUEST_REAL, RQ_REQUEST_AUTH, 1780711, 0,
 123                              UMODE_ACCOUNT | UMODE_SERVICE | UMODE_OPER,
 124                              rq_handler);
 125
 126   cp = findchannel(RQ_TLZ);
 127
 128   if (cp == NULL)
 129     localcreatechannel(rqnick, RQ_TLZ);
 130   else
 131     localjoinchannel(rqnick, cp);
 132 }
 133
 134 char *rq_longtoduration(unsigned long interval) {
 135   static char buf[100];
 136
 137   strncpy(buf, longtoduration(interval, 0), sizeof(buf));
 138
 139   /* chop off last character if it's a space */
 140   if (buf[strlen(buf)] == ' ')
 141     buf[strlen(buf)] = '\0';
 142
 143   return buf;
 144 }
 145
 146 void rq_handler(nick *target, int type, void **params) {
 147   Command* cmd;
 148   nick* user;
 149   char* line;
 150   int cargc;
 151   char* cargv[30];
 152
 153   switch (type) {
 154     case LU_PRIVMSG:
 155     case LU_SECUREMSG:
 156       user = params[0];
 157       line = params[1];
 158       cargc = splitline(line, cargv, 30, 0);
 159
 160       if (cargc == 0)
 161         return;
 162
 163       cmd = findcommandintree(rqcommands, cargv[0], 1);
 164
 165       if (cmd == NULL) {
 166         sendnoticetouser(rqnick, user, "Unknown command.");
 167
 168         return;
 169       }
 170
 171       if ((cmd->level & RQU_OPER) && !IsOper(user)) {
 172         sendnoticetouser(rqnick, user, "Sorry, this command is not "
 173               "available to you.");
 174
 175         return;
 176       }
 177
 178       if ((cmd->level & RQU_ACCOUNT) && (!IsAccount(user) || ru_getlevel(user) == 0) && !IsOper(user)) {
 179         sendnoticetouser(rqnick, user, "Sorry, this command is not "
 180               "available to you.");
 181
 182         return;
 183       }
 184
 185       if (cargc - 1 > cmd->maxparams)
 186         rejoinline(cargv[cmd->maxparams], cargc - cmd->maxparams);
 187
 188       /* handle the command */
 189       cmd->handler((void*)user, min(cargc - 1, cmd->maxparams), &(cargv[1]));
 190
 191       break;
 192     case LU_KILLED:
 193       scheduleoneshot(time(NULL) + 5, (ScheduleCallback)&rq_registeruser, NULL);
 194
 195       break;
 196     case LU_PRIVNOTICE:
 197       qr_handle_notice(params[0], params[1]);
 198
 199       break;
 200   }
 201 }
 202
 203 int rqcmd_showcommands(void *user, int cargc, char **cargv) {
 204   nick* np = (nick*)user;
 205   int n, i;
 206   Command* cmdlist[50];
 207
 208   n = getcommandlist(rqcommands, cmdlist, 50);
 209
 210   sendnoticetouser(rqnick, np, "Available commands:");
 211   sendnoticetouser(rqnick, np, "-------------------");
 212
 213   for (i = 0; i < n; i++) {
 214     if ((cmdlist[i]->level & RQU_OPER) && !IsOper(np))
 215       continue;
 216
 217     if ((cmdlist[i]->level & RQU_ACCOUNT) && !(IsOper(np) || (IsAccount(np) && ru_getlevel(np) > 0)))
 218       continue;
 219
 220     sendnoticetouser(rqnick, np, "%s", cmdlist[i]->command->content);
 221   }
 222
 223   sendnoticetouser(rqnick, np, "End of SHOWCOMMANDS");
 224
 225   return 0;
 226 }
 227
 228 int rq_genericrequestcheck(nick *np, char *channelname, channel **cp, nick **qnick) {
 229   unsigned long *userhand;
 230   rq_block *block;
 231
 232   if (!IsAccount(np)) {
 233     sendnoticetouser(rqnick, np, "Error: You must be authed.");
 234
 235     return RQ_ERROR;
 236   }
 237
 238   *cp = findchannel(channelname);
 239
 240   if (*cp == NULL) {
 241     sendnoticetouser(rqnick, np, "Error: Channel %s does not exist.",
 242           channelname);
 243
 244     return RQ_ERROR;
 245   }
 246
 247   *qnick = getnickbynick(RQ_QNICK);
 248
 249   if (*qnick == NULL || findserver(RQ_QSERVER) < 0) {
 250     sendnoticetouser(rqnick, np, "Error: %s does not seem to be online. "
 251           "Try again later.", RQ_QNICK);
 252
 253     return RQ_ERROR;
 254   }
 255
 256   userhand = getnumerichandlefromchanhash((*cp)->users, np->numeric);
 257
 258   if (userhand == NULL) {
 259     sendnoticetouser(rqnick, np, "Error: You're not on that channel.");
 260
 261     return RQ_ERROR;
 262   }
 263
 264   if ((*userhand & CUMODE_OP) == 0) {
 265     sendnoticetouser(rqnick, np, "Error: You must be op'd on the channel to "
 266           "request a service.");
 267
 268     return RQ_ERROR;
 269   }
 270
 271   block = rq_findblock(channelname);
 272
 273   if (block != NULL) {
 274      /* only say when block expires if <7 days */
 275      if ( block->expires < getnettime() + 3600 * 24 * 7) {
 276        sendnoticetouser(rqnick, np, "Error: You are not allowed to request a "
 277             "service to this channel. Keep waiting for at least %s before you try again.",
 278             rq_longtoduration(block->expires - getnettime()));
 279        /* give them another 5 minutes to think about it */
 280        block->expires += 300;
 281        rq_saveblocks();
 282      } else {
 283        sendnoticetouser(rqnick, np, "Error: You are not allowed to request a "
 284           "service to this channel.");
 285      }
 286     sendnoticetouser(rqnick, np, "Reason: %s", block->reason->content);
 287
 288     rq_blocked++;
 289
 290     return RQ_ERROR;
 291   }
 292
 293   block = rq_findblock(np->authname);
 294
 295   /* only tell the user if the block is going to expire in the next 48 hours
 296      so we can have our fun with longterm blocks.
 297      the request subsystems should deal with longterm blocks on their own */
 298   if (block != NULL && block->expires < getnettime() + 3600 * 24 * 2) {
 299     sendnoticetouser(rqnick, np, "Error: You are not allowed to request a "
 300           "service. Keep waiting for at least %s before you try again.",
 301           rq_longtoduration(block->expires - getnettime()));
 302
 303     sendnoticetouser(rqnick, np, "Reason: %s", block->reason->content);
 304
 305     /* give them another 5 minutes to think about it */
 306     block->expires += 300;
 307     rq_saveblocks();
 308
 309     rq_blocked++;
 310
 311     return RQ_ERROR;
 312   }
 313
 314   return RQ_OK;
 315 }
 316
 317 int rqcmd_request(void *user, int cargc, char **cargv) {
 318   nick *np = (nick*)user;
 319   nick *qnick;
 320   unsigned long *qhand;
 321   channel *cp;
 322   int retval;
 323   time_t now_ts;
 324   char now[50];
 325
 326   if (cargc < 1) {
 327     sendnoticetouser(rqnick, np, "Syntax: requestbot <#channel>");
 328
 329     return RQ_ERROR;
 330   }
 331
 332   rq_count++;
 333
 334   if (rq_genericrequestcheck(np, cargv[0], &cp, &qnick) == RQ_ERROR) {
 335     rq_failed++;
 336
 337     return RQ_ERROR;
 338   }
 339
 340   qhand = getnumerichandlefromchanhash(cp->users, qnick->numeric);
 341
 342   if (qhand != NULL) {
 343     sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", RQ_QNICK);
 344
 345     rq_failed++;
 346
 347     return RQ_ERROR;
 348   }
 349
 350   retval = RQ_ERROR;
 351
 352   retval = lr_requestl(rqnick, np, cp, qnick);
 353
 354   if (rq_logfd != NULL) {
 355     now[0] = '\0';
 356     now_ts = time(NULL);
 357     strftime(now, sizeof(now), "%c", localtime(&now_ts));
 358
 359     fprintf(rq_logfd, "%s: request (%s) for %s from %s!%s@%s%s%s: Request was %s.\n",
 360       now, RQ_QNICK, cp->index->name->content,
 361       np->nick, np->ident, np->host->name->content, IsAccount(np)?"/":"", IsAccount(np)?np->authname:"",
 362       (retval == RQ_OK) ? "accepted" : "denied");
 363     fflush(rq_logfd);
 364   }
 365
 366   if (retval == RQ_ERROR)
 367     rq_failed++;
 368   else if (retval == RQ_OK)
 369     rq_success++;
 370
 371   return retval;
 372 }
 373
 374 int rqcmd_requestspamscan(void *user, int cargc, char **cargv) {
 375   nick *np = (nick*)user;
 376   channel *cp;
 377   nick *qnick, *snick;
 378   unsigned long *qhand, *shand;
 379   int retval;
 380
 381   if (cargc < 1) {
 382     sendnoticetouser(rqnick, np, "Syntax: requestspamscan <#channel>");
 383
 384     return RQ_ERROR;
 385   }
 386
 387   rq_count++;
 388
 389   if (rq_genericrequestcheck(np, cargv[0], &cp, &qnick) == RQ_ERROR) {
 390     rq_failed++;
 391
 392     return RQ_ERROR;
 393   }
 394
 395   snick = getnickbynick(RQ_SNICK);
 396
 397   if (snick == NULL || findserver(RQ_SSERVER) < 0) {
 398     sendnoticetouser(rqnick, np, "Error: %s does not seem to be online. "
 399             "Try again later.", RQ_SNICK);
 400
 401     rq_failed++;
 402
 403     return RQ_ERROR;
 404   }
 405
 406   /* does the user already have S on that channel? */
 407   shand = getnumerichandlefromchanhash(cp->users, snick->numeric);
 408
 409   if (shand != NULL) {
 410     sendnoticetouser(rqnick, np, "Error: %s is already on that channel.", RQ_SNICK);
 411
 412     rq_failed++;
 413
 414     return RQ_ERROR;
 415   }
 416
 417   /* we need Q */
 418   qhand = getnumerichandlefromchanhash(cp->users, qnick->numeric);
 419
 420   if (qhand) {
 421     /* great, now try to request */
 422     retval = qr_requests(rqnick, np, cp, qnick);
 423
 424     if (retval == RQ_OK)
 425       rq_success++;
 426     else if (retval == RQ_ERROR)
 427       rq_failed++;
 428
 429       return retval;
 430   } else {
 431     /* channel apparently doesn't have Q */
 432
 433    sendnoticetouser(rqnick, np, "Error: You need %s in order to be "
 434         "able to request %s.", RQ_QNICK, RQ_SNICK);
 435
 436     rq_failed++;
 437
 438    return RQ_ERROR;
 439   }
 440 }
 441
 442 int rqcmd_requestop(void *source, int cargc, char **cargv) {
 443   nick *np2, *np = (nick *)source;
 444   nick *user = np;
 445   channel *cp;
 446   int ret, a, count;
 447   unsigned long *hand;
 448   modechanges changes;
 449
 450   if (cargc < 1) {
 451     sendnoticetouser(rqnick, np, "Syntax: requestop <#channel> [nick]");
 452
 453     return CMD_ERROR;
 454   }
 455
 456   cp = findchannel(cargv[0]);
 457
 458   if (cp == NULL) {
 459     sendnoticetouser(rqnick, np, "Error: No such channel.");
 460
 461     return CMD_ERROR;
 462   }
 463
 464   if (cargc > 1) {
 465     user = getnickbynick(cargv[1]);
 466
 467     if (!user) {
 468       sendnoticetouser(rqnick, np, "Error: No such user.");
 469
 470       return CMD_ERROR;
 471     }
 472   }
 473
 474   if (getnettime() - np->timestamp < 300) {
 475     sendnoticetouser(rqnick, np, "Error: You connected %s ago. To"
 476                         " request ops you must have been on the network for"
 477                         " at least 5 minutes.",
 478                         rq_longtoduration(getnettime() - np->timestamp));
 479
 480     return CMD_ERROR;
 481   }
 482
 483   if (getnettime() - user->timestamp < 300) {
 484     sendnoticetouser(rqnick, np, "Error: The nick you requested op for"
 485                         " connected %s ago. To request op, it must have"
 486                         "been on the network for at least 5 minutes.",
 487                         rq_longtoduration(getnettime() - user->timestamp));
 488
 489     return CMD_ERROR;
 490   }
 491
 492   hand = getnumerichandlefromchanhash(cp->users, user->numeric);
 493
 494   if (!hand) {
 495     sendnoticetouser(rqnick, np, "Error: User %s is not on channel %s.", user->nick, cargv[0]);
 496
 497     return CMD_ERROR;
 498   }
 499
 500
 501   count = 0;
 502
 503   localsetmodeinit(&changes, cp, rqnick);
 504
 505   /* reop any services first */
 506   for(a=0;a<cp->users->hashsize;a++) {
 507     if(cp->users->content[a] != nouser) {
 508       np2 = getnickbynumeric(cp->users->content[a]);
 509
 510       if (IsService(np2) && (np2->nick[1] == '\0') && !(cp->users->content[a] & CUMODE_OP)) {
 511         localdosetmode_nick(&changes, np2, MC_OP);
 512         count++;
 513       }
 514     }
 515   }
 516
 517   localsetmodeflush(&changes, 1);
 518
 519   if (count > 0) {
 520     if (count == 1)
 521       sendnoticetouser(rqnick, np, "1 service was reopped.");
 522     else
 523       sendnoticetouser(rqnick, np, "%d services were reopped.", count);
 524
 525     return CMD_ERROR;
 526   }
 527
 528   for (a=0;a<cp->users->hashsize;a++) {
 529     if ((cp->users->content[a] != nouser) && (cp->users->content[a] & CUMODE_OP)) {
 530       sendnoticetouser(rqnick, np, "There are ops on channel %s. This command can only be"
 531                       " used if there are no ops.", cargv[0]);
 532
 533       return CMD_ERROR;
 534     }
 535   }
 536
 537   if (sp_countsplitservers() > 0) {
 538     sendnoticetouser(rqnick, np, "One or more servers are currently split. Wait until the"
 539                     " netsplit is over and try again.");
 540
 541     return CMD_ERROR;
 542   }
 543
 544   if (cf_wouldreop(user, cp)) {
 545     localsetmodeinit(&changes, cp, rqnick);
 546     localdosetmode_nick(&changes, user, MC_OP);
 547     localsetmodeflush(&changes, 1);
 548
 549     sendnoticetouser(rqnick, np, "Chanfix opped you on the specified channel.");
 550   } else {
 551     ret = cf_fixchannel(cp);
 552
 553     if (ret == CFX_NOUSERSAVAILABLE)
 554       sendnoticetouser(rqnick, np, "Chanfix knows regular ops for that channel. They will"
 555                    " be opped when they return.");
 556     else
 557       sendnoticetouser(rqnick, np, "Chanfix has opped known ops for that channel.");
 558   }
 559
 560   return CMD_OK;
 561
 562 }
 563
 564 int rqcmd_addblock(void *user, int cargc, char **cargv) {
 565   nick *np = (nick*)user;
 566   rq_block *block;
 567   time_t expires;
 568   char *account;
 569   int level = ru_getlevel(np);
 570
 571   if (level < 20) {
 572     sendnoticetouser(rqnick, np, "You do not have access to this command.");
 573
 574     return RQ_ERROR;
 575   }
 576
 577   if (cargc < 3) {
 578     sendnoticetouser(rqnick, np, "Syntax: addblock <mask> <duration> <reason>");
 579
 580     return RQ_ERROR;
 581   }
 582
 583   block = rq_findblock(cargv[0]);
 584
 585   if (block != NULL) {
 586     sendnoticetouser(rqnick, np, "That mask is already blocked by %s "
 587           "(reason: %s).", block->creator->content, block->reason->content);
 588
 589     return RQ_ERROR;
 590   }
 591
 592   if (IsAccount(np))
 593     account = np->authname;
 594   else
 595     account = "unknown";
 596
 597   expires = getnettime() + durationtolong(cargv[1]);
 598
 599   if (expires > getnettime() + RQU_HELPER_MAXEXPIRE && level < 30) {
 600     sendnoticetouser(rqnick, np, "Maximum expiry time is %s.", rq_longtoduration(RQU_HELPER_MAXEXPIRE));
 601
 602     return RQ_ERROR;
 603   }
 604
 605   rq_addblock(cargv[0], cargv[2], account, 0, expires);
 606
 607   sendnoticetouser(rqnick, np, "Blocked channels/accounts matching '%s' from "
 608         "requesting a service.", cargv[0]);
 609
 610   return RQ_OK;
 611 }
 612
 613 int rqcmd_delblock(void *user, int cargc, char **cargv) {
 614   nick *np = (nick*)user;
 615   int result, level;
 616   rq_block *block;
 617
 618   level = ru_getlevel(np);
 619
 620   if (level < 20) {
 621     sendnoticetouser(rqnick, np, "You do not have access to this command.");
 622
 623     return RQ_ERROR;
 624   }
 625
 626   if (cargc < 1) {
 627     sendnoticetouser(rqnick, np, "Syntax: delblock <mask>");
 628
 629     return RQ_ERROR;
 630   }
 631
 632   block = rq_findblock(cargv[0]);
 633
 634   if (block != NULL && level < 50) {
 635     if (ircd_strcmp(block->creator->content, np->authname) != 0) {
 636       sendnoticetouser(rqnick, np, "This block was created by someone else. You cannot remove it.");
 637
 638       return RQ_ERROR;
 639     }
 640   }
 641
 642   result = rq_removeblock(cargv[0]);
 643
 644   if (result > 0) {
 645     sendnoticetouser(rqnick, np, "Block for '%s' was removed.", cargv[0]);
 646
 647     return RQ_OK;
 648   } else {
 649     sendnoticetouser(rqnick, np, "There is no such block.");
 650
 651     return RQ_OK;
 652   }
 653 }
 654
 655 int rqcmd_listblocks(void *user, int cargc, char **cargv) {
 656   nick *np = (nick*)user;
 657   rq_block block;
 658   int i, level;
 659
 660   level = ru_getlevel(np);
 661
 662   if (level < 10) {
 663     sendnoticetouser(rqnick, np, "You do not have access to this command.");
 664
 665     return RQ_ERROR;
 666   }
 667
 668   sendnoticetouser(rqnick, np, "Mask        By        Expires"
 669         "                   Reason");
 670
 671   for (i = 0; i < rqblocks.cursi; i++) {
 672     block = ((rq_block*)rqblocks.content)[i];
 673
 674     if (block.expires != 0 && block.expires < getnettime())
 675       continue; /* ignore blocks which have already expired,
 676                    rq_findblock will deal with them later on */
 677
 678     if (cargc < 1 || match2strings(block.pattern->content, cargv[0]))
 679       sendnoticetouser(rqnick, np, "%-11s %-9s %-25s %s",
 680             block.pattern->content, block.creator->content,
 681             rq_longtoduration(block.expires - getnettime()),
 682             block.reason->content);
 683   }
 684
 685   sendnoticetouser(rqnick, np, "--- End of blocklist");
 686
 687   return RQ_OK;
 688 }
 689
 690 int rqcmd_stats(void *user, int cargc, char **cargv) {
 691   nick *np = (nick*)user;
 692   int level = ru_getlevel(np);
 693
 694   if (level < 10) {
 695     sendnoticetouser(rqnick, np, "You do not have access to this command.");
 696
 697     return RQ_ERROR;
 698   }
 699
 700   sendnoticetouser(rqnick, np, "Total requests:                   %d", rq_count);
 701   sendnoticetouser(rqnick, np, "Successful requests:              %d", rq_success);
 702   sendnoticetouser(rqnick, np, "Failed requests:                  %d", rq_failed);
 703   sendnoticetouser(rqnick, np, "- Blocked:                        %d", rq_blocked);
 704
 705   lr_requeststats(rqnick, np);
 706   qr_requeststats(rqnick, np);
 707
 708   return RQ_OK;
 709 }
 710
 711 int rqcmd_adduser(void *user, int cargc, char **cargv) {
 712   nick *np = (nick*)user;
 713   int result, level;
 714
 715   if (cargc < 2) {
 716     sendnoticetouser(rqnick, np, "Syntax: adduser <account> <level>");
 717
 718     return RQ_ERROR;
 719   }
 720
 721   level = atoi(cargv[1]);
 722
 723   if (level <= 0) {
 724     sendnoticetouser(rqnick, np, "Level must be a positive integer.");
 725
 726     return RQ_ERROR;
 727   }
 728
 729   result = ru_create(cargv[0], level);
 730
 731   if (result) {
 732     sendnoticetouser(rqnick, np, "User '%s' was added with level '%d'.", cargv[0], level);
 733
 734     return RQ_OK;
 735   } else {
 736     sendnoticetouser(rqnick, np, "Something strange happened. Contact shroud.");
 737
 738     return RQ_ERROR;
 739   }
 740 }
 741
 742 int rqcmd_deluser(void *user, int cargc, char **cargv) {
 743   nick *np = (nick*)user;
 744   int level;
 745
 746   if (cargc < 1) {
 747     sendnoticetouser(rqnick, np, "Syntax: deluser <account>");
 748
 749     return RQ_ERROR;
 750   }
 751
 752   level = ru_getlevel_str(cargv[0]);
 753
 754   if (level <= 0) {
 755     sendnoticetouser(rqnick, np, "There is no such user.");
 756
 757     return RQ_ERROR;
 758   }
 759
 760   ru_destroy(cargv[0]);
 761
 762   sendnoticetouser(rqnick, np, "Done.");
 763
 764   return RQ_OK;
 765 }
 766
 767 int rqcmd_changelev(void *user, int cargc, char **cargv) {
 768   nick *np = (nick*)user;
 769   int result, level;
 770
 771   if (cargc < 2) {
 772     sendnoticetouser(rqnick, np, "Syntax: changelev <account> <level>");
 773
 774     return RQ_ERROR;
 775   }
 776
 777   level = atoi(cargv[1]);
 778
 779   if (level <= 0) {
 780     sendnoticetouser(rqnick, np, "Level must be a positive integer.");
 781
 782     return RQ_ERROR;
 783   }
 784
 785   if (ru_getlevel_str(cargv[0]) <= 0) {
 786     sendnoticetouser(rqnick, np, "Unknown user.");
 787
 788     return RQ_ERROR;
 789   }
 790
 791   result = ru_setlevel(cargv[0], level);
 792
 793   if (result != 0) {
 794     sendnoticetouser(rqnick, np, "Done.");
 795
 796     return RQ_OK;
 797   } else {
 798     sendnoticetouser(rqnick, np, "Something strange happened. Contact shroud.");
 799
 800     return RQ_ERROR;
 801   }
 802 }
 803
 804 int rqcmd_userlist(void *user, int cargc, char **cargv) {
 805   nick *np = (nick*)user;
 806   r_user_t *userp = r_userlist;
 807
 808   sendnoticetouser(rqnick, np, "User Level");
 809
 810   while (userp) {
 811     sendnoticetouser(rqnick, np, "%s %d", userp->name, userp->level);
 812     userp = userp->next;
 813   }
 814
 815   sendnoticetouser(rqnick, np, "--- End of USERS.");
 816
 817   return RQ_OK;
 818 }
 819