src/xline.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
   6  *                       E-mail:
   7  *                <brain@chatspike.net>
   8  *                <Craig@chatspike.net>
   9  *
  10  * Written by Craig Edwards, Craig McLure, and others.
  11  * This program is free but copyrighted software; see
  12  *            the file COPYING for details.
  13  *
  14  * ---------------------------------------------------
  15  */
  16
  17 #include "inspircd.h"
  18 #include "inspircd_io.h"
  19 #include "inspircd_util.h"
  20 #include "inspircd_config.h"
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <sys/errno.h>
  24 #include <sys/ioctl.h>
  25 #include <sys/utsname.h>
  26 #include <cstdio>
  27 #include <time.h>
  28 #include <string>
  29 #ifdef GCC3
  30 #include <ext/hash_map>
  31 #else
  32 #include <hash_map>
  33 #endif
  34 #include <map>
  35 #include <sstream>
  36 #include <vector>
  37 #include <errno.h>
  38 #include <deque>
  39 #include <errno.h>
  40 #include <unistd.h>
  41 #include <sched.h>
  42 #include "connection.h"
  43 #include "users.h"
  44 #include "servers.h"
  45 #include "ctables.h"
  46 #include "globals.h"
  47 #include "modules.h"
  48 #include "dynamic.h"
  49 #include "wildcard.h"
  50 #include "message.h"
  51 #include "commands.h"
  52 #include "xline.h"
  53 #include "inspstring.h"
  54
  55 #ifdef GCC3
  56 #define nspace __gnu_cxx
  57 #else
  58 #define nspace std
  59 #endif
  60
  61
  62 using namespace std;
  63
  64 extern int MODCOUNT;
  65 extern std::vector<Module*> modules;
  66 extern std::vector<ircd_module*> factory;
  67
  68 extern int LogLevel;
  69 extern char ServerName[MAXBUF];
  70 extern char Network[MAXBUF];
  71 extern char ServerDesc[MAXBUF];
  72 extern char AdminName[MAXBUF];
  73 extern char AdminEmail[MAXBUF];
  74 extern char AdminNick[MAXBUF];
  75 extern char diepass[MAXBUF];
  76 extern char restartpass[MAXBUF];
  77 extern char motd[MAXBUF];
  78 extern char rules[MAXBUF];
  79 extern char list[MAXBUF];
  80 extern char PrefixQuit[MAXBUF];
  81 extern char DieValue[MAXBUF];
  82
  83 extern int debugging;
  84 extern int WHOWAS_STALE;
  85 extern int WHOWAS_MAX;
  86 extern int DieDelay;
  87 extern time_t startup_time;
  88 extern int NetBufferSize;
  89 extern time_t nb_start;
  90
  91 extern std::vector<int> fd_reap;
  92 extern std::vector<std::string> module_names;
  93
  94 extern int boundPortCount;
  95 extern int portCount;
  96 extern int UDPportCount;
  97 extern int ports[MAXSOCKS];
  98 extern int defaultRoute;
  99
 100 extern std::vector<long> auth_cookies;
 101 extern std::stringstream config_f;
 102
 103 extern serverrec* me[32];
 104
 105 extern FILE *log_file;
 106
 107 namespace nspace
 108 {
 109 #ifdef GCC34
 110         template<> struct hash<in_addr>
 111 #else
 112         template<> struct nspace::hash<in_addr>
 113 #endif
 114         {
 115                 size_t operator()(const struct in_addr &a) const
 116                 {
 117                         size_t q;
 118                         memcpy(&q,&a,sizeof(size_t));
 119                         return q;
 120                 }
 121         };
 122 #ifdef GCC34
 123         template<> struct hash<string>
 124 #else
 125         template<> struct nspace::hash<string>
 126 #endif
 127         {
 128                 size_t operator()(const string &s) const
 129                 {
 130                         char a[MAXBUF];
 131                         static struct hash<const char *> strhash;
 132                         strlcpy(a,s.c_str(),MAXBUF);
 133                         strlower(a);
 134                         return strhash(a);
 135                 }
 136         };
 137 }
 138
 139
 140 struct StrHashComp
 141 {
 142
 143         bool operator()(const string& s1, const string& s2) const
 144         {
 145                 char a[MAXBUF],b[MAXBUF];
 146                 strlcpy(a,s1.c_str(),MAXBUF);
 147                 strlcpy(b,s2.c_str(),MAXBUF);
 148                 strlower(a);
 149                 strlower(b);
 150                 return (strcasecmp(a,b) == 0);
 151         }
 152
 153 };
 154
 155 struct InAddr_HashComp
 156 {
 157
 158         bool operator()(const in_addr &s1, const in_addr &s2) const
 159         {
 160                 size_t q;
 161                 size_t p;
 162
 163                 memcpy(&q,&s1,sizeof(size_t));
 164                 memcpy(&p,&s2,sizeof(size_t));
 165
 166                 return (q == p);
 167         }
 168
 169 };
 170
 171
 172 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 173 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 174 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 175 typedef std::deque<command_t> command_table;
 176
 177
 178 extern user_hash clientlist;
 179 extern chan_hash chanlist;
 180 extern user_hash whowas;
 181 extern command_table cmdlist;
 182 extern file_cache MOTD;
 183 extern file_cache RULES;
 184 extern address_cache IP;
 185
 186 extern time_t TIME;
 187
 188 std::vector<KLine> klines;
 189 std::vector<GLine> glines;
 190 std::vector<ZLine> zlines;
 191 std::vector<QLine> qlines;
 192 std::vector<ELine> elines;
 193
 194 // Reads the default bans from the config file.
 195 // only a very small number of bans are defined
 196 // this way these days, such as qlines against
 197 // services nicks, etc.
 198
 199 void read_xline_defaults()
 200 {
 201         char ipmask[MAXBUF];
 202         char nick[MAXBUF];
 203         char host[MAXBUF];
 204         char reason[MAXBUF];
 205
 206         for (int i = 0; i < ConfValueEnum("badip",&config_f); i++)
 207         {
 208                 ConfValue("badip","ipmask",i,ipmask,&config_f);
 209                 ConfValue("badip","reason",i,reason,&config_f);
 210                 add_zline(0,"<Config>",reason,ipmask);
 211                 log(DEBUG,"Read Z line (badip tag): ipmask=%s reason=%s",ipmask,reason);
 212         }
 213
 214         for (int i = 0; i < ConfValueEnum("badnick",&config_f); i++)
 215         {
 216                 ConfValue("badnick","nick",i,nick,&config_f);
 217                 ConfValue("badnick","reason",i,reason,&config_f);
 218                 add_qline(0,"<Config>",reason,nick);
 219                 log(DEBUG,"Read Q line (badnick tag): nick=%s reason=%s",nick,reason);
 220         }
 221
 222         for (int i = 0; i < ConfValueEnum("badhost",&config_f); i++)
 223         {
 224                 ConfValue("badhost","host",i,host,&config_f);
 225                 ConfValue("badhost","reason",i,reason,&config_f);
 226                 add_kline(0,"<Config>",reason,host);
 227                 log(DEBUG,"Read K line (badhost tag): host=%s reason=%s",host,reason);
 228         }
 229         for (int i = 0; i < ConfValueEnum("exception",&config_f); i++)
 230         {
 231                 ConfValue("exception","host",i,host,&config_f);
 232                 ConfValue("exception","reason",i,reason,&config_f);
 233                 add_eline(0,"<Config>",reason,host);
 234                 log(DEBUG,"Read E line (exception tag): host=%s reason=%s",host,reason);
 235         }
 236 }
 237
 238 // adds a g:line
 239
 240 void add_gline(long duration, const char* source,const char* reason,const char* hostmask)
 241 {
 242         del_gline(hostmask);
 243         GLine item;
 244         item.duration = duration;
 245         strlcpy(item.hostmask,hostmask,MAXBUF);
 246         strlcpy(item.reason,reason,MAXBUF);
 247         strlcpy(item.source,source,MAXBUF);
 248         item.n_matches = 0;
 249         item.set_time = TIME;
 250         glines.push_back(item);
 251 }
 252
 253 // adds an e:line (exception to bans)
 254
 255 void add_eline(long duration, const char* source, const char* reason, const char* hostmask)
 256 {
 257         del_eline(hostmask);
 258         ELine item;
 259         item.duration = duration;
 260         strlcpy(item.hostmask,hostmask,MAXBUF);
 261         strlcpy(item.reason,reason,MAXBUF);
 262         strlcpy(item.source,source,MAXBUF);
 263         item.n_matches = 0;
 264         item.set_time = TIME;
 265         elines.push_back(item);
 266 }
 267
 268 // adds a q:line
 269
 270 void add_qline(long duration, const char* source, const char* reason, const char* nickname)
 271 {
 272         del_qline(nickname);
 273         QLine item;
 274         item.duration = duration;
 275         strlcpy(item.nick,nickname,MAXBUF);
 276         strlcpy(item.reason,reason,MAXBUF);
 277         strlcpy(item.source,source,MAXBUF);
 278         item.n_matches = 0;
 279         item.is_global = false;
 280         item.set_time = TIME;
 281         qlines.push_back(item);
 282 }
 283
 284 // adds a z:line
 285
 286 void add_zline(long duration, const char* source, const char* reason, const char* ipaddr)
 287 {
 288         del_zline(ipaddr);
 289         ZLine item;
 290         item.duration = duration;
 291         strlcpy(item.ipaddr,ipaddr,MAXBUF);
 292         strlcpy(item.reason,reason,MAXBUF);
 293         strlcpy(item.source,source,MAXBUF);
 294         item.n_matches = 0;
 295         item.is_global = false;
 296         item.set_time = TIME;
 297         zlines.push_back(item);
 298 }
 299
 300 // adds a k:line
 301
 302 void add_kline(long duration, const char* source, const char* reason, const char* hostmask)
 303 {
 304         del_kline(hostmask);
 305         KLine item;
 306         item.duration = duration;
 307         strlcpy(item.hostmask,hostmask,MAXBUF);
 308         strlcpy(item.reason,reason,MAXBUF);
 309         strlcpy(item.source,source,MAXBUF);
 310         item.n_matches = 0;
 311         item.set_time = TIME;
 312         klines.push_back(item);
 313 }
 314
 315 // deletes a g:line, returns true if the line existed and was removed
 316
 317 bool del_gline(const char* hostmask)
 318 {
 319         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 320         {
 321                 if (!strcasecmp(hostmask,i->hostmask))
 322                 {
 323                         glines.erase(i);
 324                         return true;
 325                 }
 326         }
 327         return false;
 328 }
 329
 330 // deletes a e:line, returns true if the line existed and was removed
 331
 332 bool del_eline(const char* hostmask)
 333 {
 334         for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
 335         {
 336                 if (!strcasecmp(hostmask,i->hostmask))
 337                 {
 338                         elines.erase(i);
 339                         return true;
 340                 }
 341         }
 342         return false;
 343 }
 344
 345 // deletes a q:line, returns true if the line existed and was removed
 346
 347 bool del_qline(const char* nickname)
 348 {
 349         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 350         {
 351                 if (!strcasecmp(nickname,i->nick))
 352                 {
 353                         qlines.erase(i);
 354                         return true;
 355                 }
 356         }
 357         return false;
 358 }
 359
 360 bool qline_make_global(const char* nickname)
 361 {
 362         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 363         {
 364                 if (!strcasecmp(nickname,i->nick))
 365                 {
 366                         i->is_global = true;
 367                         return true;
 368                 }
 369         }
 370         return false;
 371 }
 372
 373 bool zline_make_global(const char* ipaddr)
 374 {
 375         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 376         {
 377                 if (!strcasecmp(ipaddr,i->ipaddr))
 378                 {
 379                         i->is_global = true;
 380                         return true;
 381                 }
 382         }
 383         return false;
 384 }
 385
 386 void sync_xlines(serverrec* serv, char* tcp_host)
 387 {
 388         char data[MAXBUF];
 389
 390         // for zlines and qlines, we should first check if theyre global...
 391         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 392         {
 393                 if (i->is_global)
 394                 {
 395                         snprintf(data,MAXBUF,"} %s %s %ld %ld :%s",i->ipaddr,i->source,i->set_time,i->duration,i->reason);
 396                         serv->SendPacket(data,tcp_host);
 397                 }
 398         }
 399         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 400         {
 401                 if (i->is_global)
 402                 {
 403                         snprintf(data,MAXBUF,"{ %s %s %ld %ld :%s",i->nick,i->source,i->set_time,i->duration,i->reason);
 404                         serv->SendPacket(data,tcp_host);
 405                 }
 406         }
 407         // glines are always global, so no need to check
 408         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 409         {
 410                 snprintf(data,MAXBUF,"# %s %s %ld %ld :%s",i->hostmask,i->source,i->set_time,i->duration,i->reason);
 411                 serv->SendPacket(data,tcp_host);
 412         }
 413 }
 414
 415
 416 // deletes a z:line, returns true if the line existed and was removed
 417
 418 bool del_zline(const char* ipaddr)
 419 {
 420         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 421         {
 422                 if (!strcasecmp(ipaddr,i->ipaddr))
 423                 {
 424                         zlines.erase(i);
 425                         return true;
 426                 }
 427         }
 428         return false;
 429 }
 430
 431 // deletes a k:line, returns true if the line existed and was removed
 432
 433 bool del_kline(const char* hostmask)
 434 {
 435         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 436         {
 437                 if (!strcasecmp(hostmask,i->hostmask))
 438                 {
 439                         klines.erase(i);
 440                         return true;
 441                 }
 442         }
 443         return false;
 444 }
 445
 446 // returns a pointer to the reason if a nickname matches a qline, NULL if it didnt match
 447
 448 char* matches_qline(const char* nick)
 449 {
 450         if (qlines.empty())
 451                 return NULL;
 452         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 453         {
 454                 if (match(nick,i->nick))
 455                 {
 456                         return i->reason;
 457                 }
 458         }
 459         return NULL;
 460 }
 461
 462 // returns a pointer to the reason if a host matches a gline, NULL if it didnt match
 463
 464 char* matches_gline(const char* host)
 465 {
 466         if (glines.empty())
 467                 return NULL;
 468         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 469         {
 470                 if (match(host,i->hostmask))
 471                 {
 472                         return i->reason;
 473                 }
 474         }
 475         return NULL;
 476 }
 477
 478 char* matches_exception(const char* host)
 479 {
 480         if (elines.empty())
 481                 return NULL;
 482         char host2[MAXBUF];
 483         snprintf(host2,MAXBUF,"*@%s",host);
 484         for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
 485         {
 486                 if ((match(host,i->hostmask)) || (match(host2,i->hostmask)))
 487                 {
 488                         return i->reason;
 489                 }
 490         }
 491         return NULL;
 492 }
 493
 494
 495 void gline_set_creation_time(char* host, time_t create_time)
 496 {
 497         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 498         {
 499                 if (!strcasecmp(host,i->hostmask))
 500                 {
 501                         i->set_time = create_time;
 502                         return;
 503                 }
 504         }
 505         return ;
 506 }
 507
 508 void qline_set_creation_time(char* nick, time_t create_time)
 509 {
 510         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 511         {
 512                 if (!strcasecmp(nick,i->nick))
 513                 {
 514                         i->set_time = create_time;
 515                         return;
 516                 }
 517         }
 518         return ;
 519 }
 520
 521 void zline_set_creation_time(char* ip, time_t create_time)
 522 {
 523         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 524         {
 525                 if (!strcasecmp(ip,i->ipaddr))
 526                 {
 527                         i->set_time = create_time;
 528                         return;
 529                 }
 530         }
 531         return ;
 532 }
 533
 534 // returns a pointer to the reason if an ip address matches a zline, NULL if it didnt match
 535
 536 char* matches_zline(const char* ipaddr)
 537 {
 538         if (zlines.empty())
 539                 return NULL;
 540         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 541         {
 542                 if (match(ipaddr,i->ipaddr))
 543                 {
 544                         return i->reason;
 545                 }
 546         }
 547         return NULL;
 548 }
 549
 550 // returns a pointer to the reason if a host matches a kline, NULL if it didnt match
 551
 552 char* matches_kline(const char* host)
 553 {
 554         if (klines.empty())
 555                 return NULL;
 556         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 557         {
 558                 if (match(host,i->hostmask))
 559                 {
 560                         return i->reason;
 561                 }
 562         }
 563         return NULL;
 564 }
 565
 566 // removes lines that have expired
 567
 568 void expire_lines()
 569 {
 570         bool go_again = true;
 571         time_t current = TIME;
 572
 573         // because we mess up an iterator when we remove from the vector, we must bail from
 574         // the loop early if we delete an item, therefore this outer while loop is required.
 575         while (go_again)
 576         {
 577                 go_again = false;
 578
 579                 for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 580                 {
 581                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 582                         {
 583                                 WriteOpers("Expiring timed K-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
 584                                 klines.erase(i);
 585                                 go_again = true;
 586                                 break;
 587                         }
 588                 }
 589
 590                 for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
 591                 {
 592                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 593                         {
 594                                 WriteOpers("Expiring timed E-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
 595                                 elines.erase(i);
 596                                 go_again = true;
 597                                 break;
 598                         }
 599                 }
 600
 601                 for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 602                 {
 603                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 604                         {
 605                                 WriteOpers("Expiring timed G-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
 606                                 glines.erase(i);
 607                                 go_again = true;
 608                                 break;
 609                         }
 610                 }
 611
 612                 for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 613                 {
 614                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 615                         {
 616                                 WriteOpers("Expiring timed Z-Line %s (set by %s %d seconds ago)",i->ipaddr,i->source,i->duration);
 617                                 zlines.erase(i);
 618                                 go_again = true;
 619                                 break;
 620                         }
 621                 }
 622
 623                 for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 624                 {
 625                         if ((current > (i->duration + i->set_time)) && (i->duration > 0))
 626                         {
 627                                 WriteOpers("Expiring timed Q-Line %s (set by %s %d seconds ago)",i->nick,i->source,i->duration);
 628                                 qlines.erase(i);
 629                                 go_again = true;
 630                                 break;
 631                         }
 632                 }
 633         }
 634 }
 635
 636 // applies lines, removing clients and changing nicks etc as applicable
 637
 638 void apply_lines()
 639 {
 640         bool go_again = true;
 641         char reason[MAXBUF];
 642         char host[MAXBUF];
 643
 644         if ((!glines.size()) && (!klines.size()) && (!zlines.size()) && (!qlines.size()))
 645                 return;
 646
 647         while (go_again)
 648         {
 649                 go_again = false;
 650                 for (user_hash::const_iterator u = clientlist.begin(); u != clientlist.end(); u++)
 651                 {
 652                         if (!strcasecmp(u->second->server,ServerName))
 653                         {
 654                                 snprintf(host,MAXBUF,"%s@%s",u->second->ident,u->second->host);
 655                                 if (elines.size())
 656                                 {
 657                                         // ignore people matching exempts
 658                                         if (matches_exception(host))
 659                                                 continue;
 660                                 }
 661                                 if (glines.size())
 662                                 {
 663                                         char* check = matches_gline(host);
 664                                         if (check)
 665                                         {
 666                                                 WriteOpers("*** User %s matches G-Line: %s",u->second->nick,check);
 667                                                 snprintf(reason,MAXBUF,"G-Lined: %s",check);
 668                                                 kill_link(u->second,reason);
 669                                                 go_again = true;
 670                                                 break;
 671                                         }
 672                                 }
 673                                 if (klines.size())
 674                                 {
 675                                         char* check = matches_kline(host);
 676                                         if (check)
 677                                         {
 678                                                 WriteOpers("*** User %s matches K-Line: %s",u->second->nick,check);
 679                                                 snprintf(reason,MAXBUF,"K-Lined: %s",check);
 680                                                 kill_link(u->second,reason);
 681                                                 go_again = true;
 682                                                 break;
 683                                         }
 684                                 }
 685                                 if (qlines.size())
 686                                 {
 687                                         char* check = matches_qline(u->second->nick);
 688                                         if (check)
 689                                         {
 690                                                 snprintf(reason,MAXBUF,"Matched Q-Lined nick: %s",check);
 691                                                 WriteOpers("*** Q-Lined nickname %s from %s: %s",u->second->nick,u->second->host,check);
 692                                                 kill_link(u->second,reason);
 693                                                 go_again = true;
 694                                                 break;
 695                                         }
 696                                 }
 697                                 if (zlines.size())
 698                                 {
 699                                         char* check = matches_zline(u->second->ip);
 700                                         if (check)
 701                                         {
 702                                                 snprintf(reason,MAXBUF,"Z-Lined: %s",check);
 703                                                 WriteOpers("*** User %s matches Z-Line: %s",u->second->nick,u->second->host,check);
 704                                                 kill_link(u->second,reason);
 705                                                 go_again = true;
 706                                                 break;
 707                                         }
 708                                 }
 709                         }
 710                 }
 711         }
 712 }
 713
 714 void stats_k(userrec* user)
 715 {
 716         for (std::vector<KLine>::iterator i = klines.begin(); i != klines.end(); i++)
 717         {
 718                 WriteServ(user->fd,"216 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
 719         }
 720 }
 721
 722 void stats_g(userrec* user)
 723 {
 724         for (std::vector<GLine>::iterator i = glines.begin(); i != glines.end(); i++)
 725         {
 726                 WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
 727         }
 728 }
 729
 730 void stats_q(userrec* user)
 731 {
 732         for (std::vector<QLine>::iterator i = qlines.begin(); i != qlines.end(); i++)
 733         {
 734                 WriteServ(user->fd,"217 %s :%s %d %d %s %s",user->nick,i->nick,i->set_time,i->duration,i->source,i->reason);
 735         }
 736 }
 737
 738 void stats_z(userrec* user)
 739 {
 740         for (std::vector<ZLine>::iterator i = zlines.begin(); i != zlines.end(); i++)
 741         {
 742                 WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->ipaddr,i->set_time,i->duration,i->source,i->reason);
 743         }
 744 }
 745
 746 void stats_e(userrec* user)
 747 {
 748         for (std::vector<ELine>::iterator i = elines.begin(); i != elines.end(); i++)
 749         {
 750                 WriteServ(user->fd,"223 %s :%s %d %d %s %s",user->nick,i->hostmask,i->set_time,i->duration,i->source,i->reason);
 751         }
 752 }