src/xline.cpp

   1 #include "inspircd.h"
   2 #include "inspircd_io.h"
   3 #include "inspircd_util.h"
   4 #include "inspircd_config.h"
   5 #include <unistd.h>
   6 #include <fcntl.h>
   7 #include <sys/errno.h>
   8 #include <sys/ioctl.h>
   9 #include <sys/utsname.h>
  10 #include <cstdio>
  11 #include <time.h>
  12 #include <string>
  13 #ifdef GCC3
  14 #include <ext/hash_map>
  15 #else
  16 #include <hash_map>
  17 #endif
  18 #include <map>
  19 #include <sstream>
  20 #include <vector>
  21 #include <errno.h>
  22 #include <deque>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <sched.h>
  26 #include "connection.h"
  27 #include "users.h"
  28 #include "servers.h"
  29 #include "ctables.h"
  30 #include "globals.h"
  31 #include "modules.h"
  32 #include "dynamic.h"
  33 #include "wildcard.h"
  34 #include "message.h"
  35 #include "commands.h"
  36 #include "xline.h"
  37
  38 #ifdef GCC3
  39 #define nspace __gnu_cxx
  40 #else
  41 #define nspace std
  42 #endif
  43
  44
  45 using namespace std;
  46
  47 extern int MODCOUNT;
  48 extern vector<Module*> modules;
  49 extern vector<ircd_module*> factory;
  50
  51 extern int LogLevel;
  52 extern char ServerName[MAXBUF];
  53 extern char Network[MAXBUF];
  54 extern char ServerDesc[MAXBUF];
  55 extern char AdminName[MAXBUF];
  56 extern char AdminEmail[MAXBUF];
  57 extern char AdminNick[MAXBUF];
  58 extern char diepass[MAXBUF];
  59 extern char restartpass[MAXBUF];
  60 extern char motd[MAXBUF];
  61 extern char rules[MAXBUF];
  62 extern char list[MAXBUF];
  63 extern char PrefixQuit[MAXBUF];
  64 extern char DieValue[MAXBUF];
  65
  66 extern int debugging;
  67 extern int WHOWAS_STALE;
  68 extern int WHOWAS_MAX;
  69 extern int DieDelay;
  70 extern time_t startup_time;
  71 extern int NetBufferSize;
  72 extern time_t nb_start;
  73
  74 extern std::vector<int> fd_reap;
  75 extern std::vector<std::string> module_names;
  76
  77 extern char bannerBuffer[MAXBUF];
  78 extern int boundPortCount;
  79 extern int portCount;
  80 extern int UDPportCount;
  81 extern int ports[MAXSOCKS];
  82 extern int defaultRoute;
  83
  84 extern std::vector<long> auth_cookies;
  85 extern std::stringstream config_f;
  86
  87 extern serverrec* me[32];
  88
  89 extern FILE *log_file;
  90
  91 namespace nspace
  92 {
  93         template<> struct nspace::hash<in_addr>
  94         {
  95                 size_t operator()(const struct in_addr &a) const
  96                 {
  97                         size_t q;
  98                         memcpy(&q,&a,sizeof(size_t));
  99                         return q;
 100                 }
 101         };
 102
 103         template<> struct nspace::hash<string>
 104         {
 105                 size_t operator()(const string &s) const
 106                 {
 107                         char a[MAXBUF];
 108                         static struct hash<const char *> strhash;
 109                         strcpy(a,s.c_str());
 110                         strlower(a);
 111                         return strhash(a);
 112                 }
 113         };
 114 }
 115
 116
 117 struct StrHashComp
 118 {
 119
 120         bool operator()(const string& s1, const string& s2) const
 121         {
 122                 char a[MAXBUF],b[MAXBUF];
 123                 strcpy(a,s1.c_str());
 124                 strcpy(b,s2.c_str());
 125                 return (strcasecmp(a,b) == 0);
 126         }
 127
 128 };
 129
 130 struct InAddr_HashComp
 131 {
 132
 133         bool operator()(const in_addr &s1, const in_addr &s2) const
 134         {
 135                 size_t q;
 136                 size_t p;
 137
 138                 memcpy(&q,&s1,sizeof(size_t));
 139                 memcpy(&p,&s2,sizeof(size_t));
 140
 141                 return (q == p);
 142         }
 143
 144 };
 145
 146
 147 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 148 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 149 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 150 typedef std::deque<command_t> command_table;
 151
 152
 153 extern user_hash clientlist;
 154 extern chan_hash chanlist;
 155 extern user_hash whowas;
 156 extern command_table cmdlist;
 157 extern file_cache MOTD;
 158 extern file_cache RULES;
 159 extern address_cache IP;
 160
 161
 162 std::vector<KLine> klines;
 163 std::vector<GLine> glines;
 164 std::vector<ZLine> zlines;
 165 std::vector<QLine> qlines;
 166
 167 // Reads the default bans from the config file.
 168 // only a very small number of bans are defined
 169 // this way these days, such as qlines against
 170 // services nicks, etc.
 171
 172 void read_xline_defaults()
 173 {
 174         char ipmask[MAXBUF];
 175         char nick[MAXBUF];
 176         char host[MAXBUF];
 177         char reason[MAXBUF];
 178
 179         for (int i = 0; i < ConfValueEnum("badip",&config_f); i++)
 180         {
 181                 ConfValue("badip","ipmask",i,ipmask,&config_f);
 182                 ConfValue("badip","reason",i,reason,&config_f);
 183                 add_zline(0,"<Config>",reason,ipmask);
 184                 log(DEBUG,"Read Z line (badip tag): ipmask=%s reason=%s",ipmask,reason);
 185         }
 186
 187         for (int i = 0; i < ConfValueEnum("badnick",&config_f); i++)
 188         {
 189                 ConfValue("badnick","nick",i,nick,&config_f);
 190                 ConfValue("badnick","reason",i,reason,&config_f);
 191                 add_qline(0,"<Config>",reason,nick);
 192                 log(DEBUG,"Read Q line (badnick tag): nick=%s reason=%s",nick,reason);
 193         }
 194
 195         for (int i = 0; i < ConfValueEnum("badhost",&config_f); i++)
 196         {
 197                 ConfValue("badhost","host",i,host,&config_f);
 198                 ConfValue("badhost","reason",i,reason,&config_f);
 199                 add_kline(0,"<Config>",reason,host);
 200                 log(DEBUG,"Read K line (badhost tag): host=%s reason=%s",host,reason);
 201         }
 202 }
 203
 204 // adds a g:line
 205
 206 void add_gline(long duration, char* source, char* reason, char* hostmask)
 207 {
 208         GLine item;
 209         item.duration = duration;
 210         strncpy(item.hostmask,hostmask,MAXBUF);
 211         strncpy(item.reason,reason,MAXBUF);
 212         strncpy(item.source,source,MAXBUF);
 213         item.n_matches = 0;
 214         item.set_time = time(NULL);
 215         glines.push_back(item);
 216 }
 217
 218 // adds a q:line
 219
 220 void add_qline(long duration, char* source, char* reason, char* nickname)
 221 {
 222         QLine item;
 223         item.duration = duration;
 224         strncpy(item.nick,nickname,MAXBUF);
 225         strncpy(item.reason,reason,MAXBUF);
 226         strncpy(item.source,source,MAXBUF);
 227         item.n_matches = 0;
 228         item.set_time = time(NULL);
 229         qlines.push_back(item);
 230 }
 231
 232 // adds a z:line
 233
 234 void add_zline(long duration, char* source, char* reason, char* ipaddr)
 235 {
 236         ZLine item;
 237         item.duration = duration;
 238         strncpy(item.ipaddr,ipaddr,MAXBUF);
 239         strncpy(item.reason,reason,MAXBUF);
 240         strncpy(item.source,source,MAXBUF);
 241         item.n_matches = 0;
 242         item.set_time = time(NULL);
 243         zlines.push_back(item);
 244 }
 245
 246 // adds a k:line
 247
 248 void add_kline(long duration, char* source, char* reason, char* hostmask)
 249 {
 250         KLine item;
 251         item.duration = duration;
 252         strncpy(item.hostmask,hostmask,MAXBUF);
 253         strncpy(item.reason,reason,MAXBUF);
 254         strncpy(item.source,source,MAXBUF);
 255         item.n_matches = 0;
 256         item.set_time = time(NULL);
 257         klines.push_back(item);
 258 }
 259
 260 // deletes a g:line, returns true if the line existed and was removed
 261
 262 bool del_gline(char* hostmask)
 263 {
 264         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 265         {
 266                 if (!strcasecmp(hostmask,i->hostmask))
 267                 {
 268                         glines.erase(i);
 269                         return true;
 270                 }
 271         }
 272         return false;
 273 }
 274
 275 // deletes a q:line, returns true if the line existed and was removed
 276
 277 bool del_qline(char* nickname)
 278 {
 279         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 280         {
 281                 if (!strcasecmp(nickname,i->nick))
 282                 {
 283                         qlines.erase(i);
 284                         return true;
 285                 }
 286         }
 287         return false;
 288 }
 289
 290 // deletes a z:line, returns true if the line existed and was removed
 291
 292 bool del_zline(char* ipaddr)
 293 {
 294         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 295         {
 296                 if (!strcasecmp(ipaddr,i->ipaddr))
 297                 {
 298                         zlines.erase(i);
 299                         return true;
 300                 }
 301         }
 302         return false;
 303 }
 304
 305 // deletes a k:line, returns true if the line existed and was removed
 306
 307 bool del_kline(char* hostmask)
 308 {
 309         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 310         {
 311                 if (!strcasecmp(hostmask,i->hostmask))
 312                 {
 313                         klines.erase(i);
 314                         return true;
 315                 }
 316         }
 317         return false;
 318 }
 319
 320 // returns a pointer to the reason if a nickname matches a qline, NULL if it didnt match
 321
 322 char* matches_qline(const char* nick)
 323 {
 324         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 325         {
 326                 if (match(nick,i->nick))
 327                 {
 328                         return i->reason;
 329                 }
 330         }
 331         return NULL;
 332 }
 333
 334 // returns a pointer to the reason if a host matches a gline, NULL if it didnt match
 335
 336 char* matches_gline(const char* host)
 337 {
 338         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 339         {
 340                 if (match(host,i->hostmask))
 341                 {
 342                         return i->reason;
 343                 }
 344         }
 345         return NULL;
 346 }
 347
 348 void gline_set_creation_time(char* host, time_t create_time)
 349 {
 350         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 351         {
 352                 if (!strcasecmp(host,i->hostmask))
 353                 {
 354                         i->set_time = create_time;
 355                         return;
 356                 }
 357         }
 358         return ;
 359 }
 360
 361 void qline_set_creation_time(char* nick, time_t create_time)
 362 {
 363         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 364         {
 365                 if (!strcasecmp(nick,i->nick))
 366                 {
 367                         i->set_time = create_time;
 368                         return;
 369                 }
 370         }
 371         return ;
 372 }
 373
 374 void zline_set_creation_time(char* ip, time_t create_time)
 375 {
 376         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 377         {
 378                 if (!strcasecmp(ip,i->ipaddr))
 379                 {
 380                         i->set_time = create_time;
 381                         return;
 382                 }
 383         }
 384         return ;
 385 }
 386
 387 // returns a pointer to the reason if an ip address matches a zline, NULL if it didnt match
 388
 389 char* matches_zline(const char* ipaddr)
 390 {
 391         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 392         {
 393                 if (match(ipaddr,i->ipaddr))
 394                 {
 395                         return i->reason;
 396                 }
 397         }
 398         return NULL;
 399 }
 400
 401 // returns a pointer to the reason if a host matches a kline, NULL if it didnt match
 402
 403 char* matches_kline(const char* host)
 404 {
 405         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 406         {
 407                 if (match(host,i->hostmask))
 408                 {
 409                         return i->reason;
 410                 }
 411         }
 412         return NULL;
 413 }
 414
 415 // removes lines that have expired
 416
 417 void expire_lines()
 418 {
 419         bool go_again = true;
 420         time_t current = time(NULL);
 421
 422         // because we mess up an iterator when we remove from the vector, we must bail from
 423         // the loop early if we delete an item, therefore this outer while loop is required.
 424         while (go_again)
 425         {
 426                 go_again = false;
 427
 428                 for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 429                 {
 430                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 431                         {
 432                                 WriteOpers("Expiring timed K-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
 433                                 klines.erase(i);
 434                                 go_again = true;
 435                                 break;
 436                         }
 437                 }
 438
 439                 for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 440                 {
 441                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 442                         {
 443                                 WriteOpers("Expiring timed G-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
 444                                 glines.erase(i);
 445                                 go_again = true;
 446                                 break;
 447                         }
 448                 }
 449
 450                 for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 451                 {
 452                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 453                         {
 454                                 WriteOpers("Expiring timed Z-Line %s (set by %s %d seconds ago)",i->ipaddr,i->source,i->duration);
 455                                 zlines.erase(i);
 456                                 go_again = true;
 457                                 break;
 458                         }
 459                 }
 460
 461                 for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 462                 {
 463                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 464                         {
 465                                 WriteOpers("Expiring timed Q-Line %s (set by %s %d seconds ago)",i->nick,i->source,i->duration);
 466                                 qlines.erase(i);
 467                                 go_again = true;
 468                                 break;
 469                         }
 470                 }
 471         }
 472 }
 473
 474 // applies lines, removing clients and changing nicks etc as applicable
 475
 476 void apply_lines()
 477 {
 478         bool go_again = true;
 479         char reason[MAXBUF];
 480         char host[MAXBUF];
 481
 482         while (go_again)
 483         {
 484                 go_again = false;
 485                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
 486                 {
 487                         if (!strcasecmp(u->second->server,ServerName))
 488                         {
 489                                 snprintf(host,MAXBUF,"%s@%s",u->second->ident,u->second->host);
 490                                 char* check = matches_gline(host);
 491                                 if (check)
 492                                 {
 493                                         WriteOpers("*** User %s matches G-Line: %s",u->second->nick,check);
 494                                         snprintf(reason,MAXBUF,"G-Lined: %s",check);
 495                                         kill_link(u->second,reason);
 496                                         go_again = true;
 497                                         break;
 498                                 }
 499                         }
 500                 }
 501
 502                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
 503                 {
 504                         if (!strcasecmp(u->second->server,ServerName))
 505                         {
 506                                 snprintf(host,MAXBUF,"%s@%s",u->second->ident,u->second->host);
 507                                 char* check = matches_kline(host);
 508                                 if (check)
 509                                 {
 510                                         WriteOpers("*** User %s matches K-Line: %s",u->second->nick,check);
 511                                         snprintf(reason,MAXBUF,"K-Lined: %s",check);
 512                                         kill_link(u->second,reason);
 513                                         go_again = true;
 514                                         break;
 515                                 }
 516                         }
 517                 }
 518
 519                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
 520                 {
 521                         if (!strcasecmp(u->second->server,ServerName))
 522                         {
 523                                 char* check = matches_qline(u->second->nick);
 524                                 if (check)
 525                                 {
 526                                         snprintf(reason,MAXBUF,"Matched Q-Lined nick: %s",check);
 527                                         WriteOpers("*** Q-Lined nickname %s from %s: %s",u->second->nick,u->second->host,check);
 528                                         WriteServ(u->second->fd,"432 %s %s :Invalid nickname: %s",u->second->nick,u->second->nick,check);
 529                                         kill_link(u->second,reason);
 530                                         go_again = true;
 531                                         break;
 532                                 }
 533                         }
 534                 }
 535
 536                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
 537                 {
 538                         if (!strcasecmp(u->second->server,ServerName))
 539                         {
 540                                 char* check = matches_zline(u->second->ip);
 541                                 if (check)
 542                                 {
 543                                         WriteOpers("*** User %s matches Z-Line: %s",u->second->nick,u->second->host,check);
 544                                         WriteServ(u->second->fd,"432 %s %s :Invalid nickname: %s",u->second->nick,u->second->nick,check);
 545                                         go_again = true;
 546                                         break;
 547                                 }
 548                         }
 549                 }
 550
 551         }
 552 }
 553
 554 void stats_k(userrec* user)
 555 {
 556         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 557         {
 558                 WriteServ(user->fd,"216 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
 559         }
 560 }
 561
 562 void stats_g(userrec* user)
 563 {
 564         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 565         {
 566                 WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
 567         }
 568 }
 569
 570 void stats_q(userrec* user)
 571 {
 572         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 573         {
 574                 WriteServ(user->fd,"217 %s :%s %d %d %s %s",user->nick,i->nick,i->set_time,i->duration,i->source,i->reason);
 575         }
 576 }
 577
 578 void stats_z(userrec* user)
 579 {
 580         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 581         {
 582                 WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->ipaddr,i->set_time,i->duration,i->source,i->reason);
 583         }
 584 }
 585
 586
 587