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