trusts/trusts_commands.c

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