trojanscan/trojanscan.c

   1 /*
   2  * Trojanscan version 2
   3  *
   4  * Trojanscan  copyright (C) Chris Porter 2002-2009
   5  * Newserv bits copyright (C) David Mansell 2002-2003
   6  *
   7  * TODO: CHECK::
   8  *   - Poke splidge about +r'ing bots, potential problems:
   9  *     - users might whine about T clone stealing account
  10  *       - would have to steal one already in use, so if trojans start using /msg q whois they'll see
  11  *       (though they have to be authed for this, they could use a clone of their own however)
  12  */
  13
  14 #include "trojanscan.h"
  15 #include "../lib/strlfunc.h"
  16 #include "../lib/version.h"
  17 #include "../core/nsmalloc.h"
  18 #include "../glines/glines.h"
  19 #include <stdint.h>
  20
  21 #define tmalloc(x)     nsmalloc(POOL_TROJANSCAN, x)
  22 #define tfree(x)       nsfree(POOL_TROJANSCAN, x)
  23
  24 MODULE_VERSION(TROJANSCAN_VERSION);
  25
  26 void trojanscan_phrasematch(channel *chp, nick *sender, trojanscan_phrases *phrase, char messagetype, char *matchbuf);
  27 char *trojanscan_sanitise(char *input);
  28 void trojanscan_refresh_settings(void);
  29 static void trojanscan_part_watch(int hook, void *arg);
  30 static void trojanscan_connect_nick(void *);
  31
  32 #define TROJANSCAN_SETTING_SIZE 256
  33 #define TROJANSCAN_MAX_SETTINGS 50
  34
  35 static struct {
  36   char setting[TROJANSCAN_SETTING_SIZE];
  37   char value[TROJANSCAN_SETTING_SIZE];
  38 } trojanscan_settings[TROJANSCAN_MAX_SETTINGS];
  39
  40 static int settingcount = 0;
  41 static char *versionreply;
  42 static int hooksregistered = 0;
  43 static void *trojanscan_connect_nick_schedule;
  44
  45 static void *db_ping_schedule;
  46
  47 void _init() {
  48   trojanscan_cmds = newcommandtree();
  49
  50   addcommandtotree(trojanscan_cmds, "showcommands", TROJANSCAN_ACL_UNAUTHED, 0, &trojanscan_showcommands);
  51   addcommandtotree(trojanscan_cmds, "help", TROJANSCAN_ACL_UNAUTHED, 1, &trojanscan_help);
  52   addcommandtotree(trojanscan_cmds, "hello", TROJANSCAN_ACL_UNAUTHED | TROJANSCAN_ACL_OPER, 1, &trojanscan_hello);
  53
  54   addcommandtotree(trojanscan_cmds, "join", TROJANSCAN_ACL_STAFF, 1, &trojanscan_userjoin);
  55   addcommandtotree(trojanscan_cmds, "chanlist", TROJANSCAN_ACL_STAFF, 0, &trojanscan_chanlist);
  56   addcommandtotree(trojanscan_cmds, "whois", TROJANSCAN_ACL_STAFF, 1, &trojanscan_whois);
  57
  58   addcommandtotree(trojanscan_cmds, "changelev", TROJANSCAN_ACL_STAFF | TROJANSCAN_ACL_OPER, 2, &trojanscan_changelev);
  59   addcommandtotree(trojanscan_cmds, "deluser", TROJANSCAN_ACL_TEAMLEADER | TROJANSCAN_ACL_OPER, 2, &trojanscan_deluser);
  60   addcommandtotree(trojanscan_cmds, "mew", TROJANSCAN_ACL_STAFF, 2, &trojanscan_mew);
  61   addcommandtotree(trojanscan_cmds, "status", TROJANSCAN_ACL_STAFF | TROJANSCAN_ACL_OPER, 0, &trojanscan_status);
  62   addcommandtotree(trojanscan_cmds, "listusers", TROJANSCAN_ACL_TEAMLEADER, 0, &trojanscan_listusers);
  63
  64   addcommandtotree(trojanscan_cmds, "rehash", TROJANSCAN_ACL_WEBSITE, 0, &trojanscan_rehash);
  65
  66   addcommandtotree(trojanscan_cmds, "cat", TROJANSCAN_ACL_OPER, 1, &trojanscan_cat);
  67
  68   addcommandtotree(trojanscan_cmds, "reschedule", TROJANSCAN_ACL_DEVELOPER | TROJANSCAN_ACL_OPER, 0, &trojanscan_reschedule);
  69
  70   srand((int)time(NULL));
  71
  72   trojanscan_connect_schedule = scheduleoneshot(time(NULL) + 1, &trojanscan_connect, NULL);
  73 }
  74
  75 void _fini(void) {
  76   int i;
  77   struct trojanscan_realchannels *rp = trojanscan_realchanlist, *oldrp;
  78   struct trojanscan_rejoinlist *rj = trojanscan_schedulerejoins, *oldrj;
  79
  80   if (trojanscan_nick)
  81     deregisterlocaluser(trojanscan_nick, NULL);
  82
  83   if (trojanscan_connect_schedule)
  84     deleteschedule(trojanscan_connect_schedule, &trojanscan_connect, NULL);
  85
  86   if (trojanscan_connect_nick_schedule)
  87     deleteschedule(trojanscan_connect_nick_schedule, &trojanscan_connect_nick, NULL);
  88
  89   if(trojanscan_schedule)
  90     deleteschedule(trojanscan_schedule, &trojanscan_dojoin, NULL);
  91
  92   if(trojanscan_poolschedule)
  93     deleteschedule(trojanscan_poolschedule, &trojanscan_repool, NULL);
  94
  95   if(trojanscan_cloneschedule)
  96     deleteschedule(trojanscan_poolschedule, &trojanscan_registerclones, NULL);
  97
  98   if(hooksregistered)
  99     deregisterhook(HOOK_CHANNEL_PART, trojanscan_part_watch);
 100
 101   while(rp) {
 102     deleteschedule(rp->schedule, &trojanscan_dopart, (void *)rp);
 103     oldrp = rp;
 104     rp = rp->next;
 105     tfree(oldrp);
 106   }
 107
 108   while(rj) {
 109     deleteschedule(rj->schedule, &trojanscan_rejoin_channel, (void *)rj);
 110     freesstring(rj->channel);
 111     oldrj = rj;
 112     rj = rj->next;
 113     tfree(oldrj);
 114   }
 115
 116   if(trojanscan_initialschedule)
 117     deleteschedule(trojanscan_initialschedule, &trojanscan_fill_channels, NULL);
 118
 119   deleteschedule(trojanscan_rehashschedule, &trojanscan_rehash_schedule, NULL);
 120
 121   for (i=0;i<TROJANSCAN_CLONE_TOTAL;i++)
 122     if(trojanscan_swarm[i].clone) {
 123       deregisterlocaluser(trojanscan_swarm[i].clone, NULL);
 124       derefnode(iptree, trojanscan_swarm[i].fakeipnode);
 125       trojanscan_swarm[i].clone = NULL;
 126     }
 127   trojanscan_free_database();
 128   trojanscan_free_channels();
 129
 130   for (i=0;i<trojanscan_hostpoolsize;i++)
 131     freesstring(trojanscan_hostpool[i]);
 132
 133   for (i=0;i<trojanscan_tailpoolsize;i++)
 134     freesstring(trojanscan_tailpool[i]);
 135
 136   trojanscan_database_close();
 137
 138   deletecommandfromtree(trojanscan_cmds, "showcommands", &trojanscan_showcommands);
 139   deletecommandfromtree(trojanscan_cmds, "help", &trojanscan_help);
 140   deletecommandfromtree(trojanscan_cmds, "hello", &trojanscan_hello);
 141   deletecommandfromtree(trojanscan_cmds, "join", &trojanscan_userjoin);
 142   deletecommandfromtree(trojanscan_cmds, "chanlist", &trojanscan_chanlist);
 143   deletecommandfromtree(trojanscan_cmds, "whois", &trojanscan_whois);
 144   deletecommandfromtree(trojanscan_cmds, "changelev", &trojanscan_changelev);
 145   deletecommandfromtree(trojanscan_cmds, "deluser", &trojanscan_deluser);
 146   deletecommandfromtree(trojanscan_cmds, "mew", &trojanscan_mew);
 147   deletecommandfromtree(trojanscan_cmds, "status", &trojanscan_status);
 148   deletecommandfromtree(trojanscan_cmds, "listusers", &trojanscan_listusers);
 149   deletecommandfromtree(trojanscan_cmds, "rehash", &trojanscan_rehash);
 150   deletecommandfromtree(trojanscan_cmds, "cat", &trojanscan_cat);
 151   deletecommandfromtree(trojanscan_cmds, "reschedule", &trojanscan_reschedule);
 152
 153   destroycommandtree(trojanscan_cmds);
 154   nscheckfreeall(POOL_TROJANSCAN);
 155 }
 156
 157 static void trojanscan_connect_nick(void *arg) {
 158   sstring *mnick, *myident, *myhost, *myrealname, *myauthname;
 159   channel *cp;
 160
 161   mnick = getcopyconfigitem("trojanscan", "nick", "T", NICKLEN);
 162   myident = getcopyconfigitem("trojanscan", "ident", "trojanscan", NICKLEN);
 163   myhost = getcopyconfigitem("trojanscan", "hostname", "trojanscan.quakenet.org", HOSTLEN);
 164   myrealname = getcopyconfigitem("trojanscan", "realname", "Trojanscan v" TROJANSCAN_VERSION, REALLEN);
 165   myauthname = getcopyconfigitem("trojanscan", "authname", "T", ACCOUNTLEN);
 166
 167   trojanscan_nick = registerlocaluser(mnick->content, myident->content, myhost->content, myrealname->content, myauthname->content, UMODE_SERVICE | UMODE_DEAF |
 168                                                                                                                           UMODE_OPER | UMODE_INV |
 169                                                                                                                           UMODE_ACCOUNT,
 170                                                                                                                           &trojanscan_handlemessages);
 171   freesstring(mnick);
 172   freesstring(myident);
 173   freesstring(myhost);
 174   freesstring(myrealname);
 175   freesstring(myauthname);
 176
 177   cp = findchannel(TROJANSCAN_OPERCHANNEL);
 178   if (!cp) {
 179     localcreatechannel(trojanscan_nick, TROJANSCAN_OPERCHANNEL);
 180   } else {
 181     if(!localjoinchannel(trojanscan_nick, cp))
 182       localgetops(trojanscan_nick, cp);
 183   }
 184
 185   cp = findchannel(TROJANSCAN_CHANNEL);
 186   if (!cp) {
 187     localcreatechannel(trojanscan_nick, TROJANSCAN_CHANNEL);
 188   } else {
 189     if(!localjoinchannel(trojanscan_nick, cp))
 190       localgetops(trojanscan_nick, cp);
 191   }
 192
 193 #ifdef TROJANSCAN_PEONCHANNEL
 194   cp = findchannel(TROJANSCAN_PEONCHANNEL);
 195   if (!cp) {
 196     localcreatechannel(trojanscan_nick, TROJANSCAN_PEONCHANNEL);
 197   } else {
 198     if(!localjoinchannel(trojanscan_nick, cp))
 199       localgetops(trojanscan_nick, cp);
 200   }
 201 #endif
 202 }
 203
 204 void trojanscan_connect(void *arg) {
 205   sstring *dbhost, *dbuser, *dbpass, *db, *dbport, *temp;
 206   int length, i;
 207   char buf[10];
 208
 209   trojanscan_connect_schedule = NULL;
 210
 211   for(i=0;i<TROJANSCAN_CLONE_TOTAL;i++)
 212     trojanscan_swarm[i].index = i; /* sure this could be done with pointer arithmetic... */
 213
 214   trojanscan_hostpoolsize = 0;
 215   trojanscan_tailpoolsize = 0;
 216   trojanscan_hostmode = 0;
 217   trojanscan_poolschedule = NULL;
 218   trojanscan_cloneschedule = NULL;
 219   trojanscan_realchanlist = NULL;
 220   trojanscan_database.glines = 0;
 221   trojanscan_database.detections = 0;
 222
 223   dbhost = getcopyconfigitem("trojanscan", "dbhost", "localhost", 100);
 224   dbuser = getcopyconfigitem("trojanscan", "dbuser", "moo", 100);
 225   dbpass = getcopyconfigitem("trojanscan", "dbpass", "changeme", 100);
 226   db = getcopyconfigitem("trojanscan", "db", "moo", 100);
 227
 228   dbport = getcopyconfigitem("trojanscan", "dbport", "3306", 10);
 229
 230   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_DEFAULT_MAXCHANS);
 231   temp = getcopyconfigitem("trojanscan", "maxchans", buf, length);
 232
 233   trojanscan_maxchans = atoi(temp->content);
 234   freesstring(temp);
 235
 236   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_DEFAULT_CYCLETIME);
 237   temp = getcopyconfigitem("trojanscan", "cycletime", buf, length);
 238
 239   trojanscan_cycletime = atoi(temp->content);
 240   freesstring(temp);
 241
 242   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_DEFAULT_PARTTIME);
 243   temp = getcopyconfigitem("trojanscan", "parttime", buf, length);
 244   trojanscan_part_time = atoi(temp->content);
 245   freesstring(temp);
 246
 247   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_DEFAULT_MAXUSERS);
 248   temp = getcopyconfigitem("trojanscan", "maxusers", buf, length);
 249   trojanscan_maxusers = atoi(temp->content);
 250   freesstring(temp);
 251
 252   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_MINIMUM_HOSTS_BEFORE_POOL);
 253   temp = getcopyconfigitem("trojanscan", "minpoolhosts", buf, length);
 254   trojanscan_min_hosts = atoi(temp->content);
 255   freesstring(temp);
 256
 257   if ((trojanscan_cycletime / trojanscan_maxchans) < 1) {
 258     Error("trojanscan", ERR_FATAL, "Cycletime / maxchans < 1, increase cycletime or decrease maxchans else cycling breaks.");
 259     freesstring(dbhost);
 260     freesstring(dbuser);
 261     freesstring(dbpass);
 262     freesstring(db);
 263     freesstring(dbport);
 264     return; /* PPA: module failed to load */
 265   }
 266
 267   length = snprintf(buf, sizeof(buf) - 1, "%d", TROJANSCAN_DEFAULT_MINIMUM_CHANNEL_SIZE);
 268   temp = getcopyconfigitem("trojanscan", "minchansize", buf, length);
 269   trojanscan_minchansize = atoi(temp->content);
 270   freesstring(temp);
 271
 272   trojanscan_connect_nick(NULL);
 273
 274   if (trojanscan_database_connect(dbhost->content, dbuser->content, dbpass->content, db->content, atoi(dbport->content)) < 0) {
 275     Error("trojanscan", ERR_FATAL, "Cannot connect to database host!");
 276     freesstring(dbhost);
 277     freesstring(dbuser);
 278     freesstring(dbpass);
 279     freesstring(db);
 280     freesstring(dbport);
 281     return; /* PPA: module failed to load */
 282   }
 283
 284   trojanscan_database_query("CREATE TABLE phrases (id INT(10) PRIMARY KEY AUTO_INCREMENT, wormid INT(10) NOT NULL, phrase TEXT NOT NULL, priority INT(10) DEFAULT 0 NOT NULL, dateadded int(10), disabled BOOL DEFAULT 0 NOT NULL)");
 285   trojanscan_database_query("CREATE TABLE worms (id INT(10) PRIMARY KEY AUTO_INCREMENT, wormname TEXT NOT NULL, glinetype INT DEFAULT 0, data text, hitmsgs BOOL DEFAULT 1, hitchans BOOL DEFAULT 0, epidemic BOOL DEFAULT 0, privinfo text)");
 286   trojanscan_database_query("CREATE TABLE logs (id INT(10) PRIMARY KEY AUTO_INCREMENT, userid INT(10) NOT NULL, act TEXT NOT NULL, description TEXT NOT NULL, ts TIMESTAMP)");
 287   trojanscan_database_query("CREATE TABLE channels (id INT(10) PRIMARY KEY AUTO_INCREMENT, channel VARCHAR(%d) NOT NULL, exempt BOOL DEFAULT 0)", CHANNELLEN);
 288   trojanscan_database_query("CREATE TABLE users (id INT(10) PRIMARY KEY AUTO_INCREMENT, authname VARCHAR(%d) NOT NULL, authlevel TINYINT(4) NOT NULL)", ACCOUNTLEN);
 289   trojanscan_database_query("CREATE TABLE hits (id INT(10) PRIMARY KEY AUTO_INCREMENT, nickname VARCHAR(%d) NOT NULL, ident VARCHAR(%d) NOT NULL, host VARCHAR(%d) NOT NULL, phrase INT(10) NOT NULL, ts TIMESTAMP, messagetype VARCHAR(1) NOT NULL DEFAULT 'm', glined BOOL DEFAULT 1)", NICKLEN, USERLEN, HOSTLEN);
 290   trojanscan_database_query("CREATE TABLE settings (id INT(10) PRIMARY KEY AUTO_INCREMENT, setting VARCHAR(255) NOT NULL UNIQUE, value VARCHAR(255) NOT NULL)");
 291   trojanscan_database_query("CREATE TABLE wwwlogs (id INT(10) PRIMARY KEY AUTO_INCREMENT, authid INT(10) NOT NULL, ip VARCHAR(15), action TEXT, ts TIMESTAMP)");
 292   trojanscan_database_query("CREATE TABLE unknownlog (id INT(10) PRIMARY KEY AUTO_INCREMENT, data TEXT, user VARCHAR(%d) NOT NULL, ts TIMESTAMP)", NICKLEN+USERLEN+HOSTLEN+3);
 293
 294   trojanscan_database_query("DELETE FROM settings WHERE setting = 'rehash' OR setting = 'changed'");
 295   trojanscan_database_query("INSERT INTO settings (setting, value) VALUES ('rehash','0')");
 296   trojanscan_database_query("INSERT INTO settings (setting, value) VALUES ('changed','0')");
 297
 298   /* assumption: constants aren't supplied by someone evil */
 299   trojanscan_database_query("INSERT INTO settings (setting, value) VALUES ('versionreply','" TROJANSCAN_DEFAULT_VERSION_REPLY "')");
 300
 301   trojanscan_refresh_settings();
 302   trojanscan_read_database(1);
 303
 304   freesstring(dbhost);
 305   freesstring(dbuser);
 306   freesstring(dbpass);
 307   freesstring(db);
 308   freesstring(dbport);
 309   trojanscan_registerclones(NULL);
 310
 311   trojanscan_rehashschedule = scheduleoneshot(time(NULL) + 60, &trojanscan_rehash_schedule, NULL);
 312
 313   registerhook(HOOK_CHANNEL_PART, trojanscan_part_watch);
 314   hooksregistered = 1;
 315 }
 316
 317 char *trojanscan_get_setting(char *setting) {
 318   int i;
 319
 320   for(i=0;i<settingcount;i++)
 321     if(!strcmp(trojanscan_settings[i].setting, setting))
 322       return trojanscan_settings[i].value;
 323
 324   return NULL;
 325 }
 326
 327 void trojanscan_refresh_settings(void) {
 328   trojanscan_database_res *res;
 329   trojanscan_database_row sqlrow;
 330   int i = 0;
 331
 332   if(trojanscan_database_query("SELECT setting, value FROM settings"))
 333     return;
 334
 335   if(!(res = trojanscan_database_store_result(&trojanscan_sql)))
 336     return;
 337
 338   if (trojanscan_database_num_rows(res) <= 0)
 339     return;
 340
 341   while((sqlrow = trojanscan_database_fetch_row(res))) {
 342     strlcpy(trojanscan_settings[i].setting, sqlrow[0], TROJANSCAN_SETTING_SIZE);
 343     strlcpy(trojanscan_settings[i].value, sqlrow[1], TROJANSCAN_SETTING_SIZE);
 344
 345     trojanscan_sanitise(trojanscan_settings[i].value);
 346
 347     if(++i == TROJANSCAN_MAX_SETTINGS)
 348       break;
 349   }
 350
 351   settingcount = i;
 352
 353   trojanscan_database_free_result(res);
 354
 355   /* optimisation hack */
 356   versionreply = trojanscan_get_setting("versionreply");
 357 }
 358
 359 void trojanscan_rehash_schedule(void *arg) {
 360   char *v;
 361   trojanscan_rehashschedule = scheduleoneshot(time(NULL) + 60, &trojanscan_rehash_schedule, NULL);
 362
 363   trojanscan_refresh_settings();
 364
 365   v = trojanscan_get_setting("rehash");
 366   if(v && v[0] == '1') {
 367     trojanscan_mainchanmsg("n: rehash initiated by website. . .");
 368     trojanscan_read_database(0);
 369   }
 370 }
 371
 372 void trojanscan_free_database(void) {
 373   int i;
 374   for(i=0;i<trojanscan_database.total_channels;i++)
 375     freesstring(trojanscan_database.channels[i].name);
 376   tfree(trojanscan_database.channels);
 377   for(i=0;i<trojanscan_database.total_phrases;i++) {
 378     if (trojanscan_database.phrases[i].phrase)
 379       pcre_free(trojanscan_database.phrases[i].phrase);
 380     if (trojanscan_database.phrases[i].hint)
 381       pcre_free(trojanscan_database.phrases[i].hint);
 382   }
 383   tfree(trojanscan_database.phrases);
 384   for(i=0;i<trojanscan_database.total_worms;i++)
 385     freesstring(trojanscan_database.worms[i].name);
 386   tfree(trojanscan_database.worms);
 387   trojanscan_database.total_channels = 0;
 388   trojanscan_database.total_phrases = 0;
 389   trojanscan_database.total_worms = 0;
 390   trojanscan_database.channels = NULL;
 391   trojanscan_database.phrases = NULL;
 392   trojanscan_database.worms = NULL;
 393 }
 394
 395 char *trojanscan_sanitise(char *input) {
 396   char *p;
 397
 398   for(p=input;*p;p++)
 399     if(*p == '\r' || *p == '\n')
 400       *p = '!';
 401
 402   return input;
 403 }
 404
 405 sstring *trojanscan_getsstring(char *string, int length) {
 406   int i;
 407
 408   for(i=0;i<length;i++) {
 409     if ((string[i] == '\r') || (string[i] == '\n')) {
 410       Error("trojanscan", ERR_WARNING, "Error reading %s at position %d, set to ERROR!", string, i+1);
 411       return getsstring("ERROR", sizeof("ERROR"));
 412     }
 413   }
 414
 415   return getsstring(string, length);
 416 }
 417
 418 int trojanscan_strip_codes(char *buf, size_t max, char *original) {
 419   int i, j, length = TROJANSCAN_MMIN(strlen(original), max-1);
 420   char *p2 = original, *p3, flag = 0;
 421   p3 = buf;
 422   for(i=0;i<length+1;i++) {
 423     switch (*p2) {
 424       case '\002':
 425       case '\017':
 426       case '\026':
 427       case '\037':
 428       break;
 429       case '\003':
 430         for(j=0;j<6;j++) {
 431           if ((i + 1) > length)
 432             break;
 433           if ((j == 4) && flag)
 434             break;
 435           p2++;
 436           i++;
 437           if ((j == 0) && (!((*p2 >= '0') && (*p2 <= '9'))))
 438             break;
 439           if (j == 1) {
 440
 441             if (*p2 == ',') {
 442                 if ((i + 1) > length)
 443                   break;
 444                 if (!((*(p2 + 1) >= '0') && (*(p2 + 1) <= '9')))
 445                   break;
 446               flag = 1;
 447             } else if ((*p2 >= '0') && (*p2 <= '9')) {
 448               flag = 0;
 449             } else {
 450               break;
 451             }
 452           }
 453           if (j == 2) {
 454             if (flag) {
 455               if (!((*p2 >= '0') && (*p2 <= '9')))
 456                 break;
 457             } else {
 458               if (*p2 != ',') {
 459                 break;
 460               } else {
 461                 if ((i + 1) > length)
 462                   break;
 463                 if (!((*(p2 + 1) >= '0') && (*(p2 + 1) <= '9')))
 464                   break;
 465               }
 466             }
 467           }
 468           if ((j == 3) && (!((*p2 >= '0') && (*p2 <= '9'))))
 469             break;
 470           if ((j == 4) && (!((*p2 >= '0') && (*p2 <= '9'))))
 471             break;
 472         }
 473         p2--;
 474         i--;
 475         break;
 476
 477       default:
 478         *p3 = *p2;
 479         p3++;
 480         break;
 481     }
 482     p2++;
 483   }
 484   return p3 - buf;
 485 }
 486
 487 struct trojanscan_worms *trojanscan_find_worm_by_id(int id) {
 488   int i;
 489   for(i=0;i<trojanscan_database.total_worms;i++)
 490     if (trojanscan_database.worms[i].id == id)
 491       return &trojanscan_database.worms[i];
 492   return NULL;
 493 }
 494
 495 void trojanscan_read_database(int first_time) {
 496   const char *error;
 497   int erroroffset, i, tempresult;
 498
 499   trojanscan_database_res *res;
 500   trojanscan_database_row sqlrow;
 501
 502   if (!first_time) {
 503     trojanscan_free_database();
 504   } else {
 505     trojanscan_database.total_channels = 0;
 506     trojanscan_database.total_phrases = 0;
 507     trojanscan_database.total_worms = 0;
 508   }
 509
 510   if (!(trojanscan_database_query("SELECT channel, exempt FROM channels"))) {
 511     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
 512       trojanscan_database.total_channels = trojanscan_database_num_rows(res);
 513       if (trojanscan_database.total_channels > 0) {
 514         if ((trojanscan_database.channels = (trojanscan_channels *)tmalloc(sizeof(trojanscan_channels) * trojanscan_database.total_channels))) {
 515           if ((trojanscan_database.total_channels>0) && trojanscan_database.channels) {
 516             i = 0;
 517             while((sqlrow = trojanscan_database_fetch_row(res))) {
 518               trojanscan_database.channels[i].name = trojanscan_getsstring(trojanscan_sanitise(sqlrow[0]), strlen(sqlrow[0]));
 519               trojanscan_database.channels[i].exempt = (sqlrow[1][0] == '1');
 520               i++;
 521             }
 522           }
 523         }
 524       }
 525       trojanscan_database_free_result(res);
 526     }
 527   }
 528
 529   if (!(trojanscan_database_query("SELECT id, wormname, glinetype, length(data), hitmsgs, hitchans, epidemic FROM worms"))) {
 530     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
 531       trojanscan_database.total_worms = trojanscan_database_num_rows(res);
 532       if (trojanscan_database.total_worms > 0) {
 533         if ((trojanscan_database.worms = (trojanscan_worms *)tmalloc(sizeof(trojanscan_worms) * trojanscan_database.total_worms))) {
 534           i = 0;
 535           while((sqlrow = trojanscan_database_fetch_row(res))) {
 536             trojanscan_database.worms[i].id = atoi(sqlrow[0]);
 537             trojanscan_database.worms[i].name = trojanscan_getsstring(trojanscan_sanitise(sqlrow[1]), strlen(sqlrow[1]));
 538             tempresult = atoi(sqlrow[2]);
 539             trojanscan_database.worms[i].glineuser = (tempresult == 0);
 540             trojanscan_database.worms[i].glinehost = (tempresult == 1);
 541             trojanscan_database.worms[i].monitor = (tempresult == 2);
 542             if(sqlrow[3]) {
 543               trojanscan_database.worms[i].datalen = ((atoi(sqlrow[3]) == 0) ? 0 : 1);
 544             } else {
 545               trojanscan_database.worms[i].datalen = 0;
 546             }
 547
 548             trojanscan_database.worms[i].hitpriv = (atoi(sqlrow[4]) == 1);
 549             trojanscan_database.worms[i].hitchans = (atoi(sqlrow[5]) == 1);
 550             trojanscan_database.worms[i].epidemic = (atoi(sqlrow[6]) == 1);
 551
 552             i++;
 553           }
 554         }
 555       }
 556       trojanscan_database_free_result(res);
 557     }
 558   }
 559
 560   if (!(trojanscan_database_query("SELECT id, phrase, wormid FROM phrases WHERE disabled = 0 ORDER BY priority DESC"))) {
 561     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
 562       trojanscan_database.total_phrases = trojanscan_database_num_rows(res);
 563       if (trojanscan_database.total_phrases > 0) {
 564         if ((trojanscan_database.phrases = (trojanscan_phrases *)tmalloc(sizeof(trojanscan_phrases) * trojanscan_database.total_phrases))) {
 565           i = 0;
 566           while((sqlrow = trojanscan_database_fetch_row(res))) {
 567             trojanscan_database.phrases[i].id = atoi(sqlrow[0]);
 568             trojanscan_database.phrases[i].worm = trojanscan_find_worm_by_id(atoi(sqlrow[2]));
 569             if (!(trojanscan_database.phrases[i].phrase = pcre_compile(sqlrow[1], PCRE_CASELESS, &error, &erroroffset, NULL))) {
 570               Error("trojanscan", ERR_WARNING, "Error compiling expression %s at offset %d: %s", sqlrow[1], erroroffset, error);
 571             } else {
 572               trojanscan_database.phrases[i].hint = pcre_study(trojanscan_database.phrases[i].phrase, 0, &error);
 573               if (error) {
 574                 Error("trojanscan", ERR_WARNING, "Error studying expression %s: %s", sqlrow[1], error);
 575                 pcre_free(trojanscan_database.phrases[i].phrase);
 576                 trojanscan_database.phrases[i].phrase = NULL;
 577               }
 578             }
 579             i++;
 580           }
 581         }
 582       }
 583       trojanscan_database_free_result(res);
 584     }
 585   }
 586
 587   trojanscan_database_query("UPDATE settings SET value = '0' where setting = 'rehash'");
 588 }
 589
 590 void trojanscan_log(nick *np, char *event, char *details, ...) {
 591   int nickid = 0;
 592   char eevent[TROJANSCAN_QUERY_TEMP_BUF_SIZE], edetails[TROJANSCAN_QUERY_TEMP_BUF_SIZE], buf[513];
 593   va_list va;
 594
 595   va_start(va, details);
 596   vsnprintf(buf, sizeof(buf) - 1, details, va);
 597   va_end(va);
 598
 599   if (np)
 600     if (IsAccount(np))
 601       nickid = trojanscan_user_id_by_authname(np->authname);
 602
 603   trojanscan_database_escape_string(eevent, event, strlen(event));
 604   trojanscan_database_escape_string(edetails, buf, strlen(buf));
 605   trojanscan_database_query("INSERT INTO logs (userid, act, description) VALUES ('%d', '%s', '%s')", nickid, eevent, edetails);
 606 }
 607
 608 void trojanscan_generateclone(void *arg) {
 609   int i, loops = 0, modes = UMODE_XOPER | UMODE_INV;
 610   char c_nick[NICKLEN+1], c_ident[USERLEN+1], c_host[HOSTLEN+1], c_real[REALLEN+1];
 611   patricia_node_t *fakeip;
 612
 613   i = (int)((long)arg);
 614
 615   /* PPA: unlikely to be infinite */
 616   do {
 617     c_nick[0] = '\0';
 618     if (!loops && trojanscan_hostmode) /* only have one go at this */
 619       trojanscan_generatenick(c_nick, NICKLEN);
 620     if(!c_nick[0])
 621       trojanscan_gennick(c_nick, trojanscan_minmaxrand(7, TROJANSCAN_MMIN(13, NICKLEN)));
 622     loops++;
 623   } while ((getnickbynick(c_nick) != NULL));
 624
 625   trojanscan_generateident(c_ident, USERLEN);
 626   if(!c_ident[0])
 627     trojanscan_genident(c_ident, trojanscan_minmaxrand(4, TROJANSCAN_MMIN(8, USERLEN)));
 628
 629   if(trojanscan_hostmode) {
 630     trojanscan_generatehost(c_host, HOSTLEN, &fakeip);
 631     if(!c_host[0])
 632       trojanscan_genhost(c_host, HOSTLEN, &fakeip);
 633   } else {
 634     trojanscan_genhost(c_host, HOSTLEN, &fakeip);
 635   }
 636
 637   trojanscan_generaterealname(c_real, REALLEN);
 638   if(!c_real[0])
 639     trojanscan_genreal(c_real, trojanscan_minmaxrand(15, TROJANSCAN_MMIN(50, REALLEN)));
 640
 641   trojanscan_swarm[i].clone = registerlocaluser(c_nick, c_ident, c_host, c_real, NULL, modes, &trojanscan_clonehandlemessages);
 642   trojanscan_swarm[i].fakeipnode = fakeip;
 643
 644   if(trojanscan_swarm[i].clone && !trojanscan_swarm_created) {
 645     nick *np = trojanscan_selectuser();
 646     if(np) /* select a 'random' sign on time for whois generation */
 647       trojanscan_swarm[i].clone->timestamp = np->timestamp;
 648   }
 649   trojanscan_swarm[i].remaining = trojanscan_minmaxrand(5, 100);
 650
 651   trojanscan_swarm[i].sitting = 0;
 652
 653 }
 654
 655 void trojanscan_free_channels(void) {
 656   int i;
 657   if(trojanscan_chans) {
 658     for(i=0;i<trojanscan_activechans;i++)
 659       freesstring(trojanscan_chans[i].channel);
 660     tfree(trojanscan_chans);
 661     trojanscan_chans = NULL;
 662     trojanscan_activechans = 0;
 663   }
 664 }
 665
 666 void trojanscan_repool(void *arg) {
 667   if (trojanscan_generatepool() < TROJANSCAN_MINPOOLSIZE) {
 668     trojanscan_hostmode = 0;
 669     return;
 670   } else {
 671     trojanscan_hostmode = 1;
 672     trojanscan_poolschedule = scheduleoneshot(time(NULL) + TROJANSCAN_POOL_REGENERATION, &trojanscan_repool, NULL);
 673   }
 674 }
 675
 676 void trojanscan_registerclones(void *arg) {
 677   unsigned int i;
 678
 679   if (trojanscan_generatepool() < TROJANSCAN_MINPOOLSIZE) {
 680     trojanscan_hostmode = 0;
 681     trojanscan_cloneschedule = scheduleoneshot(time(NULL) + 10, &trojanscan_registerclones, NULL);
 682     return;
 683   } else {
 684     trojanscan_hostmode = 1;
 685     trojanscan_poolschedule = scheduleoneshot(time(NULL) + TROJANSCAN_POOL_REGENERATION, &trojanscan_repool, NULL);
 686     trojanscan_cloneschedule = NULL;
 687   }
 688
 689   for (i=0;i<TROJANSCAN_CLONE_TOTAL;i++)
 690     trojanscan_generateclone((void *)((long)i));
 691   trojanscan_mainchanmsg("n: swarm (%d clones) created.", TROJANSCAN_CLONE_TOTAL);
 692   trojanscan_swarm_created = 1;
 693
 694   trojanscan_initialschedule = scheduleoneshot(time(NULL) + 60, &trojanscan_fill_channels, NULL);
 695 }
 696
 697 int trojanscan_status(void *sender, int cargc, char **cargv) {
 698   nick *np = (nick *)sender;
 699   trojanscan_log(np, "status", "");
 700   trojanscan_reply(np, "Channels in schedule: %d", trojanscan_activechans);
 701   trojanscan_reply(np, "Channels in database: %d", trojanscan_database.total_channels);
 702   trojanscan_reply(np, "Phrases: %d", trojanscan_database.total_phrases);
 703   trojanscan_reply(np, "Worms: %d", trojanscan_database.total_worms);
 704   trojanscan_reply(np, "Detections: %d", trojanscan_database.detections);
 705   trojanscan_reply(np, "Glines: %d", trojanscan_database.glines);
 706   trojanscan_reply(np, "Host/tail pool size: %d", TROJANSCAN_POOLSIZE);
 707   trojanscan_reply(np, "Cycletime: %d", trojanscan_cycletime);
 708   trojanscan_reply(np, "Clones: %d", TROJANSCAN_CLONE_TOTAL);
 709   return CMD_OK;
 710 }
 711
 712 int trojanscan_chanlist(void *sender, int cargc, char **cargv) {
 713   int i;
 714   nick *np = (nick *)sender;
 715   char buf[CHANNELLEN * 2 + 20];
 716   trojanscan_reply(np, "Channel list (%d total):", trojanscan_activechans);
 717   buf[0] = '\0';
 718
 719   for(i=0;i<trojanscan_activechans;i++) {
 720     if(trojanscan_chans[i].channel->length + 3 > sizeof(buf) - strlen(buf)) {
 721       trojanscan_reply(np, "%s", buf);
 722       buf[0] = '\0';
 723     }
 724
 725     /* if splidge sees this I'm going to die */
 726     strlcat(buf, trojanscan_chans[i].channel->content, sizeof(buf));
 727     strlcat(buf, " ", sizeof(buf));
 728   }
 729   if(buf[0])
 730     trojanscan_reply(np, "%s", buf);
 731
 732   trojanscan_reply(np, "Done.");
 733   return CMD_OK;
 734 }
 735
 736 int trojanscan_whois(void *sender, int cargc, char **cargv) {
 737   char *tochange;
 738   nick *np = (nick *)sender, *np2;
 739   int templevel;
 740
 741   if (cargc < 1) {
 742     trojanscan_reply(np, "Not enough parameters.");
 743     return CMD_ERROR;
 744   }
 745
 746   if (cargv[0][0] == '#') {
 747     tochange = cargv[0] + 1;
 748   } else {
 749     int i;
 750     np2 = getnickbynick(cargv[0]);
 751     if (!np2) {
 752       trojanscan_reply(np, "That nickname is not on the network.");
 753       return CMD_ERROR;
 754     }
 755     for(i=0;i<TROJANSCAN_CLONE_TOTAL;i++) {
 756       if(trojanscan_swarm[i].clone->nick && !ircd_strcmp(trojanscan_swarm[i].clone->nick, np2->nick)) {
 757         trojanscan_reply(np, "Nickname   : %s", np2->nick);
 758         trojanscan_reply(np, "Swarm      : yes");
 759         return CMD_OK;
 760       }
 761     }
 762     if (!IsAccount(np2)) {
 763       trojanscan_reply(np, "User is not authed.");
 764       return CMD_OK;
 765     }
 766     tochange = np2->authname;
 767   }
 768
 769   templevel = trojanscan_user_level_by_authname(tochange);
 770   if (templevel == -1) {
 771     trojanscan_reply(np, "User does not exist.");
 772   } else {
 773     union trojanscan_userlevel flags;
 774     flags.number = templevel;
 775     trojanscan_reply(np, "Authname   : %s", tochange);
 776     trojanscan_reply(np, "Flags      : +" TROJANSCAN_FLAG_MASK, TrojanscanFlagsInfo(flags));
 777   }
 778
 779   return CMD_OK;
 780 }
 781
 782 void trojanscan_privmsg_chan_or_nick(channel *cp, nick *np, char *message, ...) {
 783   char buf[513];
 784   va_list va;
 785
 786   if (!trojanscan_nick)
 787     return;
 788
 789   va_start(va, message);
 790   vsnprintf(buf, sizeof(buf) - 1, message, va);
 791   va_end(va);
 792
 793   if (cp) {
 794     sendmessagetochannel(trojanscan_nick, cp, "%s", buf);
 795   } else {
 796     sendmessagetouser(trojanscan_nick, np, "%s", buf);
 797   }
 798
 799 }
 800
 801 int trojanscan_mew(void *sender, int cargc, char **cargv) {
 802   nick *np = (nick *)sender, *np2 = NULL;
 803   channel *cp = NULL;
 804
 805   if (cargc < 2) {
 806     trojanscan_reply(np, "Not enough paramaters.");
 807     return CMD_ERROR;
 808   }
 809
 810   if(cargv[0][0] == '#') {
 811     if (!(cp = findchannel(cargv[0]))) {
 812       trojanscan_reply(np, "Channel not found.");
 813       return CMD_ERROR;
 814     }
 815     trojanscan_log(np, "mew", "%s %s", cp->index->name->content, cargv[1]);
 816   } else {
 817     if (!(np2 = getnickbynick(cargv[0]))) {
 818       trojanscan_reply(np, "Nickname is not present on the network.");
 819       return CMD_ERROR;
 820     }
 821     trojanscan_log(np, "mew", "%s %s", np2->nick, cargv[1]);
 822   }
 823
 824   trojanscan_privmsg_chan_or_nick(cp, np2, "\001ACTION mews hopefully at %s\001", cargv[1]);
 825
 826   if (cp) {
 827     trojanscan_reply(np, "Mewed at %s in %s.", cargv[1], cp->index->name->content);
 828   } else {
 829     trojanscan_reply(np, "Mewed at %s at %s.", cargv[1], np2->nick);
 830   }
 831
 832   if(!IsOper(np))
 833     trojanscan_mainchanmsg("n: mew: %s %s (%s/%s)", cargv[1], cp?cp->index->name->content:np2->nick, np->nick, np->authname);
 834
 835   return CMD_OK;
 836 }
 837
 838 int trojanscan_cat(void *sender, int cargc, char **cargv) {
 839   nick *np = (nick *)sender, *np2 = NULL;
 840   channel *cp = NULL;
 841   FILE *cat;
 842   char buf[513], *p;
 843
 844   if (cargc < 1) {
 845     trojanscan_reply(np, "Not enough paramaters.");
 846     return CMD_ERROR;
 847   }
 848
 849   if(cargv[0][0] == '#') {
 850     if (!(cp = findchannel(cargv[0]))) {
 851       trojanscan_reply(np, "Channel not found.");
 852       return CMD_ERROR;
 853     }
 854     trojanscan_log(np, "cat", cp->index->name->content);
 855   } else {
 856     if (!(np2 = getnickbynick(cargv[0]))) {
 857       trojanscan_reply(np, "Nickname is not present on the network.");
 858       return CMD_ERROR;
 859     }
 860     trojanscan_log(np, "cat", np2->nick);
 861   }
 862
 863   if ((!(cat = fopen(TROJANSCAN_CAT, "r")))) {
 864     trojanscan_reply(np, "Unable to open cat!");
 865     return CMD_ERROR;
 866   }
 867
 868   while (fgets(buf, sizeof(buf) - 1, cat)) {
 869     if ((p = strchr(buf, '\n'))) {
 870       *p = '\0';
 871       trojanscan_privmsg_chan_or_nick(cp, np2, "%s", buf);
 872     } else if (feof(cat)) {
 873       trojanscan_privmsg_chan_or_nick(cp, np2, "%s", buf);
 874     }
 875   }
 876
 877   fclose(cat);
 878
 879   if (cp) {
 880     trojanscan_reply(np, "Spammed cat in %s.", cp->index->name->content);
 881   } else {
 882     trojanscan_reply(np, "Spammed cat at %s.", np2->nick);
 883   }
 884
 885   return CMD_OK;
 886 }
 887
 888 int trojanscan_reschedule(void *sender, int cargc, char **cargv) {
 889   nick *np = (nick *)sender;
 890   trojanscan_log(np, "reschedule", "");
 891   trojanscan_fill_channels(NULL);
 892
 893   trojanscan_reply(np, "Rescheduled.");
 894   return CMD_OK;
 895 }
 896
 897 int trojanscan_listusers(void *sender, int cargc, char **cargv) {
 898   nick *np = (nick *)sender;
 899
 900   trojanscan_log(np, "listusers", "");
 901
 902   trojanscan_reply(np, "User list:");
 903
 904   if (!(trojanscan_database_query("SELECT authname, authlevel FROM users ORDER BY authlevel DESC, authname"))) {
 905     trojanscan_database_res *res;
 906     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
 907       if (trojanscan_database_num_rows(res)) {
 908         trojanscan_database_row sqlrow;
 909         union trojanscan_userlevel flags;
 910         while((sqlrow = trojanscan_database_fetch_row(res))) {
 911           flags.number = atoi(sqlrow[1]);
 912           trojanscan_reply(np, "%s +" TROJANSCAN_FLAG_MASK, sqlrow[0], TrojanscanIsDeveloper(flags) ? "d" : "", TrojanscanIsTeamLeader(flags) ? "t" : "", TrojanscanIsStaff(flags) ? "s" : "", TrojanscanIsWebsite(flags) ? "w" : "", TrojanscanIsCat(flags) ? "c" : "");
 913         }
 914       }
 915       trojanscan_database_free_result(res);
 916     }
 917   }
 918
 919   trojanscan_reply(np, "Done.");
 920   return CMD_OK;
 921 }
 922
 923 int trojanscan_help(void *sender, int cargc, char **cargv) {
 924   nick *np = (nick *)sender;
 925
 926   if (cargc == 0) {
 927     trojanscan_reply(np, "Not enough parameters.");
 928     return CMD_ERROR;
 929   }
 930
 931   if (!strcasecmp("help", cargv[0])) {
 932     trojanscan_reply(np, "Syntax: help <command name>");
 933     trojanscan_reply(np, "Gives help on commands.");
 934   } else if (!strcasecmp("status", cargv[0])) {
 935     trojanscan_reply(np, "Syntax: status");
 936     trojanscan_reply(np, "Gives statistical information about the bot.");
 937   } else if (!strcasecmp("join", cargv[0])) {
 938     trojanscan_reply(np, "Syntax: join <#channel>");
 939     trojanscan_reply(np, "Orders a clone to join supplied channel.");
 940   } else if (!strcasecmp("showcommands", cargv[0])) {
 941     trojanscan_reply(np, "Syntax: showcommands");
 942     trojanscan_reply(np, "Pretty obvious.");
 943   } else if (!strcasecmp("hello", cargv[0])) {
 944     trojanscan_reply(np, "Syntax: hello ?nickname?");
 945     trojanscan_reply(np, "Creates a new user.");
 946   } else if (!strcasecmp("rehash", cargv[0])) {
 947     trojanscan_reply(np, "Syntax: rehash");
 948     trojanscan_reply(np, "Reloads bot database.");
 949   } else if (!strcasecmp("changelev", cargv[0])) {
 950     trojanscan_reply(np, "Syntax: changelev <nickname or #authname> <flags>");
 951     trojanscan_reply(np, "Changes access flags of selected user to supplied input.");
 952     trojanscan_reply(np, "+d -> developer");
 953     trojanscan_reply(np, "+t -> team leader");
 954     trojanscan_reply(np, "+s -> staff");
 955     trojanscan_reply(np, "+w -> web management");
 956     trojanscan_reply(np, "+c -> cat access");
 957   } else if (!strcasecmp("deluser", cargv[0])) {
 958     trojanscan_reply(np, "Syntax: deluser <nickname or #authname>");
 959     trojanscan_reply(np, "Deletes selected user from my database.");
 960   } else if (!strcasecmp("mew", cargv[0])) {
 961     trojanscan_reply(np, "Syntax: mew <#channel or nickname> <nickname>");
 962     trojanscan_reply(np, "Gracefully mews at target in selected channel or query.");
 963   } else if (!strcasecmp("cat", cargv[0])) {
 964     trojanscan_reply(np, "Syntax: cat <#channel or nickname>");
 965     trojanscan_reply(np, "Shows the almightly cat.");
 966   } else if (!strcasecmp("reschedule", cargv[0])) {
 967     trojanscan_reply(np, "Syntax: reschedule");
 968     trojanscan_reply(np, "Recalculates bots schedule.");
 969   } else if (!strcasecmp("chanlist", cargv[0])) {
 970     trojanscan_reply(np, "Syntax: chanlist");
 971     trojanscan_reply(np, "Displays bots current channel list.");
 972   } else if (!strcasecmp("whois", cargv[0])) {
 973     trojanscan_reply(np, "Syntax: whois <nickname or #authname>");
 974     trojanscan_reply(np, "Displays information on given user.");
 975   } else if (!strcasecmp("whois", cargv[0])) {
 976     trojanscan_reply(np, "Syntax: listusers <flags>");
 977     trojanscan_reply(np, "Displays users with listusersing flags.");
 978   } else {
 979     trojanscan_reply(np, "Command not found.");
 980     return CMD_ERROR;
 981   }
 982
 983   return CMD_OK;
 984 }
 985
 986 int trojanscan_hello(void *sender, int cargc, char **cargv) {
 987   nick *np = (nick *)sender, *toadd;
 988   char eaccount[TROJANSCAN_QUERY_TEMP_BUF_SIZE];
 989   int level = 0;
 990
 991   if (cargc > 0) {
 992     toadd = getnickbynick(cargv[0]);
 993     if (!toadd) {
 994       trojanscan_reply(np, "That nickname is not on the network.");
 995       return CMD_ERROR;
 996     }
 997     if (!IsAccount(toadd)) {
 998       trojanscan_reply(np, "That user is not authed with the network.");
 999       return CMD_ERROR;
1000     }
1001   } else {
1002     if (!IsAccount(np)) {
1003       trojanscan_reply(np, "You are not authed with the network, auth before creating your user.");
1004       return CMD_ERROR;
1005     }
1006     toadd = np;
1007   }
1008
1009   if (trojanscan_user_level_by_authname(toadd->authname)!=-1) {
1010     trojanscan_reply(np, "Authname (%s) is already on file.", toadd->authname);
1011     return CMD_ERROR;
1012   }
1013
1014   trojanscan_log(np, "hello", toadd->authname);
1015
1016   if (!(trojanscan_database_query("SELECT id FROM users LIMIT 1"))) {
1017     trojanscan_database_res *res;
1018     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
1019       if (trojanscan_database_num_rows(res) == 0)
1020         level = TROJANSCAN_ACL_DEVELOPER | TROJANSCAN_ACL_STAFF | TROJANSCAN_ACL_WEBSITE | TROJANSCAN_ACL_CAT;
1021       trojanscan_database_free_result(res);
1022     }
1023   }
1024
1025   trojanscan_database_escape_string(eaccount, toadd->authname, strlen(toadd->authname));
1026   trojanscan_database_query("INSERT INTO users (authname, authlevel) VALUES ('%s', %d)", eaccount, level);
1027   trojanscan_reply(np, "Account added to database, account %s%s.", toadd->authname, level>0?" (first user so developer access)":"");
1028
1029   return CMD_OK;
1030 }
1031
1032 int trojanscan_user_level_by_authname(char *authname) {
1033   int result = -1, sl = strlen(authname);
1034   char eaccount[TROJANSCAN_QUERY_TEMP_BUF_SIZE];
1035
1036   trojanscan_database_escape_string(eaccount, authname, sl);
1037   if (!(trojanscan_database_query("SELECT authlevel, authname FROM users WHERE authname = '%s'", eaccount))) {
1038     trojanscan_database_res *res;
1039     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
1040       if (trojanscan_database_num_rows(res) > 0) {
1041         trojanscan_database_row sqlrow = trojanscan_database_fetch_row(res);
1042         result = atoi(sqlrow[0]);
1043         strlcpy(authname, sqlrow[1], sl + 1);
1044       }
1045       trojanscan_database_free_result(res);
1046     }
1047   }
1048   return result;
1049 }
1050
1051 int trojanscan_user_id_by_authname(char *authname) {
1052   int result = 0;
1053   char eaccount[TROJANSCAN_QUERY_TEMP_BUF_SIZE];
1054
1055   trojanscan_database_escape_string(eaccount, authname, strlen(authname));
1056   if (!(trojanscan_database_query("SELECT id FROM users WHERE authname = '%s'", eaccount))) {
1057     trojanscan_database_res *res;
1058     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
1059       if (trojanscan_database_num_rows(res) > 0) {
1060         trojanscan_database_row sqlrow = trojanscan_database_fetch_row(res);
1061         result = atoi(sqlrow[0]);
1062       }
1063       trojanscan_database_free_result(res);
1064     }
1065   }
1066   return result;
1067 }
1068
1069 struct trojanscan_clones *trojanscan_selectclone(char type) {
1070   struct trojanscan_clones *rc;
1071   int randomclone, hits = 0, minlimit, maxlimit;
1072
1073   if(type == TROJANSCAN_WATCH_CLONES) {
1074     minlimit = TROJANSCAN_CLONE_MAX;
1075     maxlimit = minlimit + TROJANSCAN_WATCHCLONE_MAX - 1;
1076   } else {
1077     minlimit = 0;
1078     maxlimit = TROJANSCAN_CLONE_MAX - 1;
1079   }
1080
1081   do {
1082     randomclone = trojanscan_minmaxrand(minlimit, maxlimit);
1083     if (hits++ > 200)
1084       return NULL;
1085     rc = &trojanscan_swarm[randomclone];
1086     if ((type == TROJANSCAN_NORMAL_CLONES) && (rc->sitting == 0) && (rc->remaining == 0))
1087       break;
1088
1089   } while (rc->remaining == 0);
1090
1091   if(type == TROJANSCAN_NORMAL_CLONES) {
1092     if ((rc->sitting == 0) && (rc->remaining == 0)) {
1093       if ((!rc->remaining) && (!rc->sitting)) {
1094         if (rc->clone) {
1095           deregisterlocaluser(rc->clone, NULL);
1096           derefnode(iptree, rc->fakeipnode);
1097           rc->clone = NULL;
1098         }
1099         trojanscan_generateclone((void *)((long)rc->index));
1100       }
1101     }
1102   }
1103
1104   return rc;
1105
1106 }
1107
1108 /* hack hack hack */
1109 int trojanscan_nickbanned(trojanscan_clones *np, channel *cp) {
1110   int ret;
1111   patricia_node_t *realipnode = np->clone->ipnode;
1112
1113   np->clone->ipnode = np->fakeipnode;
1114
1115   ret = nickbanned(np->clone, cp, 0);
1116
1117   np->clone->ipnode = realipnode;
1118
1119   return ret;
1120 }
1121
1122 struct trojanscan_realchannels *trojanscan_allocaterc(char *chan) {
1123   struct trojanscan_realchannels *rc;
1124   struct trojanscan_clones *clonep;
1125   channel *cp;
1126   int attempts_left = 10;
1127
1128   if (!chan) {
1129     trojanscan_errorcode = 1; /* sorry splidge ;( */
1130     return NULL;
1131   }
1132
1133   if(chan[0] != '#') {
1134     trojanscan_errorcode = 2;
1135     return NULL;
1136   }
1137
1138   if (strlen(chan) > 1) {
1139     if(strrchr(chan, ',')) {
1140       trojanscan_errorcode = 3;
1141       return NULL;
1142     }
1143
1144     if(strrchr(chan, ' ')) {
1145       trojanscan_errorcode = 4;
1146       return NULL;
1147     }
1148   }
1149
1150   cp = findchannel(chan);
1151   if (!cp) {
1152     trojanscan_errorcode = 5;
1153     return NULL;
1154   }
1155
1156   do {
1157     clonep = trojanscan_selectclone(TROJANSCAN_NORMAL_CLONES);
1158     if (!clonep) {
1159       trojanscan_errorcode = 6;
1160       return NULL;
1161     }
1162     if(!trojanscan_nickbanned(clonep, cp))
1163       break;
1164   } while (--attempts_left > 0);
1165
1166   if (!attempts_left) {
1167     trojanscan_errorcode = 7;
1168     return NULL;
1169   }
1170
1171   rc = (struct trojanscan_realchannels *)tmalloc(sizeof(struct trojanscan_realchannels));
1172
1173   rc->next = NULL;
1174   rc->clone = clonep;
1175   rc->chan = cp;
1176   rc->donotpart = 0;
1177   rc->kickedout = 0;
1178   return rc;
1179 }
1180
1181 void trojanscan_join(struct trojanscan_realchannels *rc) {
1182   struct trojanscan_realchannels *rp = trojanscan_realchanlist;
1183
1184   if (rc->clone && rc->clone->clone) {
1185     if (!localjoinchannel(rc->clone->clone, rc->chan)) {
1186       rc->clone->remaining--;
1187       rc->clone->sitting++;
1188       if (trojanscan_minmaxrand(1, TROJANSCAN_NICKCHANGE_ODDS)%TROJANSCAN_NICKCHANGE_ODDS == 0)
1189         trojanscan_donickchange((void *)rc->clone);
1190
1191       rc->schedule = scheduleoneshot(time(NULL)+trojanscan_part_time, &trojanscan_dopart, (void *)rc);
1192
1193       if (rp) {
1194         for(;rp->next;rp=rp->next);
1195         rp->next = rc;
1196       } else {
1197         trojanscan_realchanlist = rc;
1198       }
1199     }
1200   }
1201
1202 }
1203
1204 int trojanscan_userjoin(void *sender, int cargc, char **cargv) {
1205   nick *np = (nick *)sender;
1206   struct trojanscan_realchannels *rc;
1207
1208   if (cargc < 1) {
1209     trojanscan_reply(np, "Not enough paramaters");
1210     return CMD_ERROR;
1211   }
1212
1213   if (!trojanscan_swarm_created) {
1214     trojanscan_reply(np, "My swarm is currently empty.");
1215     return CMD_OK;
1216   }
1217
1218   if((rc = trojanscan_allocaterc(cargv[0]))) {
1219     trojanscan_log(np, "join", cargv[0]);
1220     trojanscan_join(rc);
1221     trojanscan_reply(np, "Clone has joined channel.");
1222     if(!IsOper(np))
1223       trojanscan_mainchanmsg("n: join: %s (%s/%s)", cargv[0], np->nick, np->authname);
1224   } else {
1225     if (trojanscan_errorcode == 5) {
1226       trojanscan_reply(np, "Not joining empty channel, check you entered the correct channel name.");
1227     } else {
1228       trojanscan_reply(np, "Clone could not join channel (error code %d)!", trojanscan_errorcode);
1229     }
1230   }
1231   return CMD_OK;
1232 }
1233
1234 int trojanscan_rehash(void *sender, int cargc, char **cargv) {
1235   nick *np = (void *)sender;
1236   trojanscan_refresh_settings();
1237   trojanscan_read_database(0);
1238   trojanscan_log(np, "rehash", "");
1239   trojanscan_reply(np, "Done.");
1240   return CMD_OK;
1241 }
1242
1243 int trojanscan_changelev(void *sender, int cargc, char **cargv) {
1244   nick *np = (nick *)sender, *np2;
1245   int templevel;
1246   char eaccount[TROJANSCAN_QUERY_TEMP_BUF_SIZE], *tochange, *p, mode = 1, error = 0, clast = 0, specialcase;
1247   union trojanscan_userlevel flags1, flags2;
1248
1249   if (cargc < 2) {
1250     trojanscan_reply(np, "Not enough parameters.");
1251     return CMD_ERROR;
1252   }
1253
1254   templevel = trojanscan_user_level_by_authname(np->authname);
1255
1256   if (templevel == -1) {
1257     trojanscan_reply(np, "You do not have an account.");
1258     return CMD_ERROR;
1259   }
1260
1261   flags1.number = templevel;
1262
1263   if (cargv[0][0] == '#') {
1264     tochange = cargv[0] + 1;
1265   } else {
1266     np2 = getnickbynick(cargv[0]);
1267     if (!np2) {
1268       trojanscan_reply(np, "That nickname is not on the network.");
1269       return CMD_ERROR;
1270     }
1271     if (!IsAccount(np2)) {
1272       trojanscan_reply(np, "That user is not authed with the network.");
1273       return CMD_ERROR;
1274     }
1275     tochange = np2->authname;
1276   }
1277
1278   templevel = trojanscan_user_level_by_authname(tochange);
1279
1280   if (templevel == -1) {
1281     trojanscan_reply(np, "User does not exist.");
1282     return CMD_ERROR;
1283   }
1284
1285   flags2.number = templevel;
1286
1287   if (!ircd_strcmp(np->authname, tochange)) {
1288     specialcase = 1;
1289   } else {
1290     specialcase = 0;
1291   }
1292
1293   for (p=cargv[1];*p;p++) {
1294     switch (*p) {
1295       case '+':
1296       case '-':
1297         mode = (*p == '+');
1298         break;
1299       case 'd':
1300         if (!TrojanscanIsDeveloper(flags1))
1301           clast = 1;
1302         flags2.values.developer = mode;
1303         break;
1304       case 't':
1305         if (!TrojanscanIsDeveloper(flags1))
1306           clast = 1;
1307         flags2.values.teamleader = mode;
1308         break;
1309       case 's':
1310         if (!TrojanscanIsLeastTeamLeader(flags1))
1311           clast = 1;
1312         flags2.values.staff = mode;
1313         break;
1314       case 'w':
1315         if (!TrojanscanIsDeveloper(flags1))
1316           clast = 1;
1317         flags2.values.website = mode;
1318         break;
1319       case 'c':
1320         if (!TrojanscanIsDeveloper(flags1))
1321           clast = 1;
1322         flags2.values.cat = mode;
1323         break;
1324       default:
1325         error = 1;
1326         goto last;
1327         break;
1328     }
1329     if (clast == 1) {
1330       if (specialcase && !mode) { /* allow user to remove their own flags */
1331         clast = 0;
1332       } else {
1333         goto last;
1334       }
1335     }
1336   }
1337
1338   last:
1339   if (*p) {
1340     if (error) {
1341       trojanscan_reply(np, "Unknown mode: %c%c.", mode?'+':'-', *p);
1342     } else {
1343       trojanscan_reply(np, "You have insufficient privilidges to add/remove one or more flags specified.");
1344     }
1345     return CMD_ERROR;
1346   }
1347
1348   trojanscan_log(np, "changelev", "%s %s", tochange, cargv[1]);
1349   trojanscan_database_escape_string(eaccount, tochange, strlen(tochange));
1350   trojanscan_database_query("UPDATE users SET authlevel = %d WHERE authname = '%s'", flags2.number, eaccount);
1351
1352   trojanscan_reply(np, "Flags changed.");
1353
1354   return CMD_OK;
1355 }
1356
1357 int trojanscan_deluser(void *sender, int cargc, char **cargv) {
1358   nick *np = (nick *)sender, *to;
1359   int templevel;
1360   char eaccount[TROJANSCAN_QUERY_TEMP_BUF_SIZE], *account;
1361   union trojanscan_userlevel flags1, flags2;
1362
1363   if (cargc < 1) {
1364     trojanscan_reply(np, "Not enough parameters.");
1365     return CMD_ERROR;
1366   }
1367
1368   if (cargv[0][0] == '#') {
1369     account = cargv[0] + 1;
1370   } else {
1371     to = getnickbynick(cargv[0]);
1372     if (!to) {
1373       trojanscan_reply(np, "That nickname is not on the network.");
1374       return CMD_ERROR;
1375     }
1376     if (!IsAccount(to)) {
1377       trojanscan_reply(np, "That user is not authed with the network.");
1378       return CMD_ERROR;
1379     }
1380     account = to->authname;
1381   }
1382
1383   flags1.number = trojanscan_user_level_by_authname(np->authname);
1384   templevel = trojanscan_user_level_by_authname(account);
1385
1386   if (templevel == -1) {
1387     trojanscan_reply(np, "Auth %s does not exist.", account);
1388     return CMD_ERROR;
1389   }
1390
1391   flags2.number = templevel;
1392
1393   if (!TrojanscanIsDeveloper(flags1) && TrojanscanIsLeastTeamLeader(flags2)) {
1394       trojanscan_reply(np, "Your cannot delete %s as his/her flags equal or surpass your own.", account);
1395       return CMD_ERROR;
1396   }
1397
1398   trojanscan_log(np, "deluser", account);
1399   trojanscan_database_escape_string(eaccount, account, strlen(account));
1400   trojanscan_database_query("DELETE FROM users WHERE authname = '%s'", eaccount);
1401   trojanscan_reply(np, "User deleted.");
1402
1403   return CMD_OK;
1404 }
1405
1406 int trojanscan_add_ll(struct trojanscan_prechannels **head, struct trojanscan_prechannels *newitem) {
1407   struct trojanscan_prechannels *position, *lastitem = NULL, *location = NULL;
1408   if (!*head) {
1409     *head = newitem;
1410     newitem->next = NULL;
1411     if (newitem->exempt) {
1412       return 0;
1413     } else {
1414       return 1;
1415     }
1416   }
1417   /* if its exempt, we don't give a monkeys where it is... */
1418   if (newitem->exempt) {
1419     newitem->next = *head;
1420     *head = newitem;
1421     return 0;
1422   }
1423
1424   for(position=*head;position;lastitem=position,position=position->next) {
1425     if (!ircd_strcmp(position->name->content, newitem->name->content)) {
1426       tfree(newitem);
1427       return 0;
1428     }
1429     if (!location && (position->size < newitem->size)) {
1430       if (!lastitem) {
1431         location = *head;
1432       } else {
1433         location = lastitem;
1434       }
1435     }
1436   }
1437   if (!location) {
1438     newitem->next = NULL;
1439     lastitem->next = newitem;
1440   } else {
1441     newitem->next = location->next;
1442     location->next = newitem;
1443   }
1444   if(newitem->exempt) {
1445     return 0;
1446   } else {
1447     return 1;
1448   }
1449 }
1450
1451 void trojanscan_watch_clone_update(struct trojanscan_prechannels *hp, int count) {
1452   int i, j, marked;
1453   struct trojanscan_prechannels *lp;
1454   struct trojanscan_templist *markedlist = NULL;
1455
1456   if(count > 0) {
1457     markedlist = (struct trojanscan_templist *)tmalloc(count * sizeof(struct trojanscan_templist));
1458     if (!markedlist)
1459       return;
1460     memset(markedlist, 0, sizeof(struct trojanscan_templist) * count);
1461   }
1462
1463   for(i=0;i<trojanscan_activechans;i++) {
1464     marked = 0;
1465     if(markedlist) {
1466       for(lp=hp,j=0;j<count&&lp;j++,lp=lp->next) {
1467         if(!markedlist[j].active && !lp->exempt && !ircd_strcmp(lp->name->content, trojanscan_chans[i].channel->content)) { /* we're already on the channel */
1468           if(trojanscan_chans[i].watch_clone) {
1469             markedlist[j].active = 1;
1470             markedlist[j].watch_clone = trojanscan_chans[i].watch_clone;
1471             lp->watch_clone = trojanscan_chans[i].watch_clone;
1472           }
1473           marked = 1;
1474           break;
1475         }
1476       }
1477     }
1478     if(!marked && trojanscan_chans[i].watch_clone) {
1479       channel *cp = findchannel(trojanscan_chans[i].channel->content);
1480       if(cp)
1481         localpartchannel(trojanscan_chans[i].watch_clone->clone, cp, NULL);
1482     }
1483   }
1484
1485   if(!markedlist)
1486     return;
1487
1488   for(j=0,lp=hp;j<count&&lp;j++,lp=lp->next) {
1489     if((!markedlist[j].active || !markedlist[j].watch_clone) && !lp->exempt) {
1490       channel *cp = findchannel(lp->name->content);
1491       if(cp) {
1492         int attempts = 10;
1493         do {
1494           lp->watch_clone = trojanscan_selectclone(TROJANSCAN_WATCH_CLONES);
1495           if(!lp->watch_clone)
1496             break;
1497           if(!trojanscan_nickbanned(lp->watch_clone, cp)) {
1498             if(localjoinchannel(lp->watch_clone->clone, cp))
1499               lp->watch_clone = NULL;
1500             break;
1501           }
1502         } while(--attempts > 0);
1503         if(!attempts)
1504           lp->watch_clone = NULL;
1505
1506       }
1507     }
1508   }
1509
1510   tfree(markedlist);
1511 }
1512
1513 void trojanscan_fill_channels(void *arg) {
1514   struct trojanscan_prechannels *head = NULL, *lp, *last = NULL;
1515   int i, count, tempctime = 0;
1516
1517   chanindex *chn;
1518
1519   for (count=i=0;i<trojanscan_database.total_channels;i++) {
1520     lp = (trojanscan_prechannels *)tmalloc(sizeof(trojanscan_prechannels));
1521     lp->name = trojanscan_database.channels[i].name;
1522     lp->size = 65535;
1523     lp->exempt = trojanscan_database.channels[i].exempt;
1524     lp->watch_clone = NULL;
1525     if (trojanscan_add_ll(&head, lp))
1526       count++;
1527   }
1528
1529   for (i=0;i<CHANNELHASHSIZE;i++) {
1530     for(chn=chantable[i];chn;chn=chn->next) {
1531       if (chn->channel && !IsKey(chn->channel) && !IsInviteOnly(chn->channel) && !IsRegOnly(chn->channel) && (chn->channel->users->totalusers >= trojanscan_minchansize)) {
1532         lp = (trojanscan_prechannels *)tmalloc(sizeof(trojanscan_prechannels));
1533         lp->name = chn->name;
1534         lp->size = chn->channel->users->totalusers;
1535         lp->exempt = 0;
1536         lp->watch_clone = NULL;
1537         if (trojanscan_add_ll(&head, lp))
1538           count++;
1539       }
1540     }
1541   }
1542
1543   count = TROJANSCAN_MMIN(count, trojanscan_maxchans);
1544
1545   trojanscan_watch_clone_update(head, count);
1546
1547   trojanscan_free_channels();
1548   trojanscan_chans = (struct trojanscan_inchannel *)tmalloc(count * sizeof(struct trojanscan_inchannel));
1549   memset(trojanscan_chans, 0, count * sizeof(struct trojanscan_inchannel));
1550   trojanscan_activechans = count;
1551   i = 0;
1552
1553   for(lp=head;lp;last=lp,lp=lp->next) {
1554     if (!(lp->exempt) && (i < count)) {
1555       trojanscan_chans[i].channel = getsstring(lp->name->content, lp->name->length);
1556       trojanscan_chans[i++].watch_clone = lp->watch_clone;
1557     }
1558     if (last)
1559       tfree(last);
1560   }
1561
1562   if (last)
1563     tfree(last);
1564
1565   if (trojanscan_activechans > 0) {
1566     tempctime = trojanscan_cycletime / trojanscan_activechans;
1567   } else {
1568     tempctime = 60;
1569     trojanscan_mainchanmsg("d: just escaped a divide by zero error (no activechans!), rescheduling in 60 seconds");
1570   }
1571
1572   if(trojanscan_schedule)
1573     deleteschedule(trojanscan_schedule, &trojanscan_dojoin, NULL);
1574
1575   trojanscan_channumber = 0;
1576
1577   trojanscan_schedule = schedulerecurring(time(NULL) + tempctime, trojanscan_activechans + 1, tempctime, trojanscan_dojoin, NULL);
1578
1579 }
1580
1581 void trojanscan_dojoin(void *arg) {
1582   struct trojanscan_realchannels *rc;
1583   if (trojanscan_channumber >= trojanscan_activechans) {
1584     trojanscan_schedule = NULL;
1585     trojanscan_fill_channels(NULL);
1586   } else {
1587     if ((rc = trojanscan_allocaterc(trojanscan_chans[trojanscan_channumber++].channel->content)))
1588       trojanscan_join(rc);
1589   }
1590 }
1591
1592
1593 void trojanscan_dopart(void *arg) {
1594   struct trojanscan_realchannels *rc = (struct trojanscan_realchannels *)arg, *rp, *past = NULL;
1595
1596   if (rc->kickedout) { /* there's a join scheduled, wait for it (reschedule) */
1597     rc->schedule = scheduleoneshot(time(NULL)+5, &trojanscan_dopart, (void *)rc);
1598     return;
1599   }
1600
1601   if (rc->clone->clone && (!(rc->donotpart)))
1602     localpartchannel(rc->clone->clone, rc->chan, NULL);
1603
1604   rc->clone->sitting--;
1605
1606   for(rp=trojanscan_realchanlist;rp;rp=rp->next) {
1607     if (rp == rc) {
1608       if (!past) {
1609         trojanscan_realchanlist = rp->next;
1610       } else {
1611         past->next = rp->next;
1612       }
1613       tfree(rp);
1614       break;
1615     }
1616     past = rp;
1617   }
1618
1619 }
1620
1621 void trojanscan_donickchange(void *arg) { /* just incase I choose to make this schedule at some point */
1622   struct trojanscan_clones *clone = (trojanscan_clones *)arg;
1623   if (clone && clone->clone) {
1624     char c_nick[NICKLEN+1];
1625     int loops = 0;
1626     /* PPA: unlikely to be infinite */
1627     do {
1628       if ((loops++ < 10) && trojanscan_hostmode) {
1629         trojanscan_generatenick(c_nick, NICKLEN);
1630       } else {
1631         trojanscan_gennick(c_nick, trojanscan_minmaxrand(7, TROJANSCAN_MMIN(13, NICKLEN)));
1632       }
1633     } while (c_nick[0] && (getnickbynick(c_nick) != NULL));
1634
1635     renamelocaluser(clone->clone, c_nick);
1636   }
1637
1638 }
1639
1640 int trojanscan_keysort(const void *v1, const void *v2) {
1641   return ((*(trojanscan_prechannels **)v2)->size - (*(trojanscan_prechannels **)v1)->size);
1642 }
1643
1644 int trojanscan_showcommands(void *sender, int cargc, char **cargv) {
1645   nick *np = (nick *)sender;
1646   Command *cmdlist[100];
1647   int i, n;
1648   char level = 0;
1649
1650   n = getcommandlist(trojanscan_cmds, cmdlist, 100);
1651
1652   trojanscan_reply(np, "The following commands are registered at present:");
1653
1654   for(i=0;i<n;i++) {
1655     if (cmdlist[i]->level & TROJANSCAN_ACL_STAFF) {
1656       level = 's';
1657     } else if (cmdlist[i]->level & TROJANSCAN_ACL_DEVELOPER) {
1658       level = 'd';
1659     } else if (cmdlist[i]->level & TROJANSCAN_ACL_TEAMLEADER) {
1660       level = 't';
1661     } else if (cmdlist[i]->level & TROJANSCAN_ACL_CAT) {
1662       level = 'c';
1663     } else if (cmdlist[i]->level & TROJANSCAN_ACL_WEBSITE) {
1664       level = 'w';
1665     } else if (cmdlist[i]->level & TROJANSCAN_ACL_UNAUTHED) {
1666       level = 0;
1667     }
1668     if (level) {
1669       trojanscan_reply(np, "%s (+%c)", cmdlist[i]->command->content, level);
1670     } else {
1671       trojanscan_reply(np, "%s", cmdlist[i]->command->content);
1672     }
1673   }
1674   trojanscan_reply(np, "End of list.");
1675   return CMD_OK;
1676 }
1677
1678 void trojanscan_handlemessages(nick *target, int messagetype, void **args) {
1679   Command *cmd;
1680   char *cargv[50];
1681   int cargc, templevel;
1682   nick *sender;
1683   union trojanscan_userlevel level;
1684
1685   switch(messagetype) {
1686     case LU_PRIVMSG:
1687     case LU_SECUREMSG:
1688       /* If it's a message, first arg is nick and second is message */
1689       sender = (nick *)args[0];
1690
1691       if(strncmp(TROJANSCAN_VERSION_DETECT, args[1], sizeof(TROJANSCAN_VERSION_DETECT)-1)==0) {
1692         char p = ((char *)args[1])[sizeof(TROJANSCAN_VERSION_DETECT)-1];
1693         if((p == ' ') || (p == '\0') || (p == 1)) {
1694           trojanscan_reply(sender, "\001VERSION Trojanscan (or Tigger) Newserv module version %s by Chris Porter (slug), Newserv by David Mansell (splidge). Compiled " __DATE__ " " __TIME__ ".\001", TROJANSCAN_VERSION);
1695           return;
1696         }
1697       }
1698
1699       /* Split the line into params */
1700       cargc = splitline((char *)args[1], cargv, 50, 0);
1701       if(cargc == 0 || !cargv[0])
1702         return;
1703
1704       cmd=findcommandintree(trojanscan_cmds, cargv[0], 1);
1705       if (!cmd) {
1706         trojanscan_reply(sender, "Unknown command.");
1707         return;
1708       }
1709
1710       if ((cmd->level & TROJANSCAN_ACL_OPER) && !IsOper(sender)) {
1711         trojanscan_reply(sender, "You need to be opered to use this command.");
1712         return;
1713       }
1714
1715       /* bit grim code... */
1716
1717       if (!(cmd->level & TROJANSCAN_ACL_UNAUTHED)) {
1718         if (!IsAccount(sender)) {
1719           trojanscan_reply(sender, "You must be authed with the network to access this command!");
1720           return;
1721         }
1722         templevel = trojanscan_user_level_by_authname(sender->authname);
1723
1724         if (templevel == -1) {
1725           trojanscan_reply(sender, "You do not have an account.");
1726           return;
1727         }
1728
1729         level.number = templevel;
1730
1731         if ((cmd->level & TROJANSCAN_ACL_DEVELOPER) && !TrojanscanIsDeveloper(level)) {
1732           trojanscan_reply(sender, "Access denied.");
1733           return;
1734         }
1735         if ((cmd->level & TROJANSCAN_ACL_TEAMLEADER) && !TrojanscanIsLeastTeamLeader(level)) {
1736           trojanscan_reply(sender, "Access denied.");
1737           return;
1738         }
1739         if ((cmd->level & TROJANSCAN_ACL_STAFF) && !TrojanscanIsLeastStaff(level)) {
1740           trojanscan_reply(sender, "Access denied.");
1741           return;
1742         }
1743         if ((cmd->level & TROJANSCAN_ACL_CAT) && !TrojanscanIsCat(level)) {
1744           trojanscan_reply(sender, "Access denied.");
1745           return;
1746         }
1747         if ((cmd->level & TROJANSCAN_ACL_WEBSITE) && !TrojanscanIsLeastWebsite(level)) {
1748           trojanscan_reply(sender, "Access denied.");
1749           return;
1750         }
1751       }
1752
1753       /* Check the maxargs */
1754       if (cmd->maxparams<(cargc-1)) {
1755         /* We need to do some rejoining */
1756         rejoinline(cargv[cmd->maxparams], cargc-(cmd->maxparams));
1757         cargc = (cmd->maxparams) + 1;
1758       }
1759
1760       (cmd->handler)((void *)sender, cargc - 1, &(cargv[1]));
1761       break;
1762
1763     case LU_KILLED:
1764       /* someone killed me?  Bastards */
1765       trojanscan_connect_nick_schedule = scheduleoneshot(time(NULL) + 1, &trojanscan_connect_nick, NULL);
1766       trojanscan_nick = NULL;
1767       break;
1768
1769     default:
1770       break;
1771   }
1772 }
1773
1774 static char trojanscan_getmtfromhooktype(int input) {
1775   switch(input) {
1776     case HOOK_CHANNEL_PART: return 'P';
1777     default:                return '?';
1778   }
1779 }
1780
1781 char trojanscan_getmtfrommessagetype(int input) {
1782   switch(input) {
1783     case LU_PRIVMSG:    return 'm';
1784     case LU_PRIVNOTICE: return 'n';
1785     case LU_SECUREMSG:  return 's';
1786     case LU_CHANMSG:    return 'M';
1787     case LU_CHANNOTICE: return 'N';
1788     default:            return '?';
1789   }
1790 }
1791
1792 static void trojanscan_process(nick *sender, channel *cp, char mt, char *pretext) {
1793   char text[513];
1794   unsigned int len;
1795   unsigned int i;
1796   struct trojanscan_worms *worm;
1797   int vector[30], detected = 0;
1798
1799   trojanscan_strip_codes(text, sizeof(text) - 1, pretext);
1800
1801   len = strlen(text);
1802
1803   for(i=0;i<trojanscan_database.total_phrases;i++) {
1804     if (
1805          (
1806            (worm = trojanscan_database.phrases[i].worm)
1807          ) &&
1808          (
1809            (
1810              (
1811                (mt == 'm') || (mt == 's') || (mt == 'n')
1812              ) &&
1813              (
1814                (trojanscan_database.phrases[i].worm->hitpriv)
1815              )
1816            ) ||
1817            (
1818              (
1819                (mt == 'M') || (mt == 'N') || (mt == 'P')
1820              ) &&
1821              (
1822                (trojanscan_database.phrases[i].worm->hitchans)
1823              )
1824            )
1825          ) &&
1826          (trojanscan_database.phrases[i].phrase)
1827        ) {
1828       int pre = pcre_exec(trojanscan_database.phrases[i].phrase, trojanscan_database.phrases[i].hint, text, len, 0, 0, vector, 30);
1829       if(pre >= 0) {
1830         char matchbuf[513];
1831         matchbuf[0] = 0;
1832         matchbuf[512] = 0; /* hmm */
1833
1834         if(pre > 1)
1835           if(pcre_copy_substring(text, vector, pre, 1, matchbuf, sizeof(matchbuf) - 1) <= 0)
1836             matchbuf[0] = 0;
1837
1838         trojanscan_phrasematch(cp, sender, &trojanscan_database.phrases[i], mt, matchbuf);
1839
1840         detected = 1;
1841         break;
1842       }
1843     }
1844   }
1845   if (!detected && (mt != 'N') && (mt != 'M')) {
1846     char etext[TROJANSCAN_QUERY_TEMP_BUF_SIZE], enick[TROJANSCAN_QUERY_TEMP_BUF_SIZE], eident[TROJANSCAN_QUERY_TEMP_BUF_SIZE], ehost[TROJANSCAN_QUERY_TEMP_BUF_SIZE];
1847     trojanscan_database_escape_string(etext, text, len);
1848     trojanscan_database_escape_string(enick, sender->nick, strlen(sender->nick));
1849     trojanscan_database_escape_string(eident, sender->ident, strlen(sender->ident));
1850     trojanscan_database_escape_string(ehost, sender->host->name->content, sender->host->name->length);
1851     trojanscan_database_query("INSERT INTO unknownlog (data, user) VALUES ('%s','%s!%s@%s')", etext, enick, eident, ehost);
1852   }
1853 }
1854
1855 void trojanscan_clonehandlemessages(nick *target, int messagetype, void **args) {
1856   char *pretext = NULL;
1857   nick *sender;
1858   struct trojanscan_realchannels *rp;
1859   struct trojanscan_rejoinlist *rj;
1860   char mt = trojanscan_getmtfrommessagetype(messagetype);
1861   char *channel_name;
1862   channel *cp = NULL;
1863   int i;
1864
1865   switch(messagetype) {
1866     case LU_PRIVMSG:
1867     case LU_SECUREMSG:
1868     case LU_PRIVNOTICE:
1869
1870     pretext = (char *)args[1];
1871
1872     case LU_CHANMSG:
1873     case LU_CHANNOTICE:
1874       sender = (nick *)args[0];
1875
1876       if (strlen(sender->nick) < 2)
1877         break;
1878
1879       if (!pretext) {
1880         pretext = (char *)args[2];
1881         cp = args[1];
1882       }
1883
1884       if(strncmp(TROJANSCAN_VERSION_DETECT, pretext, sizeof(TROJANSCAN_VERSION_DETECT)-1)==0) {
1885         char p = pretext[sizeof(TROJANSCAN_VERSION_DETECT)-1];
1886         if((p == ' ') || (p == '\0') || (p == 1)) {
1887           int staff = 0;
1888           if (IsOper(sender)) {
1889             staff = 1;
1890           } else {
1891             if (IsAccount(sender)) {
1892               int templevel = trojanscan_user_level_by_authname(sender->authname);
1893               if (templevel != -1) {
1894                 union trojanscan_userlevel level;
1895                 level.number = templevel;
1896                 if (TrojanscanIsLeastStaff(level))
1897                   staff = 1;
1898               }
1899             }
1900           }
1901           if (staff) {
1902             if(trojanscan_nick) {
1903               sendnoticetouser(target, sender, "\001VERSION T clone, check T for confirmation.\001");
1904               sendnoticetouser(trojanscan_nick, sender, "\001VERSION %s is part of my swarm.\001", target->nick);
1905             } else {
1906               sendnoticetouser(target, sender, "\001VERSION T clone, though since T is currently gone you'll have to version me again in a minute for confirmation.\001");
1907             }
1908           } else {
1909             sendnoticetouser(target, sender,  "\001VERSION %s\001", versionreply);
1910           }
1911
1912           return;
1913         }
1914       }
1915
1916       trojanscan_process(sender, cp, mt, pretext);
1917       break;
1918     case LU_KILLED:
1919       /* someone killed me?  Bastards */
1920
1921       /* PPA: we do NOT rejoin channels at this moment in time, it is possible to do this though */
1922       for (i=0;i<TROJANSCAN_CLONE_TOTAL;i++) {
1923         if (trojanscan_swarm[i].clone == target) {
1924
1925           scheduleoneshot(time(NULL)+1, &trojanscan_generateclone, (void *)((long)i));
1926           if(i >= TROJANSCAN_CLONE_MAX) {
1927             int j;
1928             for(j=0;j<trojanscan_activechans;j++)
1929               if(trojanscan_chans[j].watch_clone == &trojanscan_swarm[i])
1930                 trojanscan_chans[j].watch_clone = NULL;
1931           } else {
1932             for(rp=trojanscan_realchanlist;rp;rp=rp->next)
1933               if (rp->clone == &(trojanscan_swarm[i]))
1934                 rp->donotpart = 1;
1935           }
1936           derefnode(iptree, trojanscan_swarm[i].fakeipnode);
1937           trojanscan_swarm[i].clone = NULL;
1938           trojanscan_swarm[i].remaining = 0; /* bah */
1939           break;
1940         }
1941       }
1942       break;
1943
1944     case LU_KICKED:
1945       channel_name = ((channel *)args[1])->index->name->content;
1946       for (i=0;i<trojanscan_activechans;i++) {
1947         if (!trojanscan_chans[i].watch_clone)
1948           continue;
1949         if ((trojanscan_chans[i].watch_clone->clone == target) && (!strcmp(trojanscan_chans[i].channel->content, channel_name)))
1950           break;
1951       }
1952       if(i != trojanscan_activechans) {
1953         int j;
1954         for(j=0;j<TROJANSCAN_CLONE_TOTAL;j++) {
1955           if(&trojanscan_swarm[j] == trojanscan_chans[i].watch_clone) {
1956             trojanscan_chans[i].watch_clone = NULL;
1957             break;
1958           }
1959         }
1960       } else {
1961       /*
1962         trojanscan_mainchanmsg("k: %s on %s by %s", target->nick, ((channel *)args[1])->index->name->content, (((nick *)args[0])->nick)?(((nick *)args[0])->nick):"(server)");
1963       */
1964         rj = (struct trojanscan_rejoinlist *)tmalloc(sizeof(struct trojanscan_rejoinlist));
1965         if (rj) {
1966           rj->rp = NULL;
1967           for(rp=trojanscan_realchanlist;rp;rp=rp->next)
1968                if ((rp->clone->clone == target) && (rp->chan == args[1])) {
1969                 rp->kickedout++;
1970                 rj->rp = rp;
1971                 break;
1972               }
1973             if(!rj->rp) {
1974               tfree(rj);
1975               return;
1976             }
1977
1978             rj->channel = getsstring(((channel *)args[1])->index->name->content, ((channel *)args[1])->index->name->length);
1979             if(!rj->channel) {
1980               trojanscan_mainchanmsg("d: unable to allocate memory for channel: %s upon rejoin", ((channel *)args[1])->index->name->content);
1981               tfree(rj);
1982               return;
1983             }
1984
1985             rj->clone = rp->clone;
1986             rj->next = trojanscan_schedulerejoins;
1987             trojanscan_schedulerejoins = rj;
1988
1989             rj->schedule = scheduleoneshot(time(NULL)+1, &trojanscan_rejoin_channel, (void *)rj);
1990           }
1991         }
1992         break;
1993     default:
1994       break;
1995   }
1996 }
1997
1998 static void trojanscan_part_watch(int hook, void *arg) {
1999   void **arglist = (void **)arg;
2000   channel *cp = (channel *)arglist[0];
2001   nick *np = arglist[1];
2002   char *reason = arglist[2];
2003
2004   if(!cp || !np || !reason || (*reason == '\0'))
2005     return;
2006
2007   trojanscan_process(np, cp, trojanscan_getmtfromhooktype(hook), reason);
2008 }
2009
2010 void trojanscan_phrasematch(channel *chp, nick *sender, trojanscan_phrases *phrase, char messagetype, char *matchbuf) {
2011   char glinemask[HOSTLEN + USERLEN + NICKLEN + 4], enick[TROJANSCAN_QUERY_TEMP_BUF_SIZE], eident[TROJANSCAN_QUERY_TEMP_BUF_SIZE], ehost[TROJANSCAN_QUERY_TEMP_BUF_SIZE];
2012   unsigned int frequency;
2013   int glining = 0, usercount;
2014   struct trojanscan_worms *worm = phrase->worm;
2015   char reason[200];
2016
2017   trojanscan_database.detections++;
2018
2019   usercount = 0;
2020   if (worm->monitor) {
2021     usercount = -1;
2022   } else if(worm->glinehost || worm->glineuser) {
2023     glining = 1;
2024
2025     usercount = glinebynick(sender, 0, NULL, GLINE_SIMULATE, "trojanscan");
2026   }
2027
2028   if (!usercount) {
2029     trojanscan_mainchanmsg("w: user %s!%s@%s triggered infection monitor, yet no hosts found at stage 2 -- worm: %s", sender->nick, sender->ident, sender->host->name->content, worm->name->content);
2030     return;
2031   }
2032
2033   if (glining && (usercount > trojanscan_maxusers)) {
2034     trojanscan_mainchanmsg("w: not glining %s!%s@%s due to too many users (%d) with mask: *!%s -- worm: %s)", sender->nick, sender->ident, sender->host->name->content, usercount, glinemask, worm->name->content);
2035     return;
2036   }
2037
2038   if (glining && !worm->datalen) {
2039     trojanscan_mainchanmsg("w: not glining %s!%s@%s due to too lack of removal data with mask: *!%s (%d users) -- worm: %s)", sender->nick, sender->ident, sender->host->name->content, glinemask, usercount, worm->name->content);
2040     return;
2041   }
2042
2043   trojanscan_database_escape_string(enick, sender->nick, strlen(sender->nick));
2044   trojanscan_database_escape_string(eident, sender->ident, strlen(sender->ident));
2045   trojanscan_database_escape_string(ehost, sender->host->name->content, sender->host->name->length);
2046
2047   frequency = 1;
2048
2049   if (!(trojanscan_database_query("SELECT COUNT(*) FROM hits WHERE glined = %d AND host = '%s'", glining, ehost))) {
2050     trojanscan_database_res *res;
2051     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
2052       trojanscan_database_row sqlrow;
2053       if ((trojanscan_database_num_rows(res) > 0) && (sqlrow = trojanscan_database_fetch_row(res)))
2054         frequency = atoi(sqlrow[0]) + 1;
2055       trojanscan_database_free_result(res);
2056     }
2057   }
2058
2059   if (!glining) {
2060     trojanscan_mainchanmsg("m: t: %c u: %s!%s@%s%s%s w: %s p: %d %s%s", messagetype, sender->nick, sender->ident, sender->host->name->content, messagetype=='N'||messagetype=='M'||messagetype=='P'?" #: ":"", messagetype=='N'||messagetype=='M'||messagetype=='P'?chp->index->name->content:"", worm->name->content, phrase->id, matchbuf[0]?" --: ":"", matchbuf[0]?matchbuf:"");
2061 #ifdef TROJANSCAN_PEONCHANNEL
2062     trojanscan_peonchanmsg("m: t: %c u: %s!%s@%s%s%s%s w: %s %s%s", messagetype, sender->nick, sender->ident, (IsHideHost(sender)&&IsAccount(sender))?sender->authname:sender->host->name->content, (IsHideHost(sender)&&IsAccount(sender))?"."HIS_HIDDENHOST:"", messagetype=='N'||messagetype=='M'||messagetype=='P'?" #: ":"", messagetype=='N'||messagetype=='M'||messagetype=='P'?chp->index->name->content:"", worm->name->content, matchbuf[0]?" --: ":"", matchbuf[0]?matchbuf:"");
2063 #endif
2064   } else {
2065     int glinetime = TROJANSCAN_FIRST_OFFENSE * frequency * (worm->epidemic?TROJANSCAN_EPIDEMIC_MULTIPLIER:1);
2066     if(glinetime > 7 * 24)
2067       glinetime = 7 * 24; /* can't set glines over 7 days with normal non U:lined glines */
2068
2069     trojanscan_database_query("INSERT INTO hits (nickname, ident, host, phrase, messagetype, glined) VALUES ('%s', '%s', '%s', %d, '%c', %d)", enick, eident, ehost, phrase->id, messagetype, glining);
2070     trojanscan_database.glines++;
2071
2072     snprintf(reason, sizeof(reason), "You (%s!%s@%s) are infected with a trojan (%s/%d), see %s%d for details - banned for %d hours", sender->nick, sender->ident, sender->host->name->content, worm->name->content, phrase->id, TROJANSCAN_URL_PREFIX, worm->id, glinetime);
2073     glinebynick(sender, glinetime * 3600, reason, 0, "trojanscan");
2074
2075     trojanscan_mainchanmsg("g: *!%s t: %c u: %s!%s@%s%s%s c: %d w: %s%s p: %d f: %d%s%s", glinemask, messagetype, sender->nick, sender->ident, sender->host->name->content, messagetype=='N'||messagetype=='M'||messagetype=='P'?" #: ":"", messagetype=='N'||messagetype=='M'||messagetype=='P'?chp->index->name->content:"", usercount, worm->name->content, worm->epidemic?"(E)":"", phrase->id, frequency, matchbuf[0]?" --: ":"", matchbuf[0]?matchbuf:"");
2076   }
2077 }
2078
2079 void trojanscan_rejoin_channel(void *arg) {
2080   struct trojanscan_rejoinlist *rj2, *lrj, *rj = (struct trojanscan_rejoinlist *)arg;
2081
2082   channel *cp = findchannel(rj->channel->content);
2083   freesstring(rj->channel);
2084
2085   if (rj->rp) {
2086     rj->rp->kickedout--;
2087     if (!cp) {
2088       rj->rp->donotpart = 1; /* we were the last user on the channel, so we need to be VERY careful freeing it */
2089     } else {
2090       if(!rj->rp->donotpart && !rj->rp->kickedout) { /* check we're allowed to join channels (not killed), and we're the last one to join */
2091         if (trojanscan_nickbanned(rj->clone, cp)) {
2092           rj->rp->donotpart = 1;
2093         } else {
2094           localjoinchannel(rj->clone->clone, cp);
2095         }
2096       }
2097     }
2098   }
2099
2100   rj2 = trojanscan_schedulerejoins;
2101   lrj = NULL;
2102
2103   if (rj2 == rj) {
2104     trojanscan_schedulerejoins = rj->next;
2105     tfree(rj);
2106   } else {
2107     for(rj2=trojanscan_schedulerejoins;rj2;lrj=rj2,rj2=rj2->next) {
2108       if (rj2 == rj) {
2109         lrj->next = rj2->next;
2110         tfree(rj);
2111         break;
2112       }
2113     }
2114   }
2115
2116 }
2117
2118 void trojanscan_reply(nick *target, char *message, ... ) {
2119   char buf[513];
2120   va_list va;
2121
2122   if (!trojanscan_nick)
2123     return;
2124
2125   va_start(va, message);
2126   vsnprintf(buf, sizeof(buf) - 1, message, va);
2127   va_end(va);
2128
2129   sendnoticetouser(trojanscan_nick, target, "%s", buf);
2130 }
2131
2132
2133 void trojanscan_mainchanmsg(char *message, ...) {
2134   char buf[513];
2135   va_list va;
2136   channel *cp;
2137
2138   if (!trojanscan_nick)
2139     return;
2140   if (!(cp = findchannel(TROJANSCAN_CHANNEL)))
2141     return;
2142
2143   va_start(va, message);
2144   vsnprintf(buf, sizeof(buf) - 1, message, va);
2145   va_end(va);
2146
2147   sendmessagetochannel(trojanscan_nick, cp, "%s", buf);
2148 }
2149
2150 #ifdef TROJANSCAN_PEONCHANNEL
2151 void trojanscan_peonchanmsg(char *message, ...) {
2152   char buf[513];
2153   va_list va;
2154   channel *cp;
2155
2156   if (!trojanscan_nick)
2157     return;
2158   if (!(cp = findchannel(TROJANSCAN_PEONCHANNEL)))
2159     return;
2160
2161   va_start(va, message);
2162   vsnprintf(buf, sizeof(buf) - 1, message, va);
2163   va_end(va);
2164
2165   sendmessagetochannel(trojanscan_nick, cp, "%s", buf);
2166 }
2167 #endif
2168
2169 int trojanscan_minmaxrand(float min, float max) {
2170   return (int)((max-min+1)*rand()/(RAND_MAX+min))+min;
2171 }
2172
2173 char *trojanscan_iptostr(char *buf, int buflen, unsigned int ip) {
2174   snprintf(buf, buflen, "%d.%d.%d.%d", ip >> 24, (ip >> 16) & 255, (ip >> 8) & 255, ip & 255);
2175   return buf;
2176 }
2177
2178 char trojanscan_genchar(int ty) {
2179   /* hostname and realname characters*/
2180   if (!ty) {
2181     if (!(trojanscan_minmaxrand(0, 40) % 10)) {
2182       return trojanscan_minmaxrand(48, 57);
2183     } else {
2184       return trojanscan_minmaxrand(97, 122);
2185     }
2186   /* ident characters - without numbers*/
2187   } else if (ty == 1) {
2188     return trojanscan_minmaxrand(97, 122);
2189   /* ident characters - with numbers*/
2190   } else if (ty == 2) {
2191     ty = trojanscan_minmaxrand(97, 125);
2192     if (ty > 122) return trojanscan_minmaxrand(48, 57);
2193     return ty;
2194   /* nick characters - with and without numbers*/
2195   } else if (ty == 3 || ty == 4) {
2196     if (!(trojanscan_minmaxrand(0, 59) % 16)) {
2197       char weirdos[6] = { '\\', '|', '[', '{', ']', '}' };
2198       return weirdos[trojanscan_minmaxrand(0, 5)];
2199     }
2200     if (ty == 4) {
2201       ty = trojanscan_minmaxrand(65, 93);
2202       if (ty > 90) return trojanscan_minmaxrand(48, 57);
2203     } else {
2204       ty = trojanscan_minmaxrand(65, 90);
2205     }
2206     if (!(trojanscan_minmaxrand(0, 40) % 8)) return ty;
2207     return ty + 32;
2208   /* moron check */
2209   } else {
2210     return ' ';
2211   }
2212 }
2213
2214 void trojanscan_gennick(char *ptc, char size) {
2215   int i;
2216   for (i=0;i<size;i++) {
2217     if (i == 0) {
2218       ptc[i] = trojanscan_genchar(3);
2219     } else {
2220       ptc[i] = trojanscan_genchar(4);
2221     }
2222   }
2223   ptc[i] = '\0';
2224 }
2225
2226 void trojanscan_genident(char *ptc, char size) {
2227   int i;
2228   for (i=0;i<size;i++) {
2229     if (i == 0) {
2230       ptc[i] = trojanscan_genchar(1);
2231     } else {
2232       ptc[i] = trojanscan_genchar(2);
2233     }
2234   }
2235   ptc[i] = '\0';
2236 }
2237
2238 void trojanscan_genhost(char *ptc, char size, patricia_node_t **fakeipnode) {
2239   int dots = trojanscan_minmaxrand(2, 5), i, dotexist = 0, cur;
2240   struct irc_in_addr ipaddress;
2241
2242   while (!dotexist) {
2243     for (i=0;i<size;i++) {
2244       ptc[i] = trojanscan_genchar(0);
2245       if ((i > 5) && (i < (size-4))) {
2246         if ((ptc[i-1] != '.') && (ptc[i-1] != '-')) {
2247           cur = trojanscan_minmaxrand(1,size / dots);
2248           if (cur < 3) {
2249             if (cur == 1) {
2250               ptc[i] = '.';
2251               dotexist = 1;
2252             } else {
2253               ptc[i] = '-';
2254             }
2255           }
2256         }
2257       }
2258     }
2259   }
2260   ptc[i] = '\0';
2261
2262   memset(&ipaddress, 0, sizeof(ipaddress));
2263   ((unsigned short *)(ipaddress.in6_16))[5] = 65535;
2264   ((unsigned short *)(ipaddress.in6_16))[6] = trojanscan_minmaxrand(0, 65535);
2265   ((unsigned short *)(ipaddress.in6_16))[7] = trojanscan_minmaxrand(0, 65535);
2266
2267   *fakeipnode = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
2268 }
2269
2270 void trojanscan_genreal(char *ptc, char size) {
2271   int spaces = trojanscan_minmaxrand(2, 4), i;
2272   for (i=0;i<size;i++) {
2273     ptc[i] = trojanscan_genchar(0);
2274     if ((i > 5) && (i < (size-4))) {
2275       if (ptc[i-1] != ' ') {
2276         if (trojanscan_minmaxrand(1,size / spaces) == 1) ptc[i] = ' ';
2277       }
2278     }
2279   }
2280   ptc[i] = '\0';
2281 }
2282
2283 int trojanscan_is_not_octet(char *begin, int length) {
2284   int i;
2285   if(length > 3)
2286     return 0;
2287   for(i=0;i<length;i++) {
2288     if (!((*begin >= '0') && (*begin <= '9')))
2289       return 0;
2290     begin++;
2291   }
2292   return 1;
2293 }
2294
2295 int trojanscan_generatepool(void) {
2296   int i, k = 0, j = 0, loops = 0;
2297   char *p, *pp;
2298   nick *np;
2299
2300   for (i=0;i<NICKHASHSIZE;i++)
2301     for (np=nicktable[i];np;np=np->next)
2302       j++;
2303
2304   if(j < trojanscan_min_hosts)
2305     return 0;
2306
2307   if(TROJANSCAN_HOST_MODE == TROJANSCAN_STEAL_HOST)
2308     return TROJANSCAN_MINPOOLSIZE;
2309
2310   i = 0;
2311   do {
2312     for (j=trojanscan_minmaxrand(0, NICKHASHSIZE-1);j<NICKHASHSIZE;j++) {
2313       if (nicktable[j]) {
2314         for(p=nicktable[j]->host->name->content, pp=p;*p;) {
2315           if (*++p == '.') {
2316             if (!trojanscan_is_not_octet(pp, p-pp)) {
2317               if (i < TROJANSCAN_POOLSIZE) {
2318                 if (i < trojanscan_hostpoolsize)
2319                   freesstring(trojanscan_hostpool[i]);
2320                 trojanscan_hostpool[i] = getsstring(pp, p-pp);
2321                 i++;
2322               } else {
2323                 if (k >= TROJANSCAN_POOLSIZE)
2324                  break;
2325               }
2326             }
2327             pp=++p;
2328           }
2329         }
2330         if (!trojanscan_is_not_octet(pp, p-pp)) {
2331           if (k < TROJANSCAN_POOLSIZE) {
2332             if (k < trojanscan_tailpoolsize)
2333               freesstring(trojanscan_tailpool[k]);
2334             trojanscan_tailpool[k] = getsstring(pp, p-pp);
2335             k++;
2336           } else {
2337             if (i >= TROJANSCAN_POOLSIZE)
2338               break;
2339           }
2340         }
2341       }
2342     }
2343     loops++;
2344   } while ((loops < 5) && ((i < TROJANSCAN_POOLSIZE) || (k < TROJANSCAN_POOLSIZE)));
2345
2346   trojanscan_hostpoolsize = i;
2347   trojanscan_tailpoolsize = k;
2348   return i;
2349 }
2350
2351 nick *trojanscan_selectuser(void) {
2352   int target = trojanscan_minmaxrand(0, 500), loops = 150, j;
2353   nick *np;
2354   do {
2355     for (j=trojanscan_minmaxrand(0, NICKHASHSIZE-1);j<NICKHASHSIZE;j++)
2356       for(np=nicktable[j];np;np=np->next)
2357         if (!--target)
2358           return np;
2359   } while(--loops > 0);
2360   return NULL;
2361 }
2362
2363 host *trojanscan_selecthost(void) {
2364   int target = trojanscan_minmaxrand(0, 500), loops = 150, j;
2365   host *hp;
2366   do {
2367     for (j=trojanscan_minmaxrand(0, HOSTHASHSIZE-1);j<HOSTHASHSIZE;j++)
2368       for(hp=hosttable[j];hp;hp=hp->next)
2369         if (!--target)
2370           return hp;
2371   } while(--loops > 0);
2372
2373   return NULL;
2374 }
2375
2376 static int specialuseronhost(host *hp) {
2377   nick *np;
2378
2379   for(np=hp->nicks;np;np=np->nextbyhost)
2380     if(IsOper(np) || IsService(np) || IsXOper(np) || NickOnServiceServer(np))
2381       return 1;
2382
2383   return 0;
2384 }
2385
2386 void trojanscan_generatehost(char *buf, int maxsize, patricia_node_t **fakeip) {
2387   struct irc_in_addr ipaddress;
2388
2389   if(TROJANSCAN_HOST_MODE == TROJANSCAN_STEAL_HOST) {
2390     host *hp;
2391     int loops = 20;
2392
2393     buf[0] = '\0';
2394
2395     do {
2396       hp = trojanscan_selecthost();
2397       if(hp && (hp->clonecount <= TROJANSCAN_MAX_CLONE_COUNT) && !trojanscan_isip(hp->name->content) && !specialuseronhost(hp)) {
2398         strlcpy(buf, hp->name->content, maxsize + 1);
2399         if(hp->nicks) {
2400           *fakeip = hp->nicks->ipnode;
2401           patricia_ref_prefix(hp->nicks->ipnode->prefix);
2402         } else {
2403           memset(&ipaddress, 0, sizeof(ipaddress));
2404           ((unsigned short *)(ipaddress.in6_16))[5] = 65535;
2405           ((unsigned short *)(ipaddress.in6_16))[6] = trojanscan_minmaxrand(0, 65535);
2406           ((unsigned short *)(ipaddress.in6_16))[7] = trojanscan_minmaxrand(0, 65535);
2407
2408           *fakeip = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
2409         }
2410         break;
2411       }
2412     } while(--loops > 0);
2413   } else {
2414     char *cpos;
2415     int pieces = trojanscan_minmaxrand(2, 4), totallen = 0, a = 0, i;
2416     int *choices = tmalloc(sizeof(int) * (pieces + 1));
2417     int *lengths = tmalloc(sizeof(int) * (pieces + 1));
2418
2419     choices[pieces] = trojanscan_minmaxrand(0, trojanscan_tailpoolsize-1);
2420     lengths[pieces] = strlen(trojanscan_tailpool[choices[pieces]]->content) + 1;
2421     totallen += lengths[pieces];
2422
2423     for (i=0;i<pieces;i++) {
2424       choices[i] = trojanscan_minmaxrand(0, trojanscan_hostpoolsize-1);
2425       lengths[i] = strlen(trojanscan_hostpool[choices[i]]->content) + 1;
2426       if (totallen+lengths[i] > maxsize) {
2427         choices[i] = choices[pieces];
2428         lengths[i] = lengths[pieces];
2429         pieces-=(pieces-i);
2430         break;
2431       }
2432       totallen += lengths[i];
2433     }
2434
2435     for (i=0;i<pieces;i++) {
2436       for (cpos=trojanscan_hostpool[choices[i]]->content; *cpos;)
2437         buf[a++] = *cpos++;
2438       buf[a++] = '.';
2439     }
2440
2441     for (cpos=trojanscan_tailpool[choices[i]]->content; *cpos;) {
2442       buf[a++] = *cpos++;
2443     }
2444
2445     buf[a] = '\0';
2446     tfree(choices);
2447     tfree(lengths);
2448
2449     memset(&ipaddress, 0, sizeof(ipaddress));
2450     ((unsigned short *)(ipaddress.in6_16))[5] = 65535;
2451     ((unsigned short *)(ipaddress.in6_16))[6] = trojanscan_minmaxrand(0, 65535);
2452     ((unsigned short *)(ipaddress.in6_16))[7] = trojanscan_minmaxrand(0, 65535);
2453
2454     *fakeip = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
2455   }
2456 }
2457
2458 void trojanscan_generatenick(char *buf, int maxsize) {
2459   int bits = trojanscan_minmaxrand(2, 3), loops = 0, wanttocopy, len = 0, i, d = 0, newmaxsize = maxsize - trojanscan_minmaxrand(0, 7);
2460   nick *np;
2461
2462   if(newmaxsize > 2)
2463     maxsize = newmaxsize;
2464
2465   do {
2466     np = trojanscan_selectuser();
2467     if(np) {
2468       wanttocopy = trojanscan_minmaxrand(1, (strlen(np->nick) / 2) + 3);
2469       for(i=0;((i<wanttocopy) && (len<maxsize));i++)
2470         buf[len++] = np->nick[i];
2471       if(++d > bits) {
2472         buf[len] = '\0';
2473         return;
2474       }
2475     }
2476   } while (++loops < 10);
2477   buf[0] = '\0';
2478 }
2479
2480 void trojanscan_generateident(char *buf, int maxsize) {
2481   nick *np = trojanscan_selectuser();
2482   buf[0] = '\0';
2483   if(np)
2484     strlcpy(buf, np->ident, maxsize + 1);
2485 }
2486
2487 void trojanscan_generaterealname(char *buf, int maxsize) {
2488   nick *np = trojanscan_selectuser();
2489   buf[0] = '\0';
2490   if(np)
2491     strlcpy(buf, np->realname->name->content, maxsize + 1);
2492 }
2493
2494 static void db_ping(void *arg) {
2495   if (!(trojanscan_database_query("SELECT 1"))) {
2496     trojanscan_database_res *res;
2497     if ((res = trojanscan_database_store_result(&trojanscan_sql))) {
2498       trojanscan_database_free_result(res);
2499     }
2500   }
2501
2502   db_ping_schedule = scheduleoneshot(time(NULL) + 60, &db_ping, NULL);
2503 }
2504
2505 void trojanscan_database_close(void) {
2506   if(db_ping_schedule)
2507     deleteschedule(db_ping_schedule, db_ping, NULL);
2508
2509   mysql_close(&trojanscan_sql);
2510 }
2511
2512 int trojanscan_database_connect(char *dbhost, char *dbuser, char *dbpass, char *db, unsigned int port) {
2513   mysql_init(&trojanscan_sql);
2514   if (!mysql_real_connect(&trojanscan_sql, dbhost, dbuser, dbpass, db, port, NULL, 0))
2515     return -1;
2516
2517
2518   db_ping_schedule = scheduleoneshot(time(NULL) + 60, &db_ping, NULL);
2519
2520   return 0;
2521 }
2522
2523 void trojanscan_database_escape_string(char *dest, char *source, size_t length) {
2524   mysql_escape_string(dest, source, length);
2525 }
2526
2527 int trojanscan_database_query(char *format, ...) {
2528   char trojanscan_sqlquery[TROJANSCAN_QUERY_BUF_SIZE];
2529   va_list va;
2530
2531   va_start(va, format);
2532   vsnprintf(trojanscan_sqlquery, sizeof(trojanscan_sqlquery) - 1, format, va);
2533   va_end(va);
2534   return mysql_query(&trojanscan_sql, trojanscan_sqlquery);
2535 }
2536
2537 int trojanscan_database_num_rows(trojanscan_database_res *res) {
2538   return mysql_num_rows(res);
2539 }
2540
2541 trojanscan_database_res *trojanscan_database_store_result() {
2542   return mysql_store_result(&trojanscan_sql);
2543 }
2544
2545 trojanscan_database_row trojanscan_database_fetch_row(trojanscan_database_res *res) {
2546   return mysql_fetch_row(res);
2547 }
2548
2549 void trojanscan_database_free_result(trojanscan_database_res *res) {
2550   mysql_free_result(res);
2551 }
2552
2553 int trojanscan_isip(char *host) {
2554   char *p = host, components = 0, length = 0;
2555
2556   for(;*p;p++) {
2557     if(*p == '.') {
2558       if(((!length) || (length = 0)) || (++components > 3))
2559         return 0;
2560     } else {
2561       if ((++length > 3) || !isdigit(*p))
2562         return 0;
2563     }
2564   }
2565   return components == 3;
2566 }
2567