trusts/trusts_commands.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include "../control/control.h"
   4 #include "../lib/irc_string.h"
   5 #include "../lib/strlfunc.h"
   6 #include "../core/nsmalloc.h"
   7 #include "../irc/irc.h"
   8 #include "../newsearch/newsearch.h"
   9 #include "trusts.h"
  10 #include "newsearch/trusts_newsearch.h"
  11
  12 static void registercommands(int, void *);
  13 static void deregistercommands(int, void *);
  14
  15 extern void printnick_channels(searchCtx *, nick *, nick *);
  16
  17 void calculatespaces(int spaces, int width, char *str, char **_prebuf, char **_postbuf) {
  18   static char prebuf[512], postbuf[512];
  19   int spacelen;
  20
  21   if(spaces + 5 >= sizeof(prebuf)) {
  22     prebuf[0] = prebuf[1] = '\0';
  23   } else {
  24     memset(prebuf, ' ', spaces);
  25     prebuf[spaces] = '\0';
  26   }
  27
  28   spacelen = width - (strlen(str) + spaces);
  29   if(spacelen <= 0 || spacelen + 5 >= sizeof(postbuf)) {
  30     postbuf[0] = postbuf[1] = '\0';
  31   } else {
  32     memset(postbuf, ' ', spacelen);
  33     postbuf[spacelen] = '\0';
  34   }
  35
  36   *_prebuf = prebuf;
  37   *_postbuf = postbuf;
  38 }
  39
  40 static void traverseandmark(unsigned int marker, trusthost *th) {
  41   th->marker = marker;
  42
  43   for(th=th->children;th;th=th->nextbychild) {
  44     th->marker = marker;
  45     traverseandmark(marker, th);
  46   }
  47 }
  48
  49 static void insertth(array *parents, trusthost *th) {
  50   int i;
  51   trusthost **p2 = (trusthost **)(parents->content);
  52
  53   /* this eliminates common subtrees */
  54   for(i=0;i<parents->cursi;i++)
  55     if(p2[i] == th)
  56       break;
  57
  58   if(i == parents->cursi) {
  59     int pos = array_getfreeslot(parents);
  60     ((trusthost **)(parents->content))[pos] = th;
  61   }
  62 }
  63
  64 static void marktree(array *parents, unsigned int marker, trusthost *th) {
  65   trusthost *pth;
  66   int parentcount = 0;
  67
  68   for(pth=th->parent;pth;pth=pth->parent) {
  69     insertth(parents, pth);
  70
  71     pth->marker = marker;
  72   }
  73
  74   if(parentcount == 0)
  75     insertth(parents, th);
  76
  77   /* sadly we need to recurse down */
  78   traverseandmark(marker, th);
  79 }
  80
  81 static void outputtree(nick *np, unsigned int marker, trustgroup *originalgroup, trusthost *th, int depth) {
  82   char *cidrstr, *prespacebuf, *postspacebuf, parentbuf[512];
  83
  84   if(th->marker != marker)
  85     return;
  86
  87   cidrstr = trusts_cidr2str(&th->ip, th->bits);
  88   calculatespaces(depth + 1, 30 + 1, cidrstr, &prespacebuf, &postspacebuf);
  89
  90   if(th->group == originalgroup) {
  91     prespacebuf[0] = '>';
  92
  93     parentbuf[0] = '\0';
  94   } else {
  95     /* show the ids of other groups */
  96
  97     snprintf(parentbuf, sizeof(parentbuf), "%-10d %s", th->group->id, th->group->name->content);
  98   }
  99
 100   controlreply(np, "%s%s%s %-10d %-10d %-21s %-15d /%-14d%s", prespacebuf, cidrstr, postspacebuf, th->count, th->maxusage, (th->count>0)?"(now)":((th->lastseen>0)?trusts_timetostr(th->lastseen):"(never)"), th->maxpernode, (irc_in_addr_is_ipv4(&th->ip))?(th->nodebits - 96):th->nodebits, parentbuf);
 101
 102   /* Make sure we're not seeing this subtree again. */
 103   th->marker = -1;
 104
 105   for(th=th->children;th;th=th->nextbychild)
 106     outputtree(np, marker, originalgroup, th, depth + 1);
 107 }
 108
 109 static void displaygroup(nick *sender, trustgroup *tg) {
 110   trusthost *th, **p2;
 111   unsigned int marker;
 112   array parents;
 113   int i;
 114   time_t t = getnettime();
 115
 116   /* abusing the ternary operator a bit :( */
 117   controlreply(sender, "Name:            : %s", tg->name->content);
 118   controlreply(sender, "Trusted for      : %d", tg->trustedfor);
 119   controlreply(sender, "Currently using  : %d", tg->count);
 120   controlreply(sender, "Clients per user : %d (%senforcing ident)", tg->maxperident, tg->mode?"":"not ");
 121   controlreply(sender, "Contact:         : %s", tg->contact->content);
 122   controlreply(sender, "Expires in       : %s", (tg->expires)?((tg->expires>t)?longtoduration(tg->expires - t, 2):"the past (will be removed during next cleanup)"):"never");
 123   controlreply(sender, "Last changed by  : %s", tg->createdby->content);
 124   controlreply(sender, "Comment:         : %s", tg->comment->content);
 125   controlreply(sender, "ID:              : %u", tg->id);
 126   controlreply(sender, "Last used        : %s", (tg->count>0)?"(now)":((tg->lastseen>0)?trusts_timetostr(tg->lastseen):"(never)"));
 127   controlreply(sender, "Max usage        : %d", tg->maxusage);
 128   controlreply(sender, "Last max reset   : %s", tg->lastmaxusereset?trusts_timetostr(tg->lastmaxusereset):"(never)");
 129
 130   controlreply(sender, "Host                            Current    Max        Last seen             Max per Node    Node Mask      Group ID   Group name");
 131
 132   marker = nextthmarker();
 133   array_init(&parents, sizeof(trusthost *));
 134
 135   for(th=tg->hosts;th;th=th->next)
 136     marktree(&parents, marker, th);
 137
 138   p2 = (trusthost **)(parents.content);
 139   for(i=0;i<parents.cursi;i++)
 140     outputtree(sender, marker, tg, p2[i], 0);
 141
 142   array_free(&parents);
 143
 144   controlreply(sender, "End of list.");
 145 }
 146
 147 static int trusts_cmdtrustlist(void *source, int cargc, char **cargv) {
 148   nick *sender = source;
 149   trustgroup *tg = NULL;
 150   int found = 0, remaining = 50;
 151   char *name;
 152   trusthost *th;
 153   struct irc_in_addr ip;
 154   unsigned char bits;
 155
 156   if(cargc < 1)
 157     return CMD_USAGE;
 158
 159   name = cargv[0];
 160
 161   tg = tg_strtotg(name);
 162
 163   if(tg) {
 164     displaygroup(sender, tg);
 165     return CMD_OK;
 166   }
 167
 168   if(ipmask_parse(name, &ip, &bits)) {
 169     th = th_getbyhost(&ip);
 170
 171     if(!th) {
 172       controlreply(sender, "Specified IP address is not trusted.");
 173       return CMD_OK;
 174     }
 175
 176     displaygroup(sender, th->group);
 177     return CMD_OK;
 178   }
 179
 180   for(tg=tglist;tg;tg=tg->next) {
 181     if(match(name, tg->name->content))
 182       continue;
 183
 184     displaygroup(sender, tg);
 185     if(--remaining == 0) {
 186       controlreply(sender, "Maximum number of matches reached.");
 187       return CMD_OK;
 188     }
 189     found = 1;
 190   }
 191
 192   if(!found)
 193     controlreply(sender, "No matches found.");
 194
 195   return CMD_OK;
 196 }
 197
 198 static int comparetgs(const void *_a, const void *_b) {
 199   const trustgroup *a = _a;
 200   const trustgroup *b = _b;
 201
 202   if(a->id > b->id)
 203     return 1;
 204   if(a->id < b-> id)
 205     return -1;
 206   return 0;
 207 }
 208
 209 static int trusts_cmdtrustdump(void *source, int argc, char **argv) {
 210   trusthost *th;
 211   trustgroup *tg, **atg;
 212   unsigned int wanted, max, maxid, totalcount, i, groupcount, linecount;
 213   nick *np = source;
 214
 215   if((argc < 2) || (argv[0][0] != '#'))
 216     return CMD_USAGE;
 217
 218   wanted = atoi(&argv[0][1]);
 219   max = atoi(argv[1]);
 220
 221   for(maxid=totalcount=0,tg=tglist;tg;tg=tg->next) {
 222     if(totalcount == 0 || tg->id > maxid)
 223       maxid = tg->id;
 224
 225     totalcount++;
 226   }
 227
 228   if(maxid > totalcount) {
 229     controlreply(np, "Start ID cannot exceed current maximum group ID (#%u)", maxid);
 230     return CMD_OK;
 231   }
 232
 233   atg = nsmalloc(POOL_TRUSTS, sizeof(trusthost *) * totalcount);
 234   if(!atg) {
 235     controlreply(np, "Memory error.");
 236     return CMD_ERROR;
 237   }
 238
 239   for(i=0,tg=tglist;i<totalcount&&tg;tg=tg->next,i++)
 240     atg[i] = tg;
 241
 242   qsort(atg, totalcount, sizeof(trustgroup *), comparetgs);
 243
 244   for(i=0;i<totalcount;i++)
 245     if(atg[i]->id >= wanted)
 246       break;
 247
 248   for(groupcount=linecount=0;i<totalcount;i++) {
 249     linecount++;
 250     groupcount++;
 251
 252     controlreply(np, "G,%s", dumptg(atg[i], 1));
 253
 254     for(th=atg[i]->hosts;th;th=th->next) {
 255       linecount++;
 256       controlreply(np, "H,%s", dumpth(th, 1));
 257     }
 258
 259     if(--max == 0)
 260       break;
 261   }
 262   nsfree(POOL_TRUSTS, atg);
 263
 264   controlreply(np, "End of list, %u groups and %u lines returned.", groupcount, linecount);
 265   return CMD_OK;
 266 }
 267
 268 static int trusts_cmdtrustgline(void *source, int cargc, char **cargv) {
 269   trustgroup *tg;
 270   nick *sender = source;
 271   char *user, *reason;
 272   int duration, count;
 273
 274   if(cargc < 4)
 275     return CMD_USAGE;
 276
 277   tg = tg_strtotg(cargv[0]);
 278   if(!tg) {
 279     controlreply(sender, "Couldn't look up trustgroup.");
 280     return CMD_ERROR;
 281   }
 282
 283   user = cargv[1];
 284
 285   duration = durationtolong(cargv[2]);
 286   if((duration <= 0) || (duration > MAXDURATION)) {
 287     controlreply(sender, "Invalid duration supplied.");
 288     return CMD_ERROR;
 289   }
 290
 291   reason = cargv[3];
 292
 293   count = trustgline(tg, user, duration, reason);
 294
 295   controlwall(NO_OPER, NL_GLINES|NL_TRUSTS, "%s TRUSTGLINE'd user '%s' on group '%s', %d gline(s) set.", controlid(sender), user, tg->name->content, count);
 296   controlreply(sender, "Done. %d gline(s) set.", count);
 297
 298   return CMD_OK;
 299 }
 300
 301 static int trusts_cmdtrustungline(void *source, int cargc, char **cargv) {
 302   trustgroup *tg;
 303   nick *sender = source;
 304   char *user;
 305   int count;
 306
 307   if(cargc < 2)
 308     return CMD_USAGE;
 309
 310   tg = tg_strtotg(cargv[0]);
 311   if(!tg) {
 312     controlreply(sender, "Couldn't look up trustgroup.");
 313     return CMD_ERROR;
 314   }
 315
 316   user = cargv[1];
 317
 318   count = trustungline(tg, user, 0, "Deactivated.");
 319
 320   controlwall(NO_OPER, NL_GLINES|NL_TRUSTS, "%s TRUSTUNGLINE'd user '%s' on group '%s', %d gline(s) removed.", controlid(sender), user, tg->name->content, count);
 321   controlreply(sender, "Done. %d gline(s) removed.", count);
 322
 323   return CMD_OK;
 324 }
 325
 326 static int trusts_cmdtrustspew(void *source, int cargc, char **cargv) {
 327   nick *sender = source;
 328   searchASTExpr tree;
 329
 330   if(cargc < 1)
 331     return CMD_USAGE;
 332
 333   tree = NSASTNode(tgroup_parse, NSASTLiteral(cargv[0]));
 334   return ast_nicksearch(&tree, controlreply, sender, NULL, printnick_channels, NULL, NULL, 2000);
 335 }
 336
 337 static int commandsregistered;
 338
 339 static void registercommands(int hooknum, void *arg) {
 340   if(commandsregistered)
 341     return;
 342   commandsregistered = 1;
 343
 344   registercontrolhelpcmd("trustlist", NO_OPER, 1, trusts_cmdtrustlist, "Usage: trustlist <#id|name|IP>\nShows trust data for the specified trust group.");
 345   registercontrolhelpcmd("trustdump", NO_OPER, 2, trusts_cmdtrustdump, "Usage: trustdump <#id> <number>");
 346   registercontrolhelpcmd("trustgline", NO_OPER, 4, trusts_cmdtrustgline, "Usage: trustgline <#id|name> <user> <duration> <reason>\nGlines a user on all hosts of a trust group.");
 347   registercontrolhelpcmd("trustungline", NO_OPER, 4, trusts_cmdtrustungline, "Usage: trustungline <#id|name> <user>\nUnglines a user on all hosts of a trust group.");
 348   registercontrolhelpcmd("trustspew", NO_OPER, 1, trusts_cmdtrustspew, "Usage: trustspew <#id|name>\nShows currently connected users for the specified trust group.");
 349 }
 350
 351 static void deregistercommands(int hooknum, void *arg) {
 352   if(!commandsregistered)
 353     return;
 354   commandsregistered = 0;
 355
 356   deregistercontrolcmd("trustlist", trusts_cmdtrustlist);
 357   deregistercontrolcmd("trustdump", trusts_cmdtrustdump);
 358   deregistercontrolcmd("trustgline", trusts_cmdtrustgline);
 359   deregistercontrolcmd("trustungline", trusts_cmdtrustungline);
 360   deregistercontrolcmd("trustspew", trusts_cmdtrustspew);
 361 }
 362
 363 void _init(void) {
 364   registerhook(HOOK_TRUSTS_DB_LOADED, registercommands);
 365   registerhook(HOOK_TRUSTS_DB_CLOSED, deregistercommands);
 366
 367   if(trustsdbloaded)
 368     registercommands(0, NULL);
 369 }
 370
 371 void _fini(void) {
 372   deregisterhook(HOOK_TRUSTS_DB_LOADED, registercommands);
 373   deregisterhook(HOOK_TRUSTS_DB_CLOSED, deregistercommands);
 374
 375   deregistercommands(0, NULL);
 376 }