trusts/trusts_management.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include "../control/control.h"
   4 #include "../lib/version.h"
   5 #include "../lib/irc_string.h"
   6 #include "../lib/strlfunc.h"
   7 #include "../core/config.h"
   8 #include "../core/schedule.h"
   9 #include "../irc/irc.h"
  10 #include "../lib/stringbuf.h"
  11 #include "../control/control.h"
  12 #include "../control/control_policy.h"
  13 #include "trusts.h"
  14
  15 MODULE_VERSION("");
  16
  17 static void registercommands(int, void *);
  18 static void deregistercommands(int, void *);
  19
  20 typedef int (*trustmodificationfn)(void *, char *arg, nick *, int);
  21
  22 struct trustmodification {
  23   char name[50];
  24   trustmodificationfn fn;
  25 };
  26
  27 static int trusts_cmdtrustadd(void *source, int cargc, char **cargv) {
  28   trustgroup *tg;
  29   nick *sender = source;
  30   char *host;
  31   struct irc_in_addr ip;
  32   unsigned char bits;
  33   trusthost *th, *superset, *subset;
  34
  35   if(cargc < 2)
  36     return CMD_USAGE;
  37
  38   tg = tg_strtotg(cargv[0]);
  39   if(!tg) {
  40     controlreply(sender, "Couldn't look up trustgroup.");
  41     return CMD_ERROR;
  42   }
  43
  44   host = cargv[1];
  45   if(!ipmask_parse(host, &ip, &bits)) {
  46     controlreply(sender, "Invalid host.");
  47     return CMD_ERROR;
  48   }
  49
  50   if(!is_normalized_ipmask(&ip, bits)) {
  51     controlreply(sender, "Invalid IP Mask.");
  52     return CMD_ERROR;
  53   }
  54
  55   /* Don't allow non-developers to add trusts for large subnets or modify protected groups. */
  56   if (!noperserv_policy_command_permitted(NO_DEVELOPER, sender)) {
  57     int minbits = irc_in_addr_is_ipv4(&ip)?TRUST_MIN_UNPRIVILEGED_BITS_IPV4:TRUST_MIN_UNPRIVILEGED_BITS_IPV6;
  58     if(bits < minbits) {
  59       controlreply(sender, "You don't have the necessary privileges to add a subnet larger than /%d.", irc_bitlen(&ip, minbits));
  60       return CMD_ERROR;
  61     }
  62
  63     if(tg->flags & TRUST_PROTECTED) {
  64       controlreply(sender, "You don't have the necessary privileges to modify a protected trust group.");
  65       return CMD_ERROR;
  66     }
  67   }
  68
  69   /* OKAY! Lots of checking here!
  70    *
  71    * Need to check:
  72    *   - host isn't already covered by given group (reject if it is)
  73    *   - host doesn't already exist exactly already (reject if it does)
  74    *   - host is more specific than an existing one (warn if it is, fix up later)
  75    *   - host is less specific than an existing one (warn if it is, don't need to do anything special)
  76    */
  77
  78   for(th=tg->hosts;th;th=th->next) {
  79     if(ipmask_check(&ip, &th->ip, th->bits)) {
  80       controlreply(sender, "This host (or part of it) is already covered in the given group.");
  81       return CMD_ERROR;
  82     }
  83   }
  84
  85   if(th_getbyhostandmask(&ip, bits)) {
  86     controlreply(sender, "This host already exists in another group with the same mask.");
  87     return CMD_ERROR;
  88   }
  89
  90   /* this function will set both to NULL if it's equal, hence the check above */
  91   th_getsuperandsubsets(&ip, bits, &superset, &subset);
  92   if(superset) {
  93     /* a superset exists for us, we will be more specific than one existing host */
  94
  95     controlreply(sender, "Note: This host already exists in another group, but this new host will override it as it has a smaller prefix.");
  96   }
  97   if(subset) {
  98     /* a subset of us exists, we will be less specific than some existing hosts */
  99
 100     controlreply(sender, "Note: This host already exists in at least one other group, the new host has a larger prefix and therefore will not override those hosts.");
 101   }
 102
 103   th = th_new(tg, host);
 104   if(!th) {
 105     controlreply(sender, "An error occured adding the host to the group.");
 106     return CMD_ERROR;
 107   }
 108
 109   controlreply(sender, "Host added.");
 110   triggerhook(HOOK_TRUSTS_ADDHOST, th);
 111
 112   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTADD'ed host %s to group '%s'", controlid(sender), host, th->group->name->content);
 113   trustlog(tg, sender->authname, "Added host '%s'.", host);
 114
 115   return CMD_OK;
 116 }
 117
 118 static int trusts_cmdtrustgroupadd(void *source, int cargc, char **cargv) {
 119   nick *sender = source;
 120   char *name, *contact, *comment, createdby[ACCOUNTLEN + 2];
 121   long howmany, maxperident, enforceident;
 122   trustgroup *tg, itg;
 123   int override, flags;
 124
 125   if(cargc < 5)
 126     return CMD_USAGE;
 127
 128   override = noperserv_policy_command_permitted(NO_DEVELOPER, sender);
 129
 130   name = cargv[0];
 131   howmany = strtol(cargv[1], NULL, 10);
 132   if(!override && (!howmany || (howmany > MAXTRUSTEDFOR))) {
 133     controlreply(sender, "Bad value maximum number of clients.");
 134     return CMD_ERROR;
 135   }
 136
 137   maxperident = strtol(cargv[2], NULL, 10);
 138   if(maxperident < 0 || (maxperident > MAXPERIDENT)) {
 139     controlreply(sender, "Bad value for max per ident.");
 140     return CMD_ERROR;
 141   }
 142
 143   if(cargv[3][0] != '1' && cargv[3][0] != '0') {
 144     controlreply(sender, "Bad value for enforce ident (use 0 or 1).");
 145     return CMD_ERROR;
 146   }
 147   enforceident = cargv[3][0] == '1';
 148
 149   contact = cargv[4];
 150
 151   if(cargc < 6) {
 152     comment = "(no comment)";
 153   } else {
 154     comment = cargv[5];
 155   }
 156
 157   /* don't allow #id or id forms */
 158   if((name[0] == '#') || strtol(name, NULL, 10)) {
 159     controlreply(sender, "Invalid trustgroup name.");
 160     return CMD_ERROR;
 161   }
 162
 163   tg = tg_strtotg(name);
 164   if(tg) {
 165     controlreply(sender, "A group with that name already exists.");
 166     return CMD_ERROR;
 167   }
 168
 169   snprintf(createdby, sizeof(createdby), "#%s", sender->authname);
 170
 171   flags = 0;
 172
 173   if(maxperident > 0)
 174     flags |= TRUST_RELIABLE_USERNAME;
 175
 176   if(enforceident)
 177     flags |= TRUST_ENFORCE_IDENT;
 178
 179   itg.trustedfor = howmany;
 180   itg.flags = flags;
 181   itg.maxperident = maxperident;
 182   itg.expires = 0;
 183   itg.createdby = getsstring(createdby, CREATEDBYLEN);
 184   itg.contact = getsstring(contact, CONTACTLEN);
 185   itg.comment = getsstring(comment, COMMENTLEN);
 186   itg.name = getsstring(name, TRUSTNAMELEN);
 187
 188   if(itg.createdby && itg.contact && itg.comment && itg.name) {
 189     tg = tg_new(&itg);
 190   } else {
 191     tg = NULL;
 192   }
 193
 194   freesstring(itg.createdby);
 195   freesstring(itg.comment);
 196   freesstring(itg.name);
 197   freesstring(itg.contact);
 198
 199   if(!tg) {
 200     controlreply(sender, "An error occured adding the trustgroup.");
 201     return CMD_ERROR;
 202   }
 203
 204   controlreply(sender, "Group added.");
 205   triggerhook(HOOK_TRUSTS_ADDGROUP, tg);
 206
 207   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTGROUPADD'ed '%s'", controlid(sender), tg->name->content);
 208   trustlog(tg, sender->authname, "Created trust group '%s' (ID #%d): howmany=%d, enforceident=%d, maxperident=%d, "
 209     "createdby=%s, contact=%s, comment=%s",
 210     tg->name->content, howmany, tg->id, enforceident, maxperident, createdby, contact, comment);
 211
 212   return CMD_OK;
 213 }
 214
 215 static int trusts_cmdtrustgroupdel(void *source, int cargc, char **cargv) {
 216   trustgroup *tg;
 217   nick *sender = source;
 218
 219   if(cargc < 1)
 220     return CMD_USAGE;
 221
 222   tg = tg_strtotg(cargv[0]);
 223   if(!tg) {
 224     controlreply(sender, "Couldn't look up trustgroup.");
 225     return CMD_ERROR;
 226   }
 227
 228   /* Don't allow non-developers to delete protected groups. */
 229   if (!noperserv_policy_command_permitted(NO_DEVELOPER, sender)) {
 230     if(tg->flags & TRUST_PROTECTED) {
 231       controlreply(sender, "You don't have the necessary privileges to modify a protected trust group.");
 232       return CMD_ERROR;
 233     }
 234   }
 235
 236   if(tg->hosts) {
 237     controlreply(sender, "Delete all hosts before deleting the group.");
 238     return CMD_ERROR;
 239   }
 240
 241   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTGROUPDEL'ed '%s'.", controlid(sender), tg->name->content);
 242   trustlog(tg, sender->authname, "Deleted group '%s'.", tg->name->content);
 243
 244   triggerhook(HOOK_TRUSTS_DELGROUP, tg);
 245   tg_delete(tg);
 246   controlreply(sender, "Group deleted.");
 247
 248   return CMD_OK;
 249 }
 250
 251 static int trusts_cmdtrustdel(void *source, int cargc, char **cargv) {
 252   trustgroup *tg;
 253   trusthost *th;
 254   struct irc_in_addr ip;
 255   unsigned char bits;
 256   nick *sender = source;
 257   char *host;
 258
 259   if(cargc < 2)
 260     return CMD_USAGE;
 261
 262   tg = tg_strtotg(cargv[0]);
 263   if(!tg) {
 264     controlreply(sender, "Couldn't look up trustgroup.");
 265     return CMD_ERROR;
 266   }
 267
 268   host = cargv[1];
 269   if(!ipmask_parse(host, &ip, &bits)) {
 270     controlreply(sender, "Invalid IP/mask.");
 271     return CMD_ERROR;
 272   }
 273
 274   /* Don't allow non-developers to remove trusts for large subnets or modify protected groups. */
 275   if (!noperserv_policy_command_permitted(NO_DEVELOPER, sender)) {
 276     int minbits = irc_in_addr_is_ipv4(&ip)?TRUST_MIN_UNPRIVILEGED_BITS_IPV4:TRUST_MIN_UNPRIVILEGED_BITS_IPV6;
 277     if(bits < minbits) {
 278       controlreply(sender, "You don't have the necessary privileges to remove a subnet larger than /%d.", irc_bitlen(&ip, minbits));
 279       return CMD_ERROR;
 280     }
 281
 282     if(tg->flags & TRUST_PROTECTED) {
 283       controlreply(sender, "You don't have the necessary privileges to modify a protected trust group.");
 284       return CMD_ERROR;
 285     }
 286   }
 287
 288   for(th=tg->hosts;th;th=th->next)
 289     if(ipmask_check(&ip, &th->ip, th->bits) && th->bits == bits)
 290       break;
 291
 292   if(!th) {
 293     controlreply(sender, "Couldn't find that host in that group.");
 294     return CMD_ERROR;
 295   }
 296
 297   triggerhook(HOOK_TRUSTS_DELHOST, th);
 298   th_delete(th);
 299   controlreply(sender, "Host deleted.");
 300
 301   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTDEL'ed %s from group '%s'.", controlid(sender), host, tg->name->content);
 302   trustlog(tg, sender->authname, "Removed host '%s'.", host);
 303
 304   return CMD_OK;
 305 }
 306
 307 static int modifycomment(void *arg, char *comment, nick *source, int override) {
 308   trustgroup *tg = arg;
 309   sstring *n = getsstring(comment, COMMENTLEN);
 310   if(!n)
 311     return 0;
 312
 313   freesstring(tg->comment);
 314   tg->comment = n;
 315
 316   return 1;
 317 }
 318
 319 static int modifycontact(void *arg, char *contact, nick *source, int override) {
 320   trustgroup *tg = arg;
 321   sstring *n = getsstring(contact, CONTACTLEN);
 322   if(!n)
 323     return 0;
 324
 325   freesstring(tg->contact);
 326   tg->contact = n;
 327
 328   return 1;
 329 }
 330
 331 static int modifytrustedfor(void *arg, char *num, nick *source, int override) {
 332   trustgroup *tg = arg;
 333   long trustedfor = strtol(num, NULL, 10);
 334
 335   if(trustedfor < 0) {
 336     controlreply(source, "The clone limit must not be negative.");
 337     return 0;
 338   }
 339
 340   if(!override) {
 341     if (trustedfor == 0) {
 342       controlreply(source, "You don't have the necessary privileges to set an unlimited clone limit.");
 343       return 0;
 344     }
 345
 346     if (trustedfor > MAXTRUSTEDFOR) {
 347       controlreply(source, "You don't have the necessary privileges to set the clone limit to a value higher than %d.", MAXTRUSTEDFOR);
 348       return 0;
 349     }
 350   }
 351
 352   tg->trustedfor = trustedfor;
 353
 354   return 1;
 355 }
 356
 357 static int modifymaxperident(void *arg, char *num, nick *source, int override) {
 358   trustgroup *tg = arg;
 359   long maxperident = strtol(num, NULL, 10);
 360
 361   if(maxperident < 0) {
 362     controlreply(source, "Ident limit must not be negative.");
 363     return 0;
 364   }
 365
 366   if(maxperident > MAXPERIDENT) {
 367     controlreply(source, "Ident limit must not be higher than %d. Consider setting it to 0 (unlimited) instead.", MAXPERIDENT);
 368     return 0;
 369   }
 370
 371   tg->maxperident = maxperident;
 372
 373   return 1;
 374 }
 375
 376 static int modifyenforceident(void *arg, char *num, nick *source, int override) {
 377   trustgroup *tg = arg;
 378
 379   if(num[0] == '1') {
 380     tg->flags |= TRUST_ENFORCE_IDENT;
 381   } else if(num[0] == '0') {
 382     tg->flags &= ~TRUST_ENFORCE_IDENT;
 383   } else {
 384     return 0;
 385   }
 386
 387   return 1;
 388 }
 389
 390 static int modifyreliableusername(void *arg, char *num, nick *source, int override) {
 391   trustgroup *tg = arg;
 392
 393   if(num[0] == '1') {
 394     tg->flags |= TRUST_RELIABLE_USERNAME;
 395   } else if(num[0] == '0') {
 396     tg->flags &= ~TRUST_RELIABLE_USERNAME;
 397   } else {
 398     return 0;
 399   }
 400
 401   return 1;
 402 }
 403
 404 static int modifyunthrottle(void *arg, char *num, nick *source, int override) {
 405   trustgroup *tg = arg;
 406
 407   if(num[0] == '1') {
 408     tg->flags |= TRUST_UNTHROTTLE;
 409   } else if(num[0] == '0') {
 410     tg->flags &= ~TRUST_UNTHROTTLE;
 411   } else {
 412     return 0;
 413   }
 414
 415   return 1;
 416 }
 417
 418 static int modifyexpires(void *arg, char *expires, nick *source, int override) {
 419   trustgroup *tg = arg;
 420   int howlong = durationtolong(expires);
 421
 422   if((howlong < 0) || (howlong > MAXDURATION)) {
 423     controlreply(source, "Duration cannot be negative or greater than %s (use 0 instead if you don't want the group to expire).", longtoduration(MAXDURATION, 0));
 424     return 0;
 425   }
 426
 427   if(howlong)
 428     tg->expires = getnettime() + howlong;
 429   else
 430     tg->expires = 0; /* never */
 431
 432   return 1;
 433 }
 434
 435 static int modifycleanup(void *arg, char *num, nick *source, int override) {
 436   trustgroup *tg = arg;
 437
 438   if(!override) {
 439     controlreply(source, "You don't have the necessary privileges to modify this attribute.");
 440     return 0;
 441   }
 442
 443   if(num[0] == '1') {
 444     tg->flags &= ~TRUST_NO_CLEANUP;
 445   } else if(num[0] == '0') {
 446     tg->flags |= TRUST_NO_CLEANUP;
 447   } else {
 448     return 0;
 449   }
 450
 451   return 1;
 452 }
 453
 454 static int modifyprotected(void *arg, char *num, nick *source, int override) {
 455   trustgroup *tg = arg;
 456
 457   if(!override) {
 458     controlreply(source, "You don't have the necessary privileges to modify this attribute.");
 459     return 0;
 460   }
 461
 462   if(num[0] == '1') {
 463     tg->flags |= TRUST_PROTECTED;
 464   } else if(num[0] == '0') {
 465     tg->flags &= ~TRUST_PROTECTED;
 466   } else {
 467     return 0;
 468   }
 469
 470   return 1;
 471 }
 472
 473 static int modifymaxpernode(void *arg, char *num, nick *source, int override) {
 474   trusthost *th = arg;
 475   int maxpernode = strtol(num, NULL, 10);
 476
 477   if(maxpernode < 0) {
 478     controlreply(source, "Node limit must not be negative.");
 479     return 0;
 480   }
 481
 482   if(maxpernode>MAXPERNODE) {
 483     controlreply(source, "Node limit must not be higher than %d. Consider setting it to 0 (unlimited) instead.", MAXPERNODE);
 484     return 0;
 485   }
 486
 487   th->maxpernode = maxpernode;
 488
 489   return 1;
 490 }
 491
 492 static int modifynodebits(void *arg, char *num, nick *source, int override) {
 493   trusthost *th = arg;
 494   int nodebits = strtol(num, NULL, 10);
 495
 496   if(nodebits < 0) {
 497     controlreply(source, "Node bits must not be negative.");
 498     return 0;
 499   }
 500
 501   if(irc_in_addr_is_ipv4(&th->ip))
 502     nodebits += 96;
 503
 504   if(nodebits > 128) {
 505     controlreply(source, "Node bits is invalid.");
 506     return 0;
 507   }
 508
 509   if(!override) {
 510     int minbits = irc_in_addr_is_ipv4(&th->ip)?TRUST_MIN_UNPRIVILEGED_NODEBITS_IPV4:TRUST_MIN_UNPRIVILEGED_NODEBITS_IPV6;
 511
 512     if(nodebits < minbits) {
 513       controlreply(source, "You don't have the necessary privileges to set node bits to a subnet larger than /%d.", irc_bitlen(&th->ip, minbits));
 514       return 0;
 515     }
 516   }
 517
 518   if(nodebits<th->bits) {
 519     controlreply(source, "Node bits must be smaller or equal to the trusted CIDR's subnet size.");
 520     return 0;
 521   }
 522
 523   th->nodebits = nodebits;
 524
 525   return 1;
 526 }
 527
 528 static array trustgroupmods_a;
 529 static struct trustmodification *trustgroupmods;
 530 static array trusthostmods_a;
 531 static struct trustmodification *trusthostmods;
 532
 533 static int trusts_cmdtrustgroupmodify(void *source, int cargc, char **cargv) {
 534   trustgroup *tg;
 535   nick *sender = source;
 536   char *what, *to;
 537   int i, override;
 538
 539   if(cargc < 3)
 540     return CMD_USAGE;
 541
 542   tg = tg_strtotg(cargv[0]);
 543   if(!tg) {
 544     controlreply(sender, "Couldn't look up trustgroup.");
 545     return CMD_ERROR;
 546   }
 547
 548   what = cargv[1];
 549   to = cargv[2];
 550
 551   override = noperserv_policy_command_permitted(NO_DEVELOPER, sender);
 552
 553   /* Don't allow non-developers to modify protected groups. */
 554   if (!override && tg->flags & TRUST_PROTECTED) {
 555     controlreply(sender, "You don't have the necessary privileges to modify a protected trust group.");
 556     return CMD_ERROR;
 557   }
 558
 559   for(i=0;i<trustgroupmods_a.cursi;i++) {
 560     if(!strcmp(what, trustgroupmods[i].name)) {
 561       if(!(trustgroupmods[i].fn)(tg, to, sender, override)) {
 562         controlreply(sender, "An error occured changing that property, check the syntax.");
 563         return CMD_ERROR;
 564       }
 565       break;
 566     }
 567   }
 568
 569   if(i == trustgroupmods_a.cursi)
 570     return CMD_USAGE;
 571
 572   triggerhook(HOOK_TRUSTS_MODIFYGROUP, tg);
 573   tg_update(tg);
 574   controlreply(sender, "Group modified.");
 575
 576   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTMODIFIED'ed group '%s' (field: %s, value: %s)", controlid(sender), tg->name->content, what, to);
 577   trustlog(tg, sender->authname, "Modified %s: %s", what, to);
 578
 579   return CMD_OK;
 580 }
 581
 582 static int trusts_cmdtrusthostmodify(void *source, int cargc, char **cargv) {
 583   trustgroup *tg;
 584   trusthost *th;
 585   nick *sender = source;
 586   char *what, *to;
 587   int i, override;
 588   struct irc_in_addr ip;
 589   unsigned char bits;
 590
 591   if(cargc < 4)
 592     return CMD_USAGE;
 593
 594   tg = tg_strtotg(cargv[0]);
 595   if(!tg) {
 596     controlreply(sender, "Couldn't look up trustgroup.");
 597     return CMD_ERROR;
 598   }
 599
 600   if(!ipmask_parse(cargv[1], &ip, &bits)) {
 601     controlreply(sender, "Invalid host.");
 602     return CMD_ERROR;
 603   }
 604
 605   /* Don't allow non-developers to modify trusts for large subnets or modify protected groups. */
 606   if (!noperserv_policy_command_permitted(NO_DEVELOPER, sender)) {
 607     int minbits = irc_in_addr_is_ipv4(&ip)?TRUST_MIN_UNPRIVILEGED_BITS_IPV4:TRUST_MIN_UNPRIVILEGED_BITS_IPV6;
 608     if(bits < minbits) {
 609       controlreply(sender, "You don't have the necessary privileges to modify a subnet larger than /%d.", irc_bitlen(&ip, minbits));
 610       return CMD_ERROR;
 611     }
 612
 613     if(tg->flags & TRUST_PROTECTED) {
 614       controlreply(sender, "You don't have the necessary privileges to modify a protected trust group.");
 615       return CMD_ERROR;
 616     }
 617   }
 618
 619   th = th_getbyhostandmask(&ip, bits);
 620
 621   if(!th || th->group != tg) {
 622     controlreply(sender, "Host does not belong to the specified group.");
 623     return CMD_ERROR;
 624   }
 625
 626   what = cargv[2];
 627   to = cargv[3];
 628
 629   override = noperserv_policy_command_permitted(NO_DEVELOPER, sender);
 630
 631   for(i=0;i<trusthostmods_a.cursi;i++) {
 632     if(!strcmp(what, trusthostmods[i].name)) {
 633       if(!(trusthostmods[i].fn)(th, to, sender, override)) {
 634         controlreply(sender, "An error occured changing that property, check the syntax.");
 635         return CMD_ERROR;
 636       }
 637       break;
 638     }
 639   }
 640
 641   if(i == trusthostmods_a.cursi)
 642     return CMD_USAGE;
 643
 644   triggerhook(HOOK_TRUSTS_MODIFYHOST, th);
 645   th_update(th);
 646   controlreply(sender, "Host modified.");
 647
 648   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTMODIFIED'ed host '%s' in group '%s' (field: %s, value: %s)", controlid(sender), CIDRtostr(ip, bits), tg->name->content, what, to);
 649   trustlog(tg, sender->authname, "Modified %s for host '%s': %s", what, CIDRtostr(ip, bits), to);
 650
 651   return CMD_OK;
 652 }
 653
 654 static int trusts_cmdtrustlog(void *source, int cargc, char **cargv) {
 655   nick *sender = source;
 656   char *name;
 657   int groupid;
 658   long limit = 0;
 659
 660   if(cargc < 1)
 661     return CMD_USAGE;
 662
 663   if(cargc>1)
 664     limit = strtol(cargv[1], NULL, 10);
 665
 666   if(limit==0)
 667     limit = 100;
 668
 669   name = cargv[0];
 670
 671   if (name[0] == '#') {
 672     groupid = strtol(name + 1, NULL, 10);
 673     trustlogspewid(sender, groupid, limit);
 674   } else {
 675     trustlogspewname(sender, name, limit);
 676   }
 677
 678   return CMD_OK;
 679 }
 680
 681 static int trusts_cmdtrustloggrep(void *source, int cargc, char **cargv) {
 682   nick *sender = source;
 683   char *pattern;
 684   long limit = 0;
 685
 686   if(cargc < 1)
 687     return CMD_USAGE;
 688
 689   pattern = cargv[0];
 690
 691   if(cargc>1)
 692     limit = strtol(cargv[1], NULL, 10);
 693
 694   if(limit==0)
 695     limit = 100;
 696
 697   trustloggrep(sender, pattern, limit);
 698
 699   return CMD_OK;
 700 }
 701
 702 static int trusts_cmdtrustcomment(void *source, int cargc, char **cargv) {
 703   nick *sender = source;
 704   trustgroup *tg = NULL;
 705   char *name, *comment;
 706
 707   if(cargc < 2)
 708     return CMD_USAGE;
 709
 710   name = cargv[0];
 711   comment = cargv[1];
 712
 713   if(strlen(comment)>TRUSTLOGLEN) {
 714     controlreply(sender, "Your comment is too long (max: %d characters).", TRUSTLOGLEN);
 715     return CMD_OK;
 716   }
 717
 718   tg = tg_strtotg(name);
 719
 720   if(!tg) {
 721     controlreply(sender, "Invalid trust group name or ID.");
 722     return CMD_OK;
 723   }
 724
 725   controlwall(NO_OPER, NL_TRUSTS, "%s TRUSTCOMMENT'ed group '%s': %s", controlid(sender), tg->name->content, comment);
 726   trustlog(tg, sender->authname, "Comment: %s", comment);
 727
 728   return CMD_OK;
 729 }
 730
 731 static void cleanuptrusts(void *arg);
 732
 733 static int trusts_cmdtrustcleanup(void *source, int cargc, char **cargv) {
 734   cleanuptrusts(source);
 735
 736   controlreply(source, "Done.");
 737
 738   return CMD_OK;
 739 }
 740
 741
 742 static int commandsregistered;
 743
 744 static void registercommands(int hooknum, void *arg) {
 745   static char tgmhelp[512], thmhelp[512];
 746   char validfields[512];
 747   StringBuf b;
 748   int i;
 749
 750   if(commandsregistered)
 751     return;
 752   commandsregistered = 1;
 753
 754   registercontrolhelpcmd("trustgroupadd", NO_OPER, 6, trusts_cmdtrustgroupadd, "Usage: trustgroupadd <name> <howmany> <maxperident> <enforceident> <contact> ?comment?");
 755   registercontrolhelpcmd("trustadd", NO_OPER, 2, trusts_cmdtrustadd, "Usage: trustadd <#id|name|id> <host>");
 756   registercontrolhelpcmd("trustgroupdel", NO_OPER, 1, trusts_cmdtrustgroupdel, "Usage: trustgroupdel <#id|name|id>");
 757   registercontrolhelpcmd("trustdel", NO_OPER, 2, trusts_cmdtrustdel, "Usage: trustdel <#id|name|id> <ip/mask>");
 758
 759   sbinit(&b, validfields, sizeof(validfields));
 760   for(i=0;i<trustgroupmods_a.cursi;i++) {
 761     if(i > 0)
 762       sbaddstr(&b, ", ");
 763     sbaddstr(&b, trustgroupmods[i].name);
 764   }
 765   sbterminate(&b);
 766
 767   snprintf(tgmhelp, sizeof(tgmhelp), "Usage: trustgroupmodify <#id|name|id> <field> <new value>\nModifies a trust group.\nValid fields: %s", validfields);
 768   registercontrolhelpcmd("trustgroupmodify", NO_OPER, 3, trusts_cmdtrustgroupmodify, tgmhelp);
 769
 770   sbinit(&b, validfields, sizeof(validfields));
 771   for(i=0;i<trusthostmods_a.cursi;i++) {
 772     if(i > 0)
 773       sbaddstr(&b, ", ");
 774     sbaddstr(&b, trusthostmods[i].name);
 775   }
 776   sbterminate(&b);
 777
 778   snprintf(thmhelp, sizeof(thmhelp), "Usage: trusthostmodify <#id|name|id> <host> <field> <new value>\nModifies a trust host\nValid fields: %s", validfields);
 779   registercontrolhelpcmd("trusthostmodify", NO_OPER, 4, trusts_cmdtrusthostmodify, thmhelp);
 780
 781   registercontrolhelpcmd("trustlog", NO_OPER, 2, trusts_cmdtrustlog, "Usage: trustlog <#id|name> ?limit?\nShows log for the specified trust group.");
 782   registercontrolhelpcmd("trustloggrep", NO_OPER, 2, trusts_cmdtrustloggrep, "Usage trustloggrep <pattern> ?limit?\nShows maching log entries.");
 783   registercontrolhelpcmd("trustcomment", NO_OPER, 2, trusts_cmdtrustcomment, "Usage: trustcomment <#id|name> <comment>\nLogs a comment for a trust.");
 784   registercontrolhelpcmd("trustcleanup", NO_DEVELOPER, 0, trusts_cmdtrustcleanup, "Usage: trustcleanup\nCleans up unused trusts.");
 785 }
 786
 787 static void deregistercommands(int hooknum, void *arg) {
 788   if(!commandsregistered)
 789     return;
 790   commandsregistered = 0;
 791
 792   deregistercontrolcmd("trustgroupadd", trusts_cmdtrustgroupadd);
 793   deregistercontrolcmd("trustadd", trusts_cmdtrustadd);
 794   deregistercontrolcmd("trustgroupdel", trusts_cmdtrustgroupdel);
 795   deregistercontrolcmd("trustdel", trusts_cmdtrustdel);
 796   deregistercontrolcmd("trustgroupmodify", trusts_cmdtrustgroupmodify);
 797   deregistercontrolcmd("trusthostmodify", trusts_cmdtrusthostmodify);
 798   deregistercontrolcmd("trustlog", trusts_cmdtrustlog);
 799   deregistercontrolcmd("trustloggrep", trusts_cmdtrustloggrep);
 800   deregistercontrolcmd("trustcomment", trusts_cmdtrustcomment);
 801   deregistercontrolcmd("trustcleanup", trusts_cmdtrustcleanup);
 802 }
 803
 804 static int loaded;
 805
 806 #define _ms_(x) (struct trustmodification){ .name = # x, .fn = modify ## x }
 807 #define MSGROUP(x) { int slot = array_getfreeslot(&trustgroupmods_a); trustgroupmods = (struct trustmodification *)trustgroupmods_a.content; memcpy(&trustgroupmods[slot], &_ms_(x), sizeof(struct trustmodification)); }
 808 #define MSHOST(x) { int slot = array_getfreeslot(&trusthostmods_a); trusthostmods = (struct trustmodification *)trusthostmods_a.content; memcpy(&trusthostmods[slot], &_ms_(x), sizeof(struct trustmodification)); }
 809
 810 static void setupmods(void) {
 811   MSGROUP(expires);
 812   MSGROUP(enforceident);
 813   MSGROUP(reliableusername);
 814   MSGROUP(maxperident);
 815   MSGROUP(contact);
 816   MSGROUP(comment);
 817   MSGROUP(trustedfor);
 818   MSGROUP(cleanup);
 819   MSGROUP(protected);
 820   MSGROUP(unthrottle);
 821
 822   MSHOST(maxpernode);
 823   MSHOST(nodebits);
 824 }
 825
 826 static int cleanuptrusts_active;
 827
 828 static void cleanuptrusts(void *arg) {
 829   unsigned int now, to_age;
 830   nick *np = (nick *)arg;
 831   trustgroup *tg;
 832   trusthost *th;
 833   int thcount = 0, tgcount = 0;
 834   int i;
 835   array expiredths, expiredtgs;
 836
 837   now = getnettime();
 838   to_age = now - (CLEANUP_TH_INACTIVE * 3600 * 24);
 839
 840   if(np) {
 841     controlwall(NO_OPER, NL_TRUSTS, "CLEANUPTRUSTS: Manually started by %s.", np->nick);
 842   } else {
 843     controlwall(NO_OPER, NL_TRUSTS, "CLEANUPTRUSTS: Automatically started.");
 844   }
 845
 846   if (cleanuptrusts_active) {
 847     controlwall(NO_OPER, NL_TRUSTS, "CLEANUPTRUSTS: ABORTED! Cleanup already in progress! BUG BUG BUG!");
 848     return;
 849   }
 850
 851   cleanuptrusts_active=1;
 852
 853   array_init(&expiredtgs, sizeof(trustgroup *));
 854
 855   for(tg=tglist;tg;tg=tg->next) {
 856     array_init(&expiredths, sizeof(trusthost *));
 857
 858     if(tg->flags & TRUST_NO_CLEANUP)
 859       continue;
 860
 861     for(th=tg->hosts;th;th=th->next) {
 862       if((th->count == 0 && th->created < to_age && th->lastseen < to_age) || (tg->expires && tg->expires < now)) {
 863         int pos = array_getfreeslot(&expiredths);
 864         ((trusthost **)(expiredths.content))[pos] = th;
 865       }
 866     }
 867
 868     for(i=0;i<expiredths.cursi;i++) {
 869       const char *cidrstr;
 870
 871       th = ((trusthost **)(expiredths.content))[i];
 872       triggerhook(HOOK_TRUSTS_DELHOST, th);
 873
 874       cidrstr = CIDRtostr(th->ip, th->bits);
 875       trustlog(tg, "cleanuptrusts", "Removed host '%s' because it was unused for %d days.", cidrstr, CLEANUP_TH_INACTIVE);
 876
 877       th_delete(th);
 878
 879       thcount++;
 880     }
 881
 882     if(!tg->hosts) {
 883       int pos = array_getfreeslot(&expiredtgs);
 884       ((trustgroup **)(expiredtgs.content))[pos] = tg;
 885     }
 886   }
 887
 888   for(i=0;i<expiredtgs.cursi;i++) {
 889     tg = ((trustgroup **)(expiredtgs.content))[i];
 890     triggerhook(HOOK_TRUSTS_DELGROUP, tg);
 891     trustlog(tg, "cleanuptrusts", "Deleted group '%s' because it had no hosts left.", tg->name->content);
 892     tg_delete(tg);
 893     tgcount++;
 894   }
 895
 896   controlwall(NO_OPER, NL_TRUSTS, "CLEANUPTRUSTS: Removed %d trust hosts (inactive for %d days) and %d empty trust groups.", thcount, CLEANUP_TH_INACTIVE, tgcount);
 897
 898   cleanuptrusts_active=0;
 899 }
 900
 901 static void schedulecleanup(int hooknum, void *arg) {
 902   /* run at 1am but only if we're more than 15m away from it, otherwise run tomorrow */
 903
 904   time_t t = time(NULL);
 905   time_t next_run = ((t / 86400) * 86400 + 86400) + 3600;
 906   if(next_run - t < 900)
 907     next_run+=86400;
 908
 909   schedulerecurring(next_run,0,86400,cleanuptrusts,NULL);
 910 }
 911
 912 void _init(void) {
 913   sstring *m;
 914
 915   array_init(&trustgroupmods_a, sizeof(struct trustmodification));
 916   array_init(&trusthostmods_a, sizeof(struct trustmodification));
 917   setupmods();
 918
 919   m = getconfigitem("trusts", "master");
 920   if(!m || (atoi(m->content) != 1)) {
 921     Error("trusts_management", ERR_ERROR, "Not a master server, not loaded.");
 922     return;
 923   }
 924
 925   loaded = 1;
 926
 927   registerhook(HOOK_TRUSTS_DB_LOADED, registercommands);
 928   registerhook(HOOK_TRUSTS_DB_LOADED, schedulecleanup);
 929   registerhook(HOOK_TRUSTS_DB_CLOSED, deregistercommands);
 930
 931   if(trustsdbloaded)
 932     registercommands(0, NULL);
 933 }
 934
 935 void _fini(void) {
 936   array_free(&trustgroupmods_a);
 937   array_free(&trusthostmods_a);
 938
 939   if(!loaded)
 940     return;
 941
 942   deregisterhook(HOOK_TRUSTS_DB_LOADED, registercommands);
 943   deregisterhook(HOOK_TRUSTS_DB_CLOSED, deregistercommands);
 944
 945   deregistercommands(0, NULL);
 946
 947   deleteallschedules(cleanuptrusts);
 948 }