mod.c

   1 #include "mod.h"
   2
   3 #include <libxml/xmlstring.h>
   4 #include <libxml/HTMLparser.h>
   5
   6 #include <stdint.h>
   7 #include <inttypes.h>
   8 #include <sys/wait.h>
   9 #include <curl/curl.h>
  10
  11 #include <magic.h>
  12
  13 #include "entities.h"
  14 #include "quotes.h"
  15
  16 static const char *nick_self;
  17 static unsigned ponify;
  18 #define elements(x) (sizeof(x)/sizeof(*x))
  19
  20 static struct tdb_context *feed_db, *chan_db, *mail_db, *seen_db;
  21
  22 static struct command_hash command_channel = { "#", NULL };
  23
  24 #define sstrncmp(a, b) (strncmp(a, b, sizeof(b)-1))
  25 #define sstrncasecmp(a, b) (strncasecmp(a, b, sizeof(b)-1))
  26
  27 #define SPAM_CUTOFF 5
  28
  29 static int pipe_command(struct bio *b, const char *target, const char *nick, int redirect_stdout, int redirect_stderr, char *argv[])
  30 {
  31         int fd[2];
  32         int lines = 0;
  33         if (pipe2(fd, O_CLOEXEC) < 0) {
  34                 privmsg(b, target, "Could not create pipe: %m");
  35                 return -1;
  36         }
  37         pid_t pid = fork();
  38         if (pid < 0) {
  39                 privmsg(b, target, "Could not fork: %m");
  40                 close(fd[0]);
  41                 close(fd[1]);
  42                 return -1;
  43         } else if (!pid) {
  44                 int fdnull = open("/dev/null", O_WRONLY|O_CLOEXEC);
  45                 close(fd[0]);
  46                 if (dup3(redirect_stdout ? fd[1] : fdnull, 1, 0) < 0)
  47                         exit(errno);
  48                 if (dup3(redirect_stderr ? fd[1] : fdnull, 2, 0) < 0)
  49                         exit(errno);
  50                 exit(execv(argv[0], argv));
  51         } else {
  52                 int loc = -1;
  53                 char buffer[0x100];
  54                 int bufptr = 0, ret;
  55                 close(fd[1]);
  56                 fcntl(fd[0], F_SETFL, O_NONBLOCK);
  57                 while ((ret = waitpid(pid, &loc, WNOHANG)) >= 0) {
  58                         while (read(fd[0], buffer+bufptr, 1) == 1) {
  59                                 if (buffer[bufptr] != '\n' && bufptr < sizeof(buffer)-1) {
  60                                         bufptr++;
  61                                         continue;
  62                                 } else if (bufptr) {
  63                                         buffer[bufptr] = 0;
  64                                         bufptr = 0;
  65                                         lines++;
  66                                         if (lines < SPAM_CUTOFF)
  67                                                 privmsg(b, nick, "%s", buffer);
  68                                         else
  69                                                 fprintf(stderr, "%s\n", buffer);
  70                                 }
  71                         }
  72
  73                         if (ret) {
  74                                 if (bufptr) {
  75                                         buffer[bufptr] = 0;
  76                                         if (lines < SPAM_CUTOFF)
  77                                                 privmsg(b, nick, "%s", buffer);
  78                                         else
  79                                                 fprintf(stderr, "%s\n", buffer);
  80                                 }
  81                                 if (lines >= SPAM_CUTOFF)
  82                                         privmsg(b, nick, "%i lines suppressed", lines - SPAM_CUTOFF + 1);
  83                                 break;
  84                         }
  85                 }
  86                 if (ret < 0)
  87                         privmsg(b, target, "error on waitpid: %m");
  88                 else
  89                         ret = loc;
  90                 close(fd[0]);
  91                 return ret;
  92         }
  93 }
  94
  95 #include "local.c"
  96
  97 static struct command_hash commands[2048];
  98
  99 static void command_abort(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 100 {
 101         abort();
 102         return;
 103 }
 104
 105 static void command_crash(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 106 {
 107         *(char*)0 = 0;
 108 }
 109
 110 static void command_coinflip(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 111 {
 112         if (getrand() & 1)
 113                 action(b, target, "whirrrs and clicks excitedly at %s", nick);
 114         else
 115                 action(b, target, "eyes %s as nothing happens", nick);
 116 }
 117
 118 static void command_shesaid(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 119 {
 120         privmsg(b, target, "%s: \"%s\"", args ? args : nick, women_quotes[getrand() % elements(women_quotes)]);
 121 }
 122
 123 static void squash(char *title)
 124 {
 125         char *start = title;
 126         goto start;
 127         while (*title) {
 128                 while (*title != '\n' && *title != '\r' && *title != '\t' && *title != ' ' && *title) {
 129                         *(start++) = *(title++);
 130                 }
 131                 if (*title)
 132                         *(start++) = ' ';
 133 start:
 134                 while (*title == '\n' || *title == '\r' || *title == '\t' || *title == ' ')
 135                         title++;
 136         }
 137         *start = 0;
 138 }
 139
 140 struct curl_download_context
 141 {
 142         char *data;
 143         size_t len;
 144 };
 145
 146 static size_t write_data(void *ptr, size_t size, size_t nmemb, void *member) {
 147         struct curl_download_context *ctx = member;
 148         size *= nmemb;
 149         ctx->data = realloc(ctx->data, ctx->len + size);
 150         memcpy(ctx->data + ctx->len, ptr, size);
 151         ctx->len += size;
 152         return size;
 153 }
 154
 155 static const char *get_text(xmlNode *cur)
 156 {
 157         for (; cur; cur = cur->next) {
 158                 if (cur->type == XML_TEXT_NODE)
 159                         return cur->content;
 160         }
 161         return NULL;
 162 }
 163
 164 static const char *get_link(xmlAttr *cur, const char *which)
 165 {
 166         for (; cur; cur = cur->next) {
 167                 if (!strcasecmp(cur->name, which))
 168                         return get_text(cur->children);
 169         }
 170         return NULL;
 171 }
 172
 173 static int get_feed_entry(struct bio *b, const char *nick, const char *target, const char *category, xmlNode *entry, const char **title, const char **link)
 174 {
 175         const char *cur_title = NULL, *cur_link = NULL;
 176         xmlNode *cur;
 177         int cur_match = !category;
 178         for (cur = entry->children; cur; cur = cur->next) {
 179                 const char *name = cur->name, *cur_cat;
 180                 if (cur->type != XML_ELEMENT_NODE)
 181                         continue;
 182                 else if (!strcasecmp(name, "link")) {
 183                         const char *ishtml = get_link(cur->properties, "type");
 184                         const char *rel = get_link(cur->properties, "rel");
 185                         if ((!ishtml || !strcasecmp(ishtml, "text/html")) &&
 186                             rel && !strcasecmp(rel, "alternate"))
 187                                 cur_link = get_link(cur->properties, "href");
 188                 } else if (!strcasecmp(name, "title"))
 189                         cur_title = get_text(cur->children);
 190                 else if (!cur_match && !strcasecmp(name, "category") &&
 191                          (cur_cat = get_link(cur->properties, "term")) &&
 192                          strcasestr(cur_cat, category))
 193                         cur_match = 1;
 194         }
 195
 196         if (cur_title)
 197                 *title = cur_title;
 198         else
 199                 *title = "<no title>";
 200         *link = cur_link;
 201         return !cur_link  ? -1 : cur_match;
 202 }
 203
 204 static const char *walk_feed(struct bio *b, const char *nick, const char *target, const char *url, const char *category, xmlNode *root, const char *last_link)
 205 {
 206         const char *main_title = NULL, *main_subtitle = NULL, *main_link = NULL, *title, *link, *prev_link = NULL, *prev_title = NULL;
 207         char *t;
 208         int match, updates = 0;
 209         xmlNode *cur, *entry = NULL;
 210         for (cur = root->children; cur; cur = cur->next) {
 211                 const char *name = cur->name;
 212                 if (cur->type != XML_ELEMENT_NODE)
 213                         continue;
 214                 else if (!strcasecmp(name, "category"))
 215                         continue;
 216                 else if (!strcasecmp(name, "entry"))
 217                         entry = entry ? entry : cur;
 218                 else if (!strcasecmp(name, "title"))
 219                         main_title = get_text(cur->children);
 220                 else if (!strcasecmp(name, "subtitle"))
 221                         main_subtitle = get_text(cur->children);
 222                 else if (!strcasecmp(name, "link")) {
 223                         const char *ishtml = get_link(cur->properties, "type");
 224                         const char *rel = get_link(cur->properties, "rel");
 225                         if ((!ishtml || !strcasecmp(ishtml, "text/html")) && rel && !strcasecmp(rel, "alternate"))
 226                                 main_link = get_link(cur->properties, "href");
 227                 }
 228         }
 229         if (!main_link || !main_title) {
 230                 privmsg(b, target, "%s: Failed to parse main: %s %s", nick, main_link, main_title);
 231                 return NULL;
 232         }
 233         if (!entry)
 234                 return NULL;
 235
 236         if (!last_link)
 237                 privmsg(b, target, "adding blog %s \"%s\": %s", main_link, main_title, main_subtitle);
 238
 239         match = get_feed_entry(b, nick, target, category, entry, &title, &link);
 240         if (match < 0)
 241                 return NULL;
 242
 243         for (; !match && entry; entry = entry->next) {
 244                 if (!strcasecmp(entry->name, "entry"))
 245                         match = get_feed_entry(b, nick, target, category, entry, &title, &link);
 246         }
 247
 248         if (match < 0)
 249                 return NULL;
 250         if (!last_link) {
 251                 if (match > 0) {
 252                         t = strdup(title);
 253                         squash(t);
 254                         privmsg(b, target, "Most recent entry: %s %s", link, t);
 255                         free(t);
 256                 } else
 257                         privmsg(b, target, "Currently having no entries for this feed that matches the filter");
 258                 return link;
 259         }
 260         if (!strcmp(last_link, link) || !match || !entry)
 261                 return link;
 262
 263         for (entry = entry->next; entry; entry = entry->next) {
 264                 const char *cur_link, *cur_title;
 265                 if (strcasecmp(entry->name, "entry"))
 266                         continue;
 267                 match = get_feed_entry(b, nick, target, category, entry, &cur_title, &cur_link);
 268                 if (match < 0 || !strcmp(last_link, cur_link))
 269                         break;
 270                 if (match) {
 271                         prev_link = cur_link;
 272                         prev_title = cur_title;
 273                         updates++;
 274                 }
 275         }
 276         if (updates == 1) {
 277                 t = strdup(prev_title);
 278                 squash(t);
 279                 privmsg(b, target, "( %s ): %s", prev_link, t);
 280                 free(t);
 281         } else if (updates > 1)
 282                 privmsg(b, target, "( %s ): %u updates, linking most recent", main_link, 1+updates);
 283         t = strdup(title);
 284         squash(t);
 285         privmsg(b, target, "( %s ): %s", link, t);
 286         free(t);
 287         return link;
 288 }
 289
 290 static const char *walk_rss(struct bio *b, const char *nick, const char *target, const char *url, xmlNode *root, const char *last_link)
 291 {
 292         const char *main_title = NULL, *main_link = NULL, *title = NULL, *link = NULL, *ver;
 293         char *t;
 294         xmlNode *cur, *entry = NULL;
 295         ver = get_link(root->properties, "version");
 296         if (!ver || strcmp(ver, "2.0")) {
 297                 if (!ver)
 298                         privmsg(b, target, "%s: Could not parse rss feed", nick);
 299                 else
 300                         privmsg(b, target, "%s: Invalid rss version \"%s\"", nick, ver);
 301                 return NULL;
 302         }
 303         for (cur = root->children; cur && cur->type != XML_ELEMENT_NODE; cur = cur->next);
 304         if (!cur)
 305                 return NULL;
 306         for (cur = cur->children; cur; cur = cur->next) {
 307                 const char *name = cur->name;
 308                 if (cur->type != XML_ELEMENT_NODE)
 309                         continue;
 310                 if (!strcasecmp(name, "title"))
 311                         main_title = get_text(cur->children);
 312                 else if (!strcasecmp(name, "link"))
 313                         main_link = main_link ? main_link : get_text(cur->children);
 314                 else if (!strcasecmp(name, "item"))
 315                         entry = entry ? entry : cur;
 316         }
 317         if (!main_link || !main_title) {
 318                 privmsg(b, target, "%s: Failed to parse main: %s %s", nick, main_link, main_title);
 319                 return NULL;
 320         }
 321         if (!entry)
 322                 return NULL;
 323
 324         link = title = NULL;
 325         for (cur = entry->children; cur; cur = cur->next) {
 326                 const char *name = cur->name;
 327                 if (cur->type != XML_ELEMENT_NODE)
 328                         continue;
 329                 if (!strcasecmp(name, "title"))
 330                         title = get_text(cur->children);
 331                 else if (!strcasecmp(name, "link"))
 332                         link = get_text(cur->children);
 333         }
 334         if (!title)
 335                 title = "<no title>";
 336         if (!link) {
 337                 privmsg(b, target, "%s: Failed to parse entry: %s %s", nick, link, title);
 338                 return NULL;
 339         }
 340         if (!last_link) {
 341                 t = strdup(title);
 342                 privmsg(b, target, "adding blog %s \"%s\"", main_link, main_title);
 343                 squash(t);
 344                 privmsg(b, target, "Most recent entry: %s %s", link, t);
 345                 free(t);
 346         } else if (strcmp(last_link, link)) {
 347                 int updates = 0;
 348                 const char *prev_title = NULL, *prev_link = NULL, *cur_title = NULL, *cur_link = NULL;
 349                 for (entry = entry->next; entry; entry = entry->next) {
 350                         if (strcasecmp(entry->name, "item"))
 351                                 continue;
 352                         prev_title = cur_title;
 353                         prev_link = cur_link;
 354                         cur_title = cur_link = NULL;
 355                         for (cur = entry->children; cur; cur = cur->next) {
 356                                 const char *name = cur->name;
 357                                 if (cur->type != XML_ELEMENT_NODE)
 358                                         continue;
 359                                 if (!strcasecmp(name, "title"))
 360                                         cur_title = get_text(cur->children);
 361                                 else if (!strcasecmp(name, "link"))
 362                                         cur_link = get_text(cur->children);
 363                         }
 364                         if (!cur_title)
 365                                 cur_title = "<no title>";
 366                         if (!cur_link || !strcmp(last_link, cur_link))
 367                                 break;
 368                         updates++;
 369                 }
 370                 if (updates == 1) {
 371                         t = strdup(prev_title);
 372                         squash(t);
 373                         privmsg(b, target, "( %s ): %s", prev_link, t);
 374                         free(t);
 375                 } else if (updates > 1)
 376                         privmsg(b, target, "( %s ): %u updates, linking most recent", main_link, 1+updates);
 377                 t = strdup(title);
 378                 squash(t);
 379                 privmsg(b, target, "( %s ): %s", link, t);
 380                 free(t);
 381         }
 382         return link;
 383 }
 384
 385 // HTML is a mess, so I'm just walking the tree depth first until I find the next element..
 386 static xmlNode *next_link(xmlNode *cur_node)
 387 {
 388         if (cur_node->children)
 389                 return cur_node->children;
 390         while (cur_node) {
 391                 if (cur_node->next)
 392                         return cur_node->next;
 393                 cur_node = cur_node->parent;
 394         }
 395         return NULL;
 396 }
 397
 398 static const char *get_atom_link(xmlNode *cur)
 399 {
 400         for (; cur; cur = next_link(cur)) {
 401                 if (cur->type != XML_ELEMENT_NODE)
 402                         continue;
 403                 if (!strcasecmp(cur->name, "link")) {
 404                         const char *isxml = get_link(cur->properties, "type");
 405                         if (isxml && !strcasecmp(isxml, "application/atom+xml"))
 406                                 return get_link(cur->properties, "href");
 407                 }
 408         }
 409         return NULL;
 410 }
 411
 412 static const char *get_rss_link(xmlNode *cur)
 413 {
 414         for (; cur; cur = next_link(cur)) {
 415                 if (cur->type != XML_ELEMENT_NODE)
 416                         continue;
 417                 if (!strcasecmp(cur->name, "link")) {
 418                         const char *isxml = get_link(cur->properties, "type");
 419                         if (isxml && !strcasecmp(isxml, "application/rss+xml"))
 420                                 return get_link(cur->properties, "href");
 421                 }
 422         }
 423         return NULL;
 424 }
 425
 426 static void do_html(struct bio *b, const char *nick, const char *target, const char *url, const char *data, unsigned len)
 427 {
 428         htmlDocPtr ctx = htmlReadMemory(data, len, 0, url, HTML_PARSE_RECOVER|HTML_PARSE_NOERROR|HTML_PARSE_NOWARNING);
 429         xmlNode *root = xmlDocGetRootElement(ctx);
 430         const char *link = get_atom_link(root);
 431         if (link)
 432                 privmsg(b, target, "%s: not a valid feed link, try atom: %s", nick, link);
 433         else if ((link = get_rss_link(root)))
 434                 privmsg(b, target, "%s: not a valid feed link, try rss: %s", nick, link);
 435         else
 436                 privmsg(b, target, "%s: not a valid feed link, no suggestion found", nick);
 437         xmlFreeDoc(ctx);
 438 }
 439
 440 static size_t get_time_from_header(void *data, size_t size, size_t size2, void *ptr)
 441 {
 442         char *d, *e;
 443         size *= size2;
 444         if (sstrncmp(data, "Last-Modified: "))
 445                 return size;
 446         data += sizeof("Last-Modified: ")-1;
 447         *(char**)ptr = d = strdup(data);
 448         if ((e = strchr(d, '\r')))
 449                 *e = 0;
 450         return size;
 451 }
 452
 453 static int check_single_feed(struct bio *b, const char *target, TDB_DATA key, const char *last_modified, const char *url, const char *link, const char *nick)
 454 {
 455         struct curl_download_context curl_ctx = {};
 456         struct curl_slist *headers = NULL;
 457         char error[CURL_ERROR_SIZE], *category = strchr(url, '#');
 458         int retval = -1;
 459         headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:9.0.1) Gecko/20100101 Firefox/9.0.1");
 460         headers = curl_slist_append(headers, "Accept: */*");
 461         if (category)
 462                 *(category++) = 0;
 463
 464         CURL *h = curl_easy_init();
 465         curl_easy_setopt(h, CURLOPT_HTTPHEADER, headers);
 466         curl_easy_setopt(h, CURLOPT_URL, url);
 467         curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, write_data);
 468         curl_easy_setopt(h, CURLOPT_WRITEDATA, &curl_ctx);
 469         curl_easy_setopt(h, CURLOPT_ERRORBUFFER, error);
 470         curl_easy_setopt(h, CURLOPT_FOLLOWLOCATION, 1);
 471         curl_easy_setopt(h, CURLOPT_MAXREDIRS, 3);
 472         curl_easy_setopt(h, CURLOPT_SSL_VERIFYPEER, 0);
 473         curl_easy_setopt(h, CURLOPT_TIMEOUT, 8);
 474         curl_easy_setopt(h, CURLOPT_CONNECTTIMEOUT, 8);
 475         curl_easy_setopt(h, CURLOPT_FILETIME, 1);
 476         curl_easy_setopt(h, CURLOPT_HEADERFUNCTION, get_time_from_header);
 477         curl_easy_setopt(h, CURLOPT_WRITEHEADER, &last_modified);
 478         //curl_easy_setopt(h, CURLOPT_VERBOSE, 1);
 479
 480         if (last_modified) {
 481                 char *tmp;
 482                 asprintf(&tmp, "If-Modified-Since: %s", last_modified);
 483                 headers = curl_slist_append(headers, tmp);
 484                 free(tmp);
 485         }
 486
 487         int success = curl_easy_perform(h);
 488         curl_slist_free_all(headers);
 489         if (success == CURLE_OK) {
 490                 char *mime = NULL;
 491                 long code;
 492                 curl_easy_getinfo(h, CURLINFO_CONTENT_TYPE, &mime);
 493                 curl_easy_getinfo(h, CURLINFO_RESPONSE_CODE, &code);
 494                 if (code == 304)
 495                         { }
 496                 else if (!mime || !sstrncmp(mime, "application/xml") || !sstrncmp(mime, "text/xml")) {
 497                         const char *ret_link = NULL;
 498                         xmlDocPtr ctx = xmlReadMemory(curl_ctx.data, curl_ctx.len, 0, url, XML_PARSE_NOWARNING | XML_PARSE_NOERROR);
 499                         xmlNode *root = xmlDocGetRootElement(ctx);
 500
 501                         if (!root || !root->name)
 502                                 fprintf(stderr, "Failed to parse feed %s %p", url, root);
 503                         else if (!strcasecmp(root->name, "feed"))
 504                                 ret_link = walk_feed(b, nick, target, url, category, root, link);
 505                         else if (!strcasecmp(root->name, "rss"))
 506                                 ret_link = walk_rss(b, nick, target, url, root, link);
 507                         else {
 508                                 privmsg(b, target, "Unknown feed type \"%s\"", root->name);
 509                                 goto free_ctx;
 510                         }
 511                         if (category)
 512                                 category[-1] = '#';
 513
 514                         if (ret_link && (!link || strcmp(ret_link, link))) {
 515                                 TDB_DATA val;
 516                                 asprintf((char**)&val.dptr, "%s\001%s", last_modified ? last_modified : "", ret_link);
 517                                 val.dsize = strlen(val.dptr)+1;
 518                                 if (tdb_store(feed_db, key, val, 0) < 0)
 519                                         privmsg(b, target, "updating returns %s", tdb_errorstr(feed_db));
 520                                 free(val.dptr);
 521                                 retval = 1;
 522                         }
 523                         else
 524                                 retval = 0;
 525
 526 free_ctx:
 527                         xmlFreeDoc(ctx);
 528                 } else if (link)
 529                         {}
 530                 else if (!sstrncmp(mime, "text/html") || !sstrncmp(mime, "application/xhtml+xml"))
 531                         do_html(b, nick, target, url, curl_ctx.data, curl_ctx.len);
 532                 else
 533                         privmsg(b, target, "unhandled content type %s", mime);
 534         } else if (!link)
 535                 privmsg(b, target, "Error %s (%u)", error, success);
 536
 537         free(curl_ctx.data);
 538         curl_easy_cleanup(h);
 539         return retval;
 540 }
 541
 542 static void command_follow(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 543 {
 544         char *space, *last_link = NULL;
 545         TDB_DATA key, val;
 546         int ret;
 547         if (!feed_db)
 548                 return;
 549         if (target[0] != '#') {
 550                 privmsg(b, target, "%s: Can only follow on channels", nick);
 551                 return;
 552         }
 553         if (!args || !*args) {
 554                 privmsg(b, target, "%s: Usage: !follow <url>", nick);
 555                 return;
 556         }
 557
 558         if (((space = strchr(args, ' ')) && space < strchr(args, '#')) ||
 559             (sstrncmp(args, "http://") && sstrncmp(args, "https://"))) {
 560                 privmsg(b, target, "%s: Invalid url", nick);
 561                 return;
 562         }
 563
 564         key.dsize = asprintf((char**)&key.dptr, "%s,%s", target, args)+1;
 565         val = tdb_fetch(feed_db, key);
 566         if (val.dptr)
 567                 last_link = strchr(val.dptr, '\001');
 568         ret = check_single_feed(b, target, key, NULL, args, last_link ? last_link+1 : NULL, nick);
 569         free(val.dptr);
 570         if (!ret)
 571                 privmsg(b, target, "%s: Not updated", nick);
 572         free(key.dptr);
 573 }
 574
 575 static void channel_feed_check(struct bio *b, const char *target, int64_t now)
 576 {
 577         int len = strlen(target);
 578         int64_t save[] = { now, 0, 0 };
 579
 580         TDB_DATA chan, res;
 581         if (!feed_db || !chan_db)
 582                 return;
 583         chan.dptr = (char*)target;
 584         chan.dsize = len+1;
 585         res = tdb_fetch(chan_db, chan);
 586         if (res.dptr && res.dsize >= 8) {
 587                 uint64_t then = *(uint64_t*)res.dptr;
 588                 if (now - then <= 8000)
 589                         return;
 590                 if (res.dsize >= 16)
 591                         save[1] = ((uint64_t*)res.dptr)[1];
 592                 if (res.dsize >= 24)
 593                         save[2] = ((uint64_t*)res.dptr)[2];
 594         }
 595         free(res.dptr);
 596         res.dptr = (unsigned char*)save;
 597         res.dsize = sizeof(save);
 598         if (tdb_store(chan_db, chan, res, 0) < 0) {
 599                 static int complain_db;
 600                 if (!complain_db++)
 601                         privmsg(b, target, "updating database: %s", tdb_errorstr(feed_db));
 602                 return;
 603         }
 604
 605         for (TDB_DATA d = tdb_firstkey(feed_db); d.dptr;) {
 606                 TDB_DATA f = tdb_fetch(feed_db, d);
 607                 TDB_DATA next = tdb_nextkey(feed_db, d);
 608
 609                 if (!strncmp(d.dptr, target, len) && d.dptr[len] == ',') {
 610                         const char *url = (char*)d.dptr + len + 1;
 611                         char *sep;
 612                         if ((sep = strchr(f.dptr, '\001'))) {
 613                                 *(sep++) = 0;
 614                                 check_single_feed(b, target, d, f.dptr, url, sep, target);
 615                         }
 616                 }
 617                 free(d.dptr);
 618                 free(f.dptr);
 619                 d = next;
 620         }
 621 }
 622
 623 static void command_unfollow(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 624 {
 625         TDB_DATA key;
 626         char *url;
 627
 628         if (!feed_db)
 629                 return;
 630
 631         if (!(url = token(&args, ' ')) || (sstrncmp(url, "http://") && sstrncmp(url, "https://"))) {
 632                 privmsg(b, target, "%s: Invalid url", nick);
 633                 return;
 634         }
 635         if (target[0] != '#') {
 636                 privmsg(b, target, "%s: Can only unfollow on channels", nick);
 637                 return;
 638         }
 639         key.dsize = asprintf((char**)&key.dptr, "%s,%s", target, url)+1;
 640         if (tdb_delete(feed_db, key) < 0) {
 641                 if (tdb_error(feed_db) == TDB_ERR_NOEXIST)
 642                         privmsg(b, target, "%s: Not following %s on this channel", nick, url);
 643                 else
 644                         privmsg(b, target, "%s: Could not delete: %s", nick, tdb_errorstr(feed_db));
 645         } else
 646                 privmsg(b, target, "%s: No longer following %s", nick, url);
 647         free(key.dptr);
 648 }
 649
 650 static void command_g(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 651 {
 652         int ret = 0;
 653         int64_t g = 0, g_total = 0;
 654         TDB_DATA chan, res;
 655
 656         if (!chan_db || target[0] != '#')
 657                 return;
 658
 659         chan.dptr = (char*)target;
 660         chan.dsize = strlen(chan.dptr)+1;
 661         res = tdb_fetch(chan_db, chan);
 662         if (res.dptr && res.dsize >= 16) {
 663                 g = ((int64_t*)res.dptr)[1];
 664                 ((int64_t*)res.dptr)[1] = 0;
 665                 if (res.dsize >= 24)
 666                         g_total = ((int64_t*)res.dptr)[2];
 667                 ret = tdb_store(chan_db, chan, res, 0);
 668         }
 669         free(res.dptr);
 670         if (ret < 0)
 671                 fprintf(stderr, "updating database: %s", tdb_errorstr(feed_db));
 672         else
 673                 privmsg(b, target, "%s: %"PRIi64" g's since last check, %"PRIi64" total", nick, g, g_total);
 674 }
 675
 676 static void command_feeds(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 677 {
 678         int len = strlen(target), found = 0;
 679         if (!feed_db)
 680                 return;
 681         if (target[0] != '#') {
 682                 privmsg(b, target, "%s: Only useful in channels..", nick);
 683                 return;
 684         }
 685         for (TDB_DATA d = tdb_firstkey(feed_db); d.dptr;) {
 686                 TDB_DATA f = tdb_fetch(feed_db, d);
 687                 TDB_DATA next = tdb_nextkey(feed_db, d);
 688
 689                 if (!strncmp(d.dptr, target, len) && d.dptr[len] == ',') {
 690                         privmsg(b, target, "%s: following %s", nick, d.dptr + len + 1);
 691                         found++;
 692                 }
 693                 free(d.dptr);
 694                 free(f.dptr);
 695                 d = next;
 696         }
 697         if (!found)
 698                 privmsg(b, target, "%s: not following any feed on %s", nick, target);
 699 }
 700
 701 static void command_feed_get(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 702 {
 703         if (!feed_db)
 704                 return;
 705         for (TDB_DATA d = tdb_firstkey(feed_db); d.dptr;) {
 706                 TDB_DATA next = tdb_nextkey(feed_db, d);
 707                 if (!args || strcasestr(d.dptr, args)) {
 708                         TDB_DATA f = tdb_fetch(feed_db, d);
 709                         privmsg(b, target, "%s: %s = %s", nick, d.dptr, f.dptr);
 710                         free(f.dptr);
 711                 }
 712                 if (strlen(d.dptr)+1 < d.dsize) {
 713                         privmsg(b, target, "%s: removed buggy entry", nick);
 714                         tdb_delete(feed_db, d);
 715                 }
 716                 free(d.dptr);
 717                 d = next;
 718         }
 719 }
 720
 721 static void command_feed_set(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 722 {
 723         if (!feed_db)
 724                 return;
 725         TDB_DATA key, val;
 726         key.dptr = token(&args, ' ');
 727         char *value = token(&args, ' ');
 728         if (!key.dptr || !value)
 729                 return;
 730         key.dsize = strlen(key.dptr) + 1;
 731         val.dsize = strlen(value) + 2;
 732         val.dptr = malloc(val.dsize);
 733         strcpy(val.dptr+1, value);
 734         val.dptr[0] = '\001';
 735         if (tdb_store(feed_db, key, val, 0) < 0)
 736                 privmsg(b, target, "%s: setting failed: %s", nick, tdb_errorstr(feed_db));
 737         else
 738                 privmsg(b, target, "%s: burp", nick);
 739         free(val.dptr);
 740 }
 741
 742 static void command_feed_rem(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 743 {
 744         if (!feed_db || !args)
 745                 return;
 746         TDB_DATA key = { .dptr = (unsigned char*)args, .dsize = strlen(args)+1 };
 747         if (tdb_delete(feed_db, key) < 0)
 748                 privmsg(b, target, "%s: removing failed: %s", nick, tdb_errorstr(feed_db));
 749         else
 750                 privmsg(b, target, "%s: burp", nick);
 751 }
 752
 753 static void command_feed_xxx(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 754 {
 755         if (!feed_db)
 756                 return;
 757
 758         tdb_wipe_all(feed_db);
 759         privmsg(b, target, "%s: all evidence erased", nick);
 760 }
 761
 762 static void command_seen_xxx(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 763 {
 764         if (!seen_db)
 765                 return;
 766
 767         tdb_wipe_all(seen_db);
 768         privmsg(b, target, "%s: all evidence erased", nick);
 769 }
 770
 771 static void command_feed_counter(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 772 {
 773         if (!chan_db)
 774                 return;
 775         tdb_wipe_all(chan_db);
 776         privmsg(b, target, "%s: All update counters reset", nick);
 777 }
 778
 779 static char *get_text_appended(xmlNode *cur)
 780 {
 781         for (; cur; cur = cur->next) {
 782                 if (cur->type != XML_TEXT_NODE)
 783                         continue;
 784                 return strdup(cur->content);
 785         }
 786         return NULL;
 787 }
 788
 789 static char *get_title(struct bio *b, xmlNode *cur_node)
 790 {
 791         for (; cur_node; cur_node = next_link(cur_node)) {
 792                 if (cur_node->type == XML_ELEMENT_NODE && !strcasecmp(cur_node->name, "title")) {
 793                         if (!cur_node->children)
 794                                 return NULL;
 795                         return get_text_appended(cur_node->children);
 796                 }
 797         }
 798         return NULL;
 799 }
 800
 801 static void internal_link(struct bio *b, const char *nick, const char *host, const char *target, char *args, unsigned verbose)
 802 {
 803         CURL *h;
 804         struct curl_slist *headers = NULL;
 805         char error[CURL_ERROR_SIZE];
 806         int success, sent = verbose;
 807         struct curl_download_context curl_ctx = {};
 808
 809         if (!args)
 810                 return;
 811         int64_t stop, start = get_time(b, target);
 812
 813         h = curl_easy_init();
 814         headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:9.0.1) Gecko/20100101 Firefox/9.0.1");
 815         headers = curl_slist_append(headers, "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
 816         headers = curl_slist_append(headers, "Accept-Language: en-us,en;q=0.7");
 817         headers = curl_slist_append(headers, "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7");
 818         headers = curl_slist_append(headers, "DNT: 1");
 819         headers = curl_slist_append(headers, "Connection: keep-alive");
 820         curl_easy_setopt(h, CURLOPT_HTTPHEADER, headers);
 821         curl_easy_setopt(h, CURLOPT_URL, args);
 822         curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, write_data);
 823         curl_easy_setopt(h, CURLOPT_WRITEDATA, &curl_ctx);
 824         curl_easy_setopt(h, CURLOPT_ERRORBUFFER, error);
 825         curl_easy_setopt(h, CURLOPT_FOLLOWLOCATION, 1);
 826         curl_easy_setopt(h, CURLOPT_MAXREDIRS, 3);
 827         curl_easy_setopt(h, CURLOPT_SSL_VERIFYPEER, 0);
 828         curl_easy_setopt(h, CURLOPT_TIMEOUT, 8);
 829         curl_easy_setopt(h, CURLOPT_CONNECTTIMEOUT, 8);
 830         //curl_easy_setopt(h, CURLOPT_VERBOSE, 1);
 831         success = curl_easy_perform(h);
 832         curl_easy_cleanup(h);
 833         curl_slist_free_all(headers);
 834         if (success == CURLE_OK) {
 835                 magic_t m = magic_open(MAGIC_MIME_TYPE);
 836                 magic_load(m, NULL);
 837                 const char *mime = magic_buffer(m, curl_ctx.data, curl_ctx.len);
 838                 if (strstr(mime, "text/html") || strstr(mime, "application/xml") || strstr(mime, "application/xhtml+xml")) {
 839                         htmlDocPtr ctx = htmlReadMemory(curl_ctx.data, curl_ctx.len, 0, args, HTML_PARSE_RECOVER|HTML_PARSE_NOERROR|HTML_PARSE_NOWARNING);
 840                         xmlNode *root_element = xmlDocGetRootElement(ctx);
 841                         char *title = get_title(b, root_element);
 842                         if (title) {
 843                                 char *nuke;
 844                                 squash(title);
 845                                 decode_html_entities_utf8(title, NULL);
 846                                 if ((nuke = strstr(title, " on SoundCloud - Create")))
 847                                         *nuke = 0;
 848                                 if (*title) {
 849                                         privmsg(b, target, "%s linked %s", nick, title);
 850                                         sent = 1;
 851                                 }
 852                                 free(title);
 853                         }
 854                         if (verbose && !title)
 855                                 privmsg(b, target, "%s linked %s page with invalid title", nick, mime);
 856                         xmlFreeDoc(ctx);
 857                 } else if (verbose) {
 858                         magic_setflags(m, MAGIC_COMPRESS);
 859                         const char *desc = magic_buffer(m, curl_ctx.data, curl_ctx.len);
 860                         privmsg(b, target, "%s linked type %s", nick, desc);
 861                 }
 862                 magic_close(m);
 863         }
 864         if (verbose && success != CURLE_OK)
 865                 privmsg(b, target, "Error %s (%u)", error, success);
 866         else if (!sent && (stop = get_time(b, target)) - start >= 15) {
 867                 static uint64_t last_timeout;
 868
 869                 if (stop - last_timeout < 45) {
 870                         privmsg(b, target, "Link (%s) by %s timed out, disabling links for 10 seconds", args, nick);
 871                         commands[strhash("get") % elements(commands)].disabled_until = stop + 10;
 872                 }
 873                 last_timeout = stop;
 874         }
 875         free(curl_ctx.data);
 876 }
 877
 878 static void command_get(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 879 {
 880         if (!args || (sstrncmp(args, "http://") && sstrncmp(args, "https://")))
 881                 return;
 882         internal_link(b, nick, host, target, token(&args, ' '), 1);
 883 }
 884
 885 static void command_fabric(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 886 {
 887         privmsg(b, target, "Dumb fabric!");
 888 }
 889
 890 static void command_fun(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 891 {
 892         privmsg(b, target, "Fun?");
 893 }
 894
 895 static void command_admire(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 896 {
 897         char *arg = token(&args, ' ');
 898         privmsg(b, target, "%s: I really like your mane!", arg ? arg : nick);
 899 }
 900
 901 static void command_hugs(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 902 {
 903         action(b, target, "gives a lunar hug to %s", args ? args : nick);
 904 }
 905
 906 static void command_hug(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 907 {
 908         if ((host && !strcmp(host, "life.on.the.moon.is.great.I.know.all.about.it")) ||
 909             (args && !sstrncasecmp(args, "lu")))
 910                 command_hugs(b, nick, host, target, args);
 911         else
 912                 action(b, target, "gives a robotic hug to %s", args ? args : nick);
 913 }
 914
 915 static void command_snuggles(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 916 {
 917         action(b, target, "gives a lunar snuggle to %s", args ? args : nick);
 918 }
 919
 920 static void command_snuggle(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 921 {
 922         if ((host && !strcmp(host, "life.on.the.moon.is.great.I.know.all.about.it")) ||
 923             (args && !sstrncasecmp(args, "lu")))
 924                 command_snuggles(b, nick, host, target, args);
 925         else
 926                 action(b, target, "gives a robotic snuggle to %s", args ? args : nick);
 927 }
 928
 929 static void command_cuddles(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 930 {
 931         action(b, target, "gives cuddles to %s in a lunaresque way", args ? args : nick);
 932 }
 933
 934 static void command_cuddle(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 935 {
 936         if ((host && !strcmp(host, "life.on.the.moon.is.great.I.know.all.about.it")) ||
 937             (args && !sstrncasecmp(args, "lu")))
 938                 command_cuddles(b, nick, host, target, args);
 939         else
 940                 action(b, target, "gives cuddles to %s in a robotic way", args ? args : nick);
 941 }
 942
 943
 944 static void command_cookie(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 945 {
 946         if (args && !strncasecmp(args, nick_self, strlen(nick_self)))
 947                 action(b, target, "eats the cookie offered by %s", nick);
 948         else
 949                 action(b, target, "hands a metallic looking cookie to %s", args ? args : nick);
 950 }
 951
 952 static void command_derpy(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 953 {
 954         static const char *insults[] = {
 955                 "accidentally shocks herself",
 956                 "tumbles down the stairs like a slinky",
 957                 "whirrrs and clicks in a screeching way",
 958                 "had problems executing this command",
 959                 "breaks down entirely",
 960                 "uses her magic to levitate herself off the ground, then hits it face first"
 961         };
 962         action(b, target, "%s", insults[getrand() % elements(insults)]);
 963 }
 964
 965 static void command_inspect(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 966 {
 967         struct command_hash *c;
 968         unsigned leave, crash;
 969         char *cmd;
 970         if (!args || !(cmd = token(&args, ' ')))
 971                 return;
 972
 973         if (strcmp(cmd, "#")) {
 974                 c = &commands[strhash(cmd) % elements(commands)];
 975                 if (!c->string || strcasecmp(c->string, cmd)) {
 976                         privmsg(b, target, "Command %s not valid", cmd);
 977                         return;
 978                 }
 979         } else
 980                 c = &command_channel;
 981
 982         leave = c->left + (c->cmd == command_inspect);
 983         crash = c->enter - leave;
 984         if (c->enter != leave)
 985                 privmsg(b, target, "%s: %u successes and %u crash%s, last crashing command: %s", c->string, leave, crash, crash == 1 ? "" : "es", c->failed_command);
 986         else
 987                 privmsg(b, target, "%s: %u time%s executed succesfully", c->string, leave, leave == 1 ? "" : "s");
 988 }
 989
 990 static void command_rebuild(struct bio *b, const char *nick, const char *host, const char *target, char *args)
 991 {
 992         int ret;
 993         char *make[] = { "/usr/bin/make", "-j4", NULL };
 994         char *git_reset[] = { "/usr/bin/git", "reset", "--hard", "master", NULL };
 995         ret = pipe_command(b, target, nick, 0, 1, git_reset);
 996         if (ret) {
 997                 action(b, target, "could not rebuild");
 998                 return;
 999         }
1000         ret = pipe_command(b, target, nick, 0, 1, make);
1001         if (!ret)
1002                 kill(getpid(), SIGUSR1);
1003         else if (ret > 0)
1004                 action(b, target, "displays an ominous %i", ret);
1005 }
1006
1007 static void command_swear(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1008 {
1009         static const char *insults[] = {
1010                 "featherbrain",
1011                 "ponyfeathers",
1012                 "What in the hey?",
1013                 "What are you, a dictionary?",
1014                 "TAR-DY!",
1015                 "[BUY SOME APPLES]",
1016                 "{ Your lack of bloodlust on the battlefield is proof positive that you are a soulless automaton! }",
1017                 "Your royal snootiness"
1018         };
1019         privmsg(b, target, "%s: %s", args ? args : nick, insults[getrand() % elements(insults)]);
1020 }
1021
1022 static const char *perty(int64_t *t)
1023 {
1024         if (*t >= 14 * 24 * 3600) {
1025                 *t /= 7 * 24 * 3600;
1026                 return "weeks";
1027         } else if (*t >= 48 * 3600) {
1028                 *t /= 24 * 3600;
1029                 return "days";
1030         } else if (*t >= 7200) {
1031                 *t /= 3600;
1032                 return "hours";
1033         } else if (*t >= 120) {
1034                 *t /= 60;
1035                 return "minutes";
1036         }
1037         return *t == 1 ? "second" : "seconds";
1038 }
1039
1040 static void command_timeout(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1041 {
1042         struct command_hash *c;
1043         int64_t t = get_time(b, target);
1044         int64_t howlong;
1045         if (t < 0)
1046                 return;
1047         char *arg = token(&args, ' ');
1048         if (!arg || !args || !(howlong = atoi(args))) {
1049                 action(b, target, "pretends to time out");;
1050                 return;
1051         }
1052         c = &commands[strhash(arg) % elements(commands)];
1053         if (c->string && !strcasecmp(c->string, arg)) {
1054                 c->disabled_until = t + howlong;
1055                 const char *str = perty(&howlong);
1056                 action(b, target, "disables %s for %"PRIi64" %s", arg, howlong, str);
1057         } else
1058                 action(b, target, "clicks sadly at %s for not being able to find that command", nick);
1059 }
1060
1061 static void command_mfw(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1062 {
1063         char error[CURL_ERROR_SIZE], *new_url;
1064         CURL *h = curl_easy_init();
1065         struct curl_slist *headers = NULL;
1066         struct curl_download_context curl_ctx = {};
1067         headers = curl_slist_append(headers, "User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:9.0.1) Gecko/20100101 Firefox/9.0.1");
1068         headers = curl_slist_append(headers, "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
1069         headers = curl_slist_append(headers, "Accept-Language: en-us,en;q=0.7");
1070         headers = curl_slist_append(headers, "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7");
1071         headers = curl_slist_append(headers, "DNT: 1");
1072         headers = curl_slist_append(headers, "Connection: keep-alive");
1073         curl_easy_setopt(h, CURLOPT_HTTPHEADER, headers);
1074         curl_easy_setopt(h, CURLOPT_URL, "http://mylittlefacewhen.com/random/");
1075         curl_easy_setopt(h, CURLOPT_WRITEFUNCTION, write_data);
1076         curl_easy_setopt(h, CURLOPT_WRITEDATA, &curl_ctx);
1077         curl_easy_setopt(h, CURLOPT_ERRORBUFFER, error);
1078         curl_easy_setopt(h, CURLOPT_TIMEOUT, 8);
1079         curl_easy_setopt(h, CURLOPT_CONNECTTIMEOUT, 8);
1080         //curl_easy_setopt(h, CURLOPT_VERBOSE, 1);
1081         CURLcode ret = curl_easy_perform(h);
1082         if (ret == CURLE_OK && curl_easy_getinfo(h, CURLINFO_REDIRECT_URL, &new_url) == CURLE_OK)
1083                 privmsg(b, target, "%s: %s", nick, new_url);
1084         curl_slist_free_all(headers);
1085         curl_easy_cleanup(h);
1086         if (ret != CURLE_OK)
1087                 privmsg(b, target, "%s: You have no face", nick);
1088 }
1089
1090 static TDB_DATA get_mail_key(const char *nick)
1091 {
1092         TDB_DATA d;
1093         int i;
1094         d.dsize = strlen(nick)+1;
1095         d.dptr = malloc(d.dsize);
1096         for (i = 0; i < d.dsize - 1; ++i)
1097                 d.dptr[i] = tolower(nick[i]);
1098         d.dptr[i] = 0;
1099         return d;
1100 }
1101
1102 static void command_mail(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1103 {
1104         char *victim, *x;
1105         size_t len;
1106         int override = 0;
1107         int64_t last_seen = 0;
1108
1109         if (!mail_db || !seen_db)
1110                 return;
1111         TDB_DATA key, val;
1112         victim = token(&args, ' ');
1113         if (victim && !strcasecmp(victim, "-seen")) {
1114                 victim = token(&args, ' ');
1115                 override = 1;
1116         }
1117         x = victim;
1118         victim = token(&x, ',');
1119         if (!victim || x || !args || victim[0] == '#' || strchr(victim, '@') || strchr(victim, '.')) {
1120                 privmsg(b, target, "%s: Usage: !mail <nick> <message>", nick);
1121                 return;
1122         }
1123         if (!strcasecmp(victim, nick_self)) {
1124                 action(b, target, "whirrs and clicks excitedly at the mail she received from %s", nick);
1125                 return;
1126         }
1127         if (!strcasecmp(victim, nick)) {
1128                 action(b, target, "echos the words from %s back to them: %s", nick, args);
1129                 return;
1130         }
1131         int64_t now = get_time(b, target);
1132         if (now < 0)
1133                 return;
1134
1135         key = get_mail_key(victim);
1136         val = tdb_fetch(seen_db, key);
1137         if (val.dptr && (x = strchr(val.dptr, ','))) {
1138                 *(x++) = 0;
1139                 last_seen = atoll(val.dptr);
1140         }
1141         if (x && !admin(host) && (now - last_seen) < 300 && (!sstrncasecmp(x, "in ") || !sstrncasecmp(x, "joining "))) {
1142                 action(b, target, "would rather not store mail for someone active so recently");
1143                         goto out;
1144         } else if (last_seen && now - last_seen > 14 * 24 * 3600 && !override) {
1145                 int64_t delta = now - last_seen;
1146                 const char *str = perty(&delta);
1147                 privmsg(b, target, "%s: \"%s\" was last seen %"PRIi64" %s ago, use !mail -seen %s <message> to override this check.", nick, victim, delta, str, victim);
1148                 return;
1149         } else if (!x && !override) {
1150                 privmsg(b, target, "%s: I've never seen \"%s\", use !mail -seen %s <message> to override this check.", nick, victim, victim);
1151                 return;
1152         }
1153
1154         val = tdb_fetch(mail_db, key);
1155         if (!val.dptr)
1156                 val.dsize = 0;
1157         else {
1158                 unsigned char *cur;
1159                 int letters = 0;
1160                 for (cur = val.dptr; cur < val.dptr + val.dsize; cur += strlen(cur)+1)
1161                         letters++;
1162                 if (letters >= 6) {
1163                         action(b, target, "looks sadly at %s as she cannot hold any more mail to %s", nick, victim);
1164                         goto out;
1165                 }
1166         }
1167         len = snprintf(NULL, 0, "%"PRIi64 ",%s: %s", now, nick, args) + 1;
1168         val.dptr = realloc(val.dptr, val.dsize + len);
1169         snprintf(val.dptr + val.dsize, len, "%"PRIi64 ",%s: %s", now, nick, args);
1170         val.dsize += len;
1171         if (tdb_store(mail_db, key, val, 0) < 0)
1172                 privmsg(b, target, "%s: updating mail returns %s", nick, tdb_errorstr(mail_db));
1173         else
1174                 action(b, target, "whirrs and clicks at %s as she stores the mail for %s", nick, victim);
1175 out:
1176         free(val.dptr);
1177         free(key.dptr);
1178 }
1179
1180 static void single_message(struct bio *b, const char *target, char *cur, int64_t now)
1181 {
1182         char *endtime, *sep = strchr(cur, ':');
1183         int64_t delta = -1;
1184         if (sep && (endtime = strchr(cur, ',')) && endtime < sep) {
1185                 int64_t t = atoll(cur);
1186                 if (t > 0)
1187                         delta = now - t;
1188                 cur = endtime + 1;
1189         }
1190         if (delta >= 0) {
1191                 const char *str = perty(&delta);
1192                 privmsg(b, target, "%"PRIi64" %s ago from %s", delta, str, cur);
1193         } else
1194                 privmsg(b, target, "From %s", cur);
1195 }
1196
1197 static void command_deliver(struct bio *b, const char *nick, const char *target)
1198 {
1199         TDB_DATA key, val;
1200         unsigned char *cur;
1201         static unsigned mail_enter, mail_leave;
1202         if (mail_enter++ != mail_leave)
1203                 return;
1204
1205         if (!mail_db)
1206                 return;
1207         key = get_mail_key(nick);
1208         val = tdb_fetch(mail_db, key);
1209         if (!val.dptr)
1210                 goto end;
1211         int64_t now = get_time(b, NULL);
1212         if (strcasecmp(key.dptr, nick_self)) {
1213                 privmsg(b, target, "%s: You've got mail!", nick);
1214                 for (cur = val.dptr; cur < val.dptr + val.dsize; cur += strlen(cur)+1)
1215                         single_message(b, target, cur, now);
1216         }
1217         free(val.dptr);
1218         tdb_delete(mail_db, key);
1219 end:
1220         free(key.dptr);
1221         mail_leave++;
1222 }
1223
1224 static void update_seen(struct bio *b, char *doingwhat, const char *nick)
1225 {
1226         TDB_DATA key;
1227         key = get_mail_key(nick);
1228         TDB_DATA val = { .dptr = doingwhat, .dsize = strlen(doingwhat)+1 };
1229         if (seen_db)
1230                 tdb_store(seen_db, key, val, 0);
1231         free(key.dptr);
1232 }
1233
1234 static void command_seen(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1235 {
1236         char *arg = token(&args, ' '), *x;
1237         int64_t now = get_time(b, target);
1238         TDB_DATA key, val;
1239         if (now < 0)
1240                 return;
1241         if (!seen_db || !arg) {
1242                 privmsg(b, target, "%s: { Error... }", nick);
1243                 return;
1244         }
1245         if (!strcasecmp(arg, nick_self)) {
1246                 action(b, target, "whirrs and clicks at %s", nick);
1247                 return;
1248         }
1249         if (!strcasecmp(arg, nick)) {
1250                 action(b, target, "circles around %s dancing", nick);
1251                 return;
1252         }
1253         key = get_mail_key(arg);
1254         val = tdb_fetch(seen_db, key);
1255         if (val.dptr && (x = strchr(val.dptr, ','))) {
1256                 int64_t delta;
1257                 const char *str;
1258                 *(x++) = 0;
1259                 delta = now - atoll(val.dptr);
1260                 str = perty(&delta);
1261                 if (delta < 0)
1262                         privmsg(b, target, "%s was last seen in the future %s", arg, x);
1263                 else
1264                         privmsg(b, target, "%s was last seen %"PRIi64" %s ago %s", arg, delta, str, x);
1265         } else
1266                 action(b, target, "cannot find any evidence that %s exists", arg);
1267         free(val.dptr);
1268 }
1269
1270 static int suppress_message(const char *cur, int64_t now)
1271 {
1272         const char *endtime, *sep = strchr(cur, ':');
1273         int64_t delta = -1;
1274         if (sep && (endtime = strchr(cur, ',')) && endtime < sep) {
1275                 int64_t t = atoll(cur);
1276                 if (t > 0)
1277                         delta = now - t;
1278         }
1279
1280         return delta == -1 || delta >= 28 * 24 * 3600;
1281 }
1282
1283 static void command_mailbag(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1284 {
1285         char buffer[256];
1286         unsigned rem = sizeof(buffer)-1, first = 2, hidden = 0;
1287         int64_t now = get_time(b, NULL);
1288
1289         if (!mail_db)
1290                 return;
1291         buffer[rem] = 0;
1292
1293         for (TDB_DATA f = tdb_firstkey(mail_db); f.dptr;) {
1294                 TDB_DATA next;
1295
1296                 if (f.dsize + 4 > rem) {
1297                         privmsg(b, target, "%s: Holding mail for: %s", nick, &buffer[rem]);
1298                         first = 2;
1299                         rem = sizeof(buffer)-1;
1300                         assert(f.dsize + 4 < rem);
1301                 }
1302                 if (f.dptr) {
1303                         TDB_DATA val = tdb_fetch(mail_db, f);
1304                         if (val.dptr) {
1305                                 if (now >= 0 && suppress_message(val.dptr, now)) {
1306                                         hidden++;
1307                                         free(val.dptr);
1308                                         goto skip;
1309                                 }
1310                                 free(val.dptr);
1311                         }
1312
1313                         if (first == 2) {
1314                                 first = 1;
1315                         } else if (first) {
1316                                 rem -= 5;
1317                                 memcpy(&buffer[rem], " and ", 5);
1318                                 first = 0;
1319                         } else {
1320                                 rem -= 2;
1321                                 memcpy(&buffer[rem], ", ", 2);
1322                         }
1323                         rem -= f.dsize - 1;
1324                         memcpy(&buffer[rem], f.dptr, f.dsize - 1);
1325                 }
1326 skip:
1327                 next = tdb_nextkey(mail_db, f);
1328                 free(f.dptr);
1329                 f = next;
1330         }
1331         if (first < 2 && !hidden)
1332                 privmsg(b, target, "%s: Holding mail for: %s", nick, &buffer[rem]);
1333         else
1334                 privmsg(b, target, "%s: Holding mail for: %s (and %u others)", nick, &buffer[rem], hidden);
1335 }
1336
1337 static void command_mailread(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1338 {
1339         TDB_DATA key, val;
1340         char *victim;
1341         if (!mail_db || !(victim = token(&args, ' ')))
1342                 return;
1343         key = get_mail_key(victim);
1344         val = tdb_fetch(mail_db, key);
1345         if (!val.dptr)
1346                 action(b, target, "ponyshrugs as no mail for %s was found", victim);
1347         else {
1348                 unsigned char *cur;
1349                 int64_t now = get_time(b, NULL);
1350                 action(b, target, "peeks through %s's mail", victim);
1351                 for (cur = val.dptr; cur < val.dptr + val.dsize; cur += strlen(cur)+1)
1352                         single_message(b, target, cur, now);
1353         }
1354         free(val.dptr);
1355         free(key.dptr);
1356 }
1357
1358 static void command_no_deliver(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1359 {
1360         TDB_DATA key, val;
1361         char *cur;
1362         if (!mail_db || !(cur = token(&args, ' ')))
1363                 return;
1364         key = get_mail_key(cur);
1365         val = tdb_fetch(mail_db, key);
1366         if (!val.dptr)
1367                 action(b, target, "ponyshrugs as no mail for %s was found", cur);
1368         else {
1369                 action(b, target, "deletes all evidence of %s's mail", cur);
1370                 tdb_delete(mail_db, key);
1371         }
1372         free(val.dptr);
1373         free(key.dptr);
1374 }
1375
1376 static void perform_roll(struct bio *b, const char *nick, const char *target, long sides, long dice, long bonus)
1377 {
1378         long rem = dice, total = bonus;
1379         while (rem--)
1380                 total += 1 + (getrand() % sides);
1381         if (bonus)
1382                 action(b, target, "rolls %li %li-sided %s for a total of %li (%+li)", dice, sides, dice == 1 ? "die" : "dice", total, bonus);
1383         else
1384                 action(b, target, "rolls %li %li-sided %s for a total of %li", dice, sides, dice == 1 ? "die" : "dice", total);
1385 }
1386
1387 static void command_roll(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1388 {
1389         char *cur;
1390         long dice = 1, sides = 20;
1391         if ((cur = token(&args, ' '))) {
1392                 char *first = cur;
1393                 dice = strtol(first, &cur, 10);
1394                 if (first == cur)
1395                         dice = 1;
1396                 if (*cur && *cur != 'd' && *cur != 'D')
1397                         goto syntax;
1398
1399                 if (*cur) {
1400                         char *last = cur+1;
1401                         sides = strtol(last, &cur, 10);
1402                         if (last == cur)
1403                                 goto syntax;
1404                 }
1405         }
1406         if (dice <= 0 || dice > 25 || sides < 2 || sides > 20)
1407                 goto syntax;
1408         perform_roll(b, nick, target, sides, dice, 0);
1409         return;
1410
1411 syntax:
1412         action(b, target, "bleeps at %s in a confused manner", nick);
1413 }
1414
1415 static void add_g(struct bio *b, const char *target, int g)
1416 {
1417         int ret = 0;
1418         int64_t total_g = 0;
1419         TDB_DATA chan, res;
1420
1421         if (!chan_db || target[0] != '#')
1422                 return;
1423
1424         chan.dptr = (char*)target;
1425         chan.dsize = strlen(chan.dptr)+1;
1426         res = tdb_fetch(chan_db, chan);
1427         if (res.dptr && res.dsize >= 16) {
1428                 ((int64_t*)res.dptr)[1] += g;
1429                 if (res.dsize >= 24)
1430                         total_g = ((int64_t*)res.dptr)[2] += g;
1431                 ret = tdb_store(chan_db, chan, res, 0);
1432         }
1433         free(res.dptr);
1434         if (ret < 0)
1435                 fprintf(stderr, "updating database: %s", tdb_errorstr(feed_db));
1436         else if (g < total_g) {
1437                 int64_t last_g = total_g - g;
1438                 last_g -= last_g % 1000;
1439                 if (last_g + 1000 <= total_g)
1440                         privmsg(b, target, "g has been said %"PRIi64" times!", total_g);
1441         }
1442 }
1443
1444 static int parse_g(const char *cur, int *g)
1445 {
1446         int this_g = 0;
1447         for (const unsigned char *ptr = cur; *ptr; ptr++) {
1448                 if (*ptr >= 0x80)
1449                         return 0;
1450                 if (*ptr == 'g' || *ptr == 'G')
1451                         this_g++;
1452                 else if ((*ptr >= 'a' && *ptr <= 'z') || (*ptr >= 'A' && *ptr <= 'Z'))
1453                         return 0;
1454                 else if (*ptr != '1' && *ptr >= '0' && *ptr <= '9')
1455                         return 0;
1456         }
1457         *g += this_g;
1458         return this_g;
1459 }
1460
1461 static void channel_msg(struct bio *b, const char *nick, const char *host,
1462                         const char *chan, char *msg, int64_t t)
1463 {
1464         char *cur = NULL, *next;
1465         int is_action = 0;
1466         int g = 0;
1467
1468         int that = 0, what = 0, she = 0, nsfw = 0;
1469
1470         if (!msg || !strcmp(nick, "`Daring_Do`") ||
1471             !sstrncmp(nick, "derpy") || !sstrncmp(nick, "`derpy") ||
1472             !sstrncmp(nick, "`Luna") || !sstrncmp(nick, "`Celestia") ||
1473             !sstrncmp(nick, "GitHub") || !sstrncmp(nick, "CIA-") ||
1474             !sstrncmp(nick, "Termi") || !strcmp(nick, "r0m") || !sstrncasecmp(nick, "Owloysius"))
1475                 return;
1476
1477         if (!sstrncasecmp(msg, "\001ACTION ")) {
1478                 msg += sizeof("\001ACTION ")-1;
1479                 is_action = 1;
1480                 asprintf(&cur, "%"PRIi64 ",in %s: * %s %s", t, chan, nick, msg);
1481         } else
1482                 asprintf(&cur, "%"PRIi64 ",in %s: <%s> %s", t, chan, nick, msg);
1483         if (t > 0 && strcasecmp(chan, "#themoon") && strcasecmp(chan, "#fluttertreehouse"))
1484                 update_seen(b, cur, nick);
1485         free(cur);
1486         (void)is_action;
1487
1488         if (!sstrncasecmp(msg, "fun!") || !strcasecmp(msg, "fun")) {
1489                 static int64_t last_fun = -1;
1490
1491                 if (!strcasecmp(chan, "#bronymusic") && t - last_fun > 5) {
1492                         if (t < 0 || t > commands[strhash("fun") % elements(commands)].disabled_until) {
1493                                 if (sstrncmp(nick, "EqBot"))
1494                                         privmsg(b, chan, "Fun!");
1495                                 privmsg(b, chan, "Fun!");
1496                         }
1497                 }
1498                 last_fun = t;
1499                 return;
1500         }
1501
1502         next = msg;
1503         while ((cur = token(&next, ' '))) {
1504                 if (!strcasecmp(cur, ">mfw") || !strcasecmp(cur, "mfw")) {
1505                         if (!strcasecmp(chan, "#brony") || !ponify)
1506                                 continue;
1507                         if (t < 0 || t > commands[strhash("mfw") % elements(commands)].disabled_until)
1508                                 command_mfw(b, nick, host, chan, NULL);
1509                         return;
1510                 } else if (!sstrncasecmp(cur, "http://") || !sstrncasecmp(cur, "https://")) {
1511                         static char last_url[512];
1512                         char *part;
1513                         if (!strcmp(cur, last_url))
1514                                 return;
1515                         strncpy(last_url, cur, sizeof(last_url)-1);
1516
1517                         if (!sstrncmp(nick, "EqBot") || !sstrncasecmp(chan, "#mlpsurvival"))
1518                                 return;
1519
1520                         if (t >= 0 && t < commands[strhash("get") % elements(commands)].disabled_until)
1521                                 return;
1522
1523                         else if (strcasestr(cur, "youtube.com/user") && (part = strstr(cur, "#p/"))) {
1524                                 char *foo;
1525                                 part = strrchr(part, '/') + 1;
1526                                 asprintf(&foo, "http://youtube.com/watch?v=%s", part);
1527                                 if (foo)
1528                                         internal_link(b, nick, host, chan, foo, 0);
1529                                 free(foo);
1530                                 return;
1531                         } else if (strcasestr(cur, "twitter.com/") || strcasestr(cur, "mlfw.info") || strcasestr(cur, "mylittlefacewhen.com") || !strcasecmp(chan, "#geek"))
1532                                 return;
1533                         if (!strcasecmp(chan, "#bronymusic") &&
1534                                 (nsfw || (next && strcasestr(next, "nsfw"))))
1535                                 continue;
1536                         internal_link(b, nick, host, chan, cur, 0);
1537                         return;
1538                 }
1539                 else if (!sstrncasecmp(cur, "that") || !sstrncasecmp(cur, "dat"))
1540                         that = 1;
1541                 else if (that && (!sstrncasecmp(cur, "what") || !sstrncasecmp(cur, "wat")))
1542                         what = 1;
1543                 else if (what && !sstrncasecmp(cur, "she"))
1544                         she = 1;
1545                 else if (she && !sstrncasecmp(cur, "said")) {
1546                         if (t <= 0 || t >= commands[strhash("shesaid") % elements(commands)].disabled_until)
1547                                 privmsg(b, chan, "%s: \"%s\"", nick, women_quotes[getrand() % elements(women_quotes)]);
1548                         return;
1549                 } else if (parse_g(cur, &g))
1550                         continue;
1551                 else if (strcasestr(cur, "nsfw"))
1552                         nsfw = 1;
1553         }
1554         if (g)
1555                 add_g(b, chan, g);
1556 }
1557
1558 static void command_commands(struct bio *b, const char *nick, const char *host, const char *target, char *args);
1559
1560 static struct command_hash unhashed[] = {
1561         { "1", command_coinflip },
1562         { "fabric", command_fabric },
1563         { "fun", command_fun },
1564         { "get", command_get },
1565         { "hug", command_hug },
1566         { "hugs", command_hugs, -1 },
1567         { "admire", command_admire },
1568         { "snug", command_snuggle, -1 },
1569         { "snugs", command_snuggles, -1 },
1570         { "snuggle", command_snuggle },
1571         { "snuggles", command_snuggles, -1 },
1572         { "cuddle", command_cuddle },
1573         { "cuddles", command_cuddles, -1 },
1574         { "cookie", command_cookie },
1575         { "mfw", command_mfw },
1576         { "swear", command_swear },
1577         { "mail", command_mail },
1578         { "m", command_mail, -1 },
1579         { "seen", command_seen },
1580         { "derpy", command_derpy },
1581         { "g", command_g, -1 },
1582         { "shesaid", command_shesaid },
1583         { "roll", command_roll },
1584
1585         { "rebuild", command_rebuild, 1 },
1586         { "abort", command_abort, 1 },
1587         { "crash", command_crash, 1 },
1588         { "inspect", command_inspect, 1 },
1589         { "timeout", command_timeout, 1 },
1590
1591         { "follow", command_follow },
1592         { "unfollow", command_unfollow },
1593         { "feeds", command_feeds },
1594
1595 // DEBUG
1596         { "feed_get", command_feed_get, 1 },
1597         { "feed_set", command_feed_set, 1 },
1598         { "feed_rem", command_feed_rem, 1 },
1599         { "feed_xxx", command_feed_xxx, 1 },
1600         { "feed_counter", command_feed_counter, 1 },
1601         { "seen_xxx", command_seen_xxx, 1 },
1602         { "mailbag", command_mailbag },
1603         { "mailread", command_mailread, 1 },
1604         { "\"deliver\"", command_no_deliver, 1 },
1605         { "commands", command_commands, -1 }
1606 };
1607
1608 static void command_commands(struct bio *b, const char *nick, const char *host, const char *target, char *args)
1609 {
1610         char buffer[256];
1611         unsigned rem = sizeof(buffer)-1, first = 2, i;
1612         buffer[rem] = 0;
1613
1614         for (i = 0; i < sizeof(unhashed)/sizeof(*unhashed); ++i) {
1615                 const char *str;
1616                 unsigned long len;
1617                 if (unhashed[i].admin)
1618                         continue;
1619
1620                 str = unhashed[i].string;
1621                 len = strlen(str);
1622
1623                 if (len + 5 > rem) {
1624                         privmsg(b, target, "%s: Valid commands: %s", nick, &buffer[rem]);
1625                         first = 2;
1626                         rem = sizeof(buffer)-1;
1627                         assert(len < rem);
1628                 }
1629                 if (str) {
1630                         if (first == 2) {
1631                                 first = 1;
1632                         } else if (first) {
1633                                 rem -= 5;
1634                                 memcpy(&buffer[rem], " and ", 5);
1635                                 first = 0;
1636                         } else {
1637                                 rem -= 2;
1638                                 memcpy(&buffer[rem], ", ", 2);
1639                         }
1640                         rem -= len;
1641                         memcpy(&buffer[rem], str, len);
1642                 }
1643         }
1644         if (first < 2)
1645                 privmsg(b, target, "%s: Valid commands: %s", nick, &buffer[rem]);
1646 }
1647
1648 static void init_hash(struct bio *b, const char *target)
1649 {
1650         int i;
1651         for (i = 0; i < elements(unhashed); ++i) {
1652                 unsigned h = strhash(unhashed[i].string) % elements(commands);
1653                 if (commands[h].string)
1654                         privmsg(b, target, "%s is a duplicate command with %s", commands[h].string, unhashed[i].string);
1655                 else
1656                         commands[h] = unhashed[i];
1657         }
1658 #ifdef local_commands
1659         for (i = 0; i < elements(local_commands); ++i) {
1660                 unsigned h = strhash(local_commands[i].string) % elements(commands);
1661                 if (commands[h].string)
1662                         privmsg(b, target, "%s is a duplicate command with %s", commands[h].string, local_commands[i].string);
1663                 else
1664                         commands[h] = local_commands[i];
1665         }
1666 #endif
1667 }
1668
1669 void init_hook(struct bio *b, const char *target, const char *nick, unsigned is_ponified)
1670 {
1671         char *cwd, *path = NULL;
1672         nick_self = nick;
1673         static const char *messages[] = {
1674                 "feels circuits being activated that weren't before",
1675                 "suddenly gets a better feel of her surroundings",
1676                 "looks the same, yet there's definitely something different",
1677                 "emits a beep as her lights begin to pulse slowly",
1678                 "whirrrs and bleeps like never before",
1679                 "bleeps a few times happily",
1680                 "excitedly peeks at her surroundings"
1681         };
1682         init_hash(b, target);
1683         ponify = is_ponified;
1684
1685         cwd = getcwd(NULL, 0);
1686         asprintf(&path, "%s/db/feed.tdb", cwd);
1687         feed_db = tdb_open(path, 0, 0, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
1688         free(path);
1689         if (!feed_db)
1690                 privmsg(b, target, "Opening feed db failed: %m");
1691
1692         asprintf(&path, "%s/db/chan.tdb", cwd);
1693         chan_db = tdb_open(path, 0, 0, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
1694         free(path);
1695         if (!chan_db)
1696                 privmsg(b, target, "Opening chan db failed: %m");
1697
1698         asprintf(&path, "%s/db/mail.tdb", cwd);
1699         mail_db = tdb_open(path, 0, 0, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
1700         free(path);
1701         if (!mail_db)
1702                 privmsg(b, target, "Opening mail db failed: %m");
1703
1704         asprintf(&path, "%s/db/seen.tdb", cwd);
1705         seen_db = tdb_open(path, 0, 0, O_RDWR|O_CREAT|O_CLOEXEC|O_NOCTTY, 0644);
1706         free(path);
1707         if (!seen_db)
1708                 privmsg(b, target, "Opening seen db failed: %m");
1709
1710         free(cwd);
1711         action(b, target, "%s", messages[getrand() % elements(messages)]);
1712 }
1713
1714 static void  __attribute__((destructor)) shutdown_hook(void)
1715 {
1716         if (seen_db)
1717                 tdb_close(seen_db);
1718         if (mail_db)
1719                 tdb_close(mail_db);
1720         if (feed_db)
1721                 tdb_close(feed_db);
1722         if (chan_db)
1723                 tdb_close(chan_db);
1724 }
1725
1726 static char *nom_special(char *line)
1727 {
1728         while (*line) {
1729                 if (*line == 0x03) {
1730                         line++;
1731                         if (*line >= '0' && *line <= '9')
1732                                 line++;
1733                         else continue;
1734                         if (*line >= '0' && *line <= '9')
1735                                 line++;
1736                         if (line[0] == ',' && line[1] >= '0' && line[1] <= '9')
1737                                 line += 2;
1738                         else continue;
1739                         if (*line >= '0' && *line <= '9')
1740                                 line++;
1741                 } else if (*line <= 0x1f) /* some control code */
1742                         line++;
1743                 else
1744                         return line;
1745         }
1746         return line;
1747 }
1748
1749 static char *cleanup_special(char *line)
1750 {
1751         char *cur, *start = nom_special(line);
1752         if (!*start)
1753                 return NULL;
1754         for (line = cur = start; *line; line = nom_special(line))
1755                 *(cur++) = *(line++);
1756
1757         for (cur--; cur >= start; --cur)
1758                 if (*cur != ' ' && *cur != '\001')
1759                         break;
1760
1761         if (cur < start)
1762                 return NULL;
1763         cur[1] = 0;
1764         return start;
1765 }
1766
1767 static void rss_check(struct bio *b, const char *channel, int64_t t)
1768 {
1769         static unsigned rss_enter, rss_leave;
1770         if (t >= 0 && rss_enter == rss_leave) {
1771                 rss_enter++;
1772                 channel_feed_check(b, channel, t);
1773                 rss_leave++;
1774         }
1775 }
1776
1777 static const char *privileged_command[] = {
1778         "{ Rarity, I love you so much! }",
1779         "{ Rarity, have I ever told you that I love you? }",
1780         "{ Yes, I love my sister, Rarity. }",
1781         "{ Raaaaaaaaaaaaaarity. }",
1782         "{ You do not fool me, Rari...bot! }"
1783 };
1784
1785 static int cmd_check(struct bio *b, struct command_hash *c, int is_admin, int64_t t, const char *prefix, const char *target)
1786 {
1787         if (c->left != c->enter)
1788                 privmsg(b, target, "Command %s is disabled because of a crash", c->string);
1789         else if (t > 0 && t < c->disabled_until && !is_admin) {
1790                 int64_t delta = c->disabled_until - t;
1791                 const char *str = perty(&delta);
1792                 b->writeline(b, "NOTICE %s :Command %s is on timeout for the next %"PRIi64 " %s", prefix, c->string, delta, str);
1793         } else if (c->admin > 0 && !is_admin)
1794                 privmsg(b, target, "%s: %s", prefix, privileged_command[getrand() % elements(privileged_command)]);
1795         else
1796                 return 1;
1797         return 0;
1798 }
1799
1800 void privmsg_hook(struct bio *b, const char *prefix, const char *ident, const char *host,
1801                   const char *const *args, unsigned nargs)
1802 {
1803         char *cmd_args, *cmd;
1804         const char *target = args[0][0] == '#' ? args[0] : prefix;
1805         unsigned chan, nick_len;
1806         struct command_hash *c;
1807         int64_t t = get_time(b, target);
1808         int is_admin = admin(host);
1809
1810         chan = args[0][0] == '#';
1811         if (chan) {
1812                 rss_check(b, args[0], t);
1813                 command_deliver(b, prefix, args[0]);
1814         }
1815         cmd_args = cleanup_special((char*)args[1]);
1816         if (!cmd_args)
1817                 return;
1818
1819         if (ident && (!strcasecmp(ident, "Revolver") || !strcasecmp(ident, "Rev")))
1820                 return;
1821
1822         if (chan && cmd_args[0] == '!') {
1823                 cmd_args++;
1824         } else if (chan && (nick_len = strlen(nick_self)) &&
1825                 !strncasecmp(cmd_args, nick_self, nick_len) &&
1826                 (cmd_args[nick_len] == ':' || cmd_args[nick_len] == ',') && cmd_args[nick_len+1] == ' ') {
1827                 cmd_args += nick_len + 2;
1828                 if (!cmd_args[0])
1829                         return;
1830                 chan = 2;
1831         } else if (chan) {
1832                 if (command_channel.enter == command_channel.left) {
1833                         command_channel.enter++;
1834                         snprintf(command_channel.failed_command,
1835                                  sizeof(command_channel) - offsetof(struct command_hash, failed_command) - 1,
1836                                  "%s:%s (%s@%s) \"#\" %s", target, prefix, ident, host, cmd_args);
1837                         channel_msg(b, prefix, host, args[0], cmd_args, t);
1838                         command_channel.left++;
1839                 }
1840                 return;
1841         }
1842         cmd = token(&cmd_args, ' ');
1843         if (!chan && cmd_args && cmd_args[0] == '#') {
1844                 if (!is_admin) {
1845                         privmsg(b, target, "%s: %s", prefix, privileged_command[getrand() % elements(privileged_command)]);
1846                         return;
1847                 }
1848                 target = token(&cmd_args, ' ');
1849         }
1850
1851         c = &commands[strhash(cmd) % elements(commands)];
1852         if (c->string && !strcasecmp(c->string, cmd)) {
1853                 if (!sstrncasecmp(prefix, "EqBot")) {
1854                         action(b, target, "adoringly pulses some light back to %s", prefix);
1855                         return;
1856                 }
1857                 if (cmd_check(b, c, is_admin, t, prefix, target)) {
1858                         c->enter++;
1859                         snprintf(c->failed_command, sizeof(*c) - offsetof(struct command_hash, failed_command) - 1,
1860                                  "%s:%s (%s@%s) \"%s\" %s", target, prefix, ident, host, cmd, cmd_args);
1861                         c->cmd(b, prefix, host, target, cmd_args);
1862                         c->left++;
1863                 }
1864                 return;
1865         } else if (cmd[0] == 'd' && cmd[1] >= '0' && cmd[1] <= '9') {
1866                 char *end;
1867                 long base;
1868                 base = strtol(cmd+1, &end, 10);
1869                 if (base > 1 && base <= 20 && !*end) {
1870                         long dice = 1, bonus = 0;
1871                         char *strdice;
1872                         c = &commands[strhash("roll") % elements(commands)];
1873                         if (!cmd_check(b, c, is_admin, t, prefix, target))
1874                                 return;
1875                         c->enter++;
1876                         snprintf(c->failed_command, sizeof(*c) - offsetof(struct command_hash, failed_command) - 1,
1877                                 "%s:%s (%s@%s) \"%s\" %s", target, prefix, ident, host, cmd, cmd_args);
1878
1879                         strdice = token(&cmd_args, ' ');
1880                         if (strdice) {
1881                                 dice = strtol(strdice, &end, 10);
1882                                 if (*end || !dice || dice > 25)
1883                                         goto syntax;
1884                                 strdice = token(&cmd_args, ' ');
1885                                 if (strdice) {
1886                                         bonus = strtol(strdice, &end, 10);
1887                                         if (*end || bonus > 1000 || bonus < -1000)
1888                                                 goto syntax;
1889                                 }
1890                         }
1891                         perform_roll(b, prefix, target, base, dice, bonus);
1892                         c->left++;
1893                         return;
1894
1895 syntax:
1896                         action(b, target, "bleeps at %s in a confused manner", prefix);
1897                         c->left++;
1898                         return;
1899                 }
1900         } else if (cmd[0] >= '0' && cmd[0] <= '9') {
1901                 long dice, sides, bonus = 0;
1902                 char *end;
1903                 dice = strtol(cmd, &end, 10);
1904                 if (dice >= 1 && dice <= 25 && *end == 'd' &&
1905                     (sides = strtol(end+1, &end, 10)) &&
1906                     sides > 1 && sides <= 20 && !*end) {
1907                         char *strbonus;
1908
1909                         c = &commands[strhash("roll") % elements(commands)];
1910                         if (!cmd_check(b, c, is_admin, t, prefix, target))
1911                                 return;
1912                         c->enter++;
1913                         snprintf(c->failed_command, sizeof(*c) - offsetof(struct command_hash, failed_command) - 1,
1914                                 "%s:%s (%s@%s) \"%s\" %s", target, prefix, ident, host, cmd, cmd_args);
1915
1916                         strbonus = token(&cmd_args, ' ');
1917                         if (strbonus) {
1918                                 bonus = strtol(strbonus, &end, 10);
1919                                 if (*end || bonus > 1000 || bonus < -1000)
1920                                         goto syntax;
1921                         }
1922
1923                         perform_roll(b, prefix, target, sides, dice, bonus);
1924                         c->left++;
1925                         return;
1926                 }
1927         }
1928
1929         if (chan == 2 && t > 0) {
1930                 static int64_t last_t;
1931                 if (t - last_t > 3)
1932                         privmsg(b, target, "%s: { I love you! }", prefix);
1933                 last_t = t;
1934         }
1935 }
1936
1937 void command_hook(struct bio *b, const char *prefix, const char *ident, const char *host,
1938                   const char *command, const char *const *args, unsigned nargs)
1939 {
1940         char *buf = NULL;
1941         int64_t t = -1;
1942         if (!strcasecmp(command, "NOTICE")) {
1943                 if (nargs < 2 || args[0][0] == '#')
1944                         return;
1945                 if (admin(host))
1946                         b->writeline(b, "%s", args[1]);
1947                 else
1948                         fprintf(stderr, "%s: %s\n", prefix, args[1]);
1949         } else if (!strcasecmp(command, "JOIN")) {
1950                 t = get_time(b, args[0]);
1951                 rss_check(b, args[0], t);
1952                 command_deliver(b, prefix, args[0]);
1953                 asprintf(&buf, "%"PRIi64",joining %s", t, args[0]);
1954         } else if (!strcasecmp(command, "PART")) {
1955                 t = get_time(b, args[0]);
1956                 rss_check(b, args[0], t);
1957                 asprintf(&buf, "%"PRIi64",leaving %s", t, args[0]);
1958         } else if (!strcasecmp(command, "QUIT")) {
1959                 t = get_time(b, NULL);
1960                 asprintf(&buf, "%"PRIi64",quitting with the message \"%s\"", t, args[0]);
1961         } else if (!strcasecmp(command, "NICK")) {
1962                 t = get_time(b, NULL);
1963                 if (t >= 0) {
1964                         asprintf(&buf, "%"PRIi64",changing nick from %s", t, prefix);
1965                         if (buf)
1966                                 update_seen(b, buf, args[0]);
1967                         free(buf);
1968                         buf = NULL;
1969                 }
1970                 asprintf(&buf, "%"PRIi64",changing nick to %s", t, args[0]);
1971         } else if (0) {
1972                 int i;
1973                 fprintf(stderr, ":%s!%s%s %s", prefix, ident, host, command);
1974                 for (i = 0; i < nargs; ++i)
1975                         fprintf(stderr, " %s", args[i]);
1976                 fprintf(stderr, "\n");
1977         }
1978         if (t >= 0 && buf)
1979                 update_seen(b, buf, prefix);
1980         free(buf);
1981         return;
1982 }
1983