src/users.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
   5  *   Copyright (C) 2006-2009 Robin Burchell <robin+git@viroteck.net>
   6  *   Copyright (C) 2006-2007, 2009 Dennis Friis <peavey@inspircd.org>
   7  *   Copyright (C) 2008 John Brooks <john.brooks@dereferenced.net>
   8  *   Copyright (C) 2008 Thomas Stagner <aquanight@inspircd.org>
   9  *   Copyright (C) 2008 Oliver Lupton <oliverlupton@gmail.com>
  10  *   Copyright (C) 2003-2008 Craig Edwards <craigedwards@brainbox.cc>
  11  *
  12  * This file is part of InspIRCd.  InspIRCd is free software: you can
  13  * redistribute it and/or modify it under the terms of the GNU General Public
  14  * License as published by the Free Software Foundation, version 2.
  15  *
  16  * This program is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  18  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  19  * details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25
  26 #include "inspircd.h"
  27 #include <stdarg.h>
  28 #include "socketengine.h"
  29 #include "xline.h"
  30 #include "bancache.h"
  31
  32 already_sent_t LocalUser::already_sent_id = 0;
  33
  34 std::string User::ProcessNoticeMasks(const char *sm)
  35 {
  36         bool adding = true, oldadding = false;
  37         const char *c = sm;
  38         std::string output;
  39
  40         while (c && *c)
  41         {
  42                 switch (*c)
  43                 {
  44                         case '+':
  45                                 adding = true;
  46                         break;
  47                         case '-':
  48                                 adding = false;
  49                         break;
  50                         case '*':
  51                                 for (unsigned char d = 'a'; d <= 'z'; d++)
  52                                 {
  53                                         if (!ServerInstance->SNO->masks[d - 'a'].Description.empty())
  54                                         {
  55                                                 if ((!IsNoticeMaskSet(d) && adding) || (IsNoticeMaskSet(d) && !adding))
  56                                                 {
  57                                                         if ((oldadding != adding) || (!output.length()))
  58                                                                 output += (adding ? '+' : '-');
  59
  60                                                         this->SetNoticeMask(d, adding);
  61
  62                                                         output += d;
  63                                                 }
  64                                                 oldadding = adding;
  65                                                 char u = toupper(d);
  66                                                 if ((!IsNoticeMaskSet(u) && adding) || (IsNoticeMaskSet(u) && !adding))
  67                                                 {
  68                                                         if ((oldadding != adding) || (!output.length()))
  69                                                                 output += (adding ? '+' : '-');
  70
  71                                                         this->SetNoticeMask(u, adding);
  72
  73                                                         output += u;
  74                                                 }
  75                                                 oldadding = adding;
  76                                         }
  77                                 }
  78                         break;
  79                         default:
  80                                 if (isalpha(*c))
  81                                 {
  82                                         if ((!IsNoticeMaskSet(*c) && adding) || (IsNoticeMaskSet(*c) && !adding))
  83                                         {
  84                                                 if ((oldadding != adding) || (!output.length()))
  85                                                         output += (adding ? '+' : '-');
  86
  87                                                 this->SetNoticeMask(*c, adding);
  88
  89                                                 output += *c;
  90                                         }
  91                                 }
  92                                 else
  93                                         this->WriteNumeric(ERR_UNKNOWNSNOMASK, "%s %c :is unknown snomask char to me", this->nick.c_str(), *c);
  94
  95                                 oldadding = adding;
  96                         break;
  97                 }
  98
  99                 c++;
 100         }
 101
 102         std::string s = this->FormatNoticeMasks();
 103         if (s.length() == 0)
 104         {
 105                 this->modes[UM_SNOMASK] = false;
 106         }
 107
 108         return output;
 109 }
 110
 111 bool User::IsNoticeMaskSet(unsigned char sm)
 112 {
 113         if (!isalpha(sm))
 114                 return false;
 115         return (snomasks[sm-65]);
 116 }
 117
 118 void User::SetNoticeMask(unsigned char sm, bool value)
 119 {
 120         if (!isalpha(sm))
 121                 return;
 122         snomasks[sm-65] = value;
 123 }
 124
 125 const char* User::FormatNoticeMasks()
 126 {
 127         static char data[MAXBUF];
 128         int offset = 0;
 129
 130         for (int n = 0; n < 64; n++)
 131         {
 132                 if (snomasks[n])
 133                         data[offset++] = n+65;
 134         }
 135
 136         data[offset] = 0;
 137         return data;
 138 }
 139
 140 bool User::IsModeSet(unsigned char m)
 141 {
 142         if (!isalpha(m))
 143                 return false;
 144         return (modes[m-65]);
 145 }
 146
 147 void User::SetMode(unsigned char m, bool value)
 148 {
 149         if (!isalpha(m))
 150                 return;
 151         modes[m-65] = value;
 152 }
 153
 154 const char* User::FormatModes(bool showparameters)
 155 {
 156         static std::string data;
 157         std::string params;
 158         data.clear();
 159
 160         for (unsigned char n = 0; n < 64; n++)
 161         {
 162                 if (modes[n])
 163                 {
 164                         data.push_back(n + 65);
 165                         ModeHandler* mh = ServerInstance->Modes->FindMode(n + 65, MODETYPE_USER);
 166                         if (showparameters && mh && mh->GetNumParams(true))
 167                         {
 168                                 std::string p = mh->GetUserParameter(this);
 169                                 if (p.length())
 170                                         params.append(" ").append(p);
 171                         }
 172                 }
 173         }
 174         data += params;
 175         return data.c_str();
 176 }
 177
 178 User::User(const std::string &uid, const std::string& sid, int type)
 179         : uuid(uid), server(sid), usertype(type)
 180 {
 181         age = ServerInstance->Time();
 182         signon = 0;
 183         registered = 0;
 184         quietquit = quitting = false;
 185         client_sa.sa.sa_family = AF_UNSPEC;
 186
 187         ServerInstance->Logs->Log("USERS", LOG_DEBUG, "New UUID for user: %s", uuid.c_str());
 188
 189         user_hash::iterator finduuid = ServerInstance->Users->uuidlist->find(uuid);
 190         if (finduuid == ServerInstance->Users->uuidlist->end())
 191                 (*ServerInstance->Users->uuidlist)[uuid] = this;
 192         else
 193                 throw CoreException("Duplicate UUID "+std::string(uuid)+" in User constructor");
 194 }
 195
 196 LocalUser::LocalUser(int myfd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* servaddr)
 197         : User(ServerInstance->UIDGen.GetUID(), ServerInstance->Config->ServerName, USERTYPE_LOCAL), eh(this),
 198         localuseriter(ServerInstance->Users->local_users.end()),
 199         bytes_in(0), bytes_out(0), cmds_in(0), cmds_out(0), nping(0), CommandFloodPenalty(0),
 200         already_sent(0)
 201 {
 202         exempt = quitting_sendq = false;
 203         idle_lastmsg = 0;
 204         ident = "unknown";
 205         lastping = 0;
 206         eh.SetFd(myfd);
 207         memcpy(&client_sa, client, sizeof(irc::sockets::sockaddrs));
 208         memcpy(&server_sa, servaddr, sizeof(irc::sockets::sockaddrs));
 209         dhost = host = GetIPString();
 210 }
 211
 212 User::~User()
 213 {
 214         if (ServerInstance->Users->uuidlist->find(uuid) != ServerInstance->Users->uuidlist->end())
 215                 ServerInstance->Logs->Log("USERS", LOG_DEFAULT, "User destructor for %s called without cull", uuid.c_str());
 216 }
 217
 218 const std::string& User::MakeHost()
 219 {
 220         if (!this->cached_makehost.empty())
 221                 return this->cached_makehost;
 222
 223         // XXX: Is there really a need to cache this?
 224         this->cached_makehost = ident + "@" + host;
 225         return this->cached_makehost;
 226 }
 227
 228 const std::string& User::MakeHostIP()
 229 {
 230         if (!this->cached_hostip.empty())
 231                 return this->cached_hostip;
 232
 233         // XXX: Is there really a need to cache this?
 234         this->cached_hostip = ident + "@" + this->GetIPString();
 235         return this->cached_hostip;
 236 }
 237
 238 const std::string& User::GetFullHost()
 239 {
 240         if (!this->cached_fullhost.empty())
 241                 return this->cached_fullhost;
 242
 243         // XXX: Is there really a need to cache this?
 244         this->cached_fullhost = nick + "!" + ident + "@" + dhost;
 245         return this->cached_fullhost;
 246 }
 247
 248 const std::string& User::GetFullRealHost()
 249 {
 250         if (!this->cached_fullrealhost.empty())
 251                 return this->cached_fullrealhost;
 252
 253         // XXX: Is there really a need to cache this?
 254         this->cached_fullrealhost = nick + "!" + ident + "@" + host;
 255         return this->cached_fullrealhost;
 256 }
 257
 258 InviteList& LocalUser::GetInviteList()
 259 {
 260         RemoveExpiredInvites();
 261         return invites;
 262 }
 263
 264 bool LocalUser::RemoveInvite(Channel* chan)
 265 {
 266         Invitation* inv = Invitation::Find(chan, this);
 267         if (inv)
 268         {
 269                 inv->cull();
 270                 delete inv;
 271                 return true;
 272         }
 273         return false;
 274 }
 275
 276 void LocalUser::RemoveExpiredInvites()
 277 {
 278         Invitation::Find(NULL, this);
 279 }
 280
 281 bool User::HasModePermission(unsigned char, ModeType)
 282 {
 283         return true;
 284 }
 285
 286 bool LocalUser::HasModePermission(unsigned char mode, ModeType type)
 287 {
 288         if (!this->IsOper())
 289                 return false;
 290
 291         if (mode < 'A' || mode > ('A' + 64)) return false;
 292
 293         return ((type == MODETYPE_USER ? oper->AllowedUserModes : oper->AllowedChanModes))[(mode - 'A')];
 294
 295 }
 296 /*
 297  * users on remote servers can completely bypass all permissions based checks.
 298  * This prevents desyncs when one server has different type/class tags to another.
 299  * That having been said, this does open things up to the possibility of source changes
 300  * allowing remote kills, etc - but if they have access to the src, they most likely have
 301  * access to the conf - so it's an end to a means either way.
 302  */
 303 bool User::HasPermission(const std::string&)
 304 {
 305         return true;
 306 }
 307
 308 bool LocalUser::HasPermission(const std::string &command)
 309 {
 310         // are they even an oper at all?
 311         if (!this->IsOper())
 312         {
 313                 return false;
 314         }
 315
 316         if (oper->AllowedOperCommands.find(command) != oper->AllowedOperCommands.end())
 317                 return true;
 318         else if (oper->AllowedOperCommands.find("*") != oper->AllowedOperCommands.end())
 319                 return true;
 320
 321         return false;
 322 }
 323
 324 bool User::HasPrivPermission(const std::string &privstr, bool noisy)
 325 {
 326         return true;
 327 }
 328
 329 bool LocalUser::HasPrivPermission(const std::string &privstr, bool noisy)
 330 {
 331         if (!this->IsOper())
 332         {
 333                 if (noisy)
 334                         this->WriteNotice("You are not an oper");
 335                 return false;
 336         }
 337
 338         if (oper->AllowedPrivs.find(privstr) != oper->AllowedPrivs.end())
 339         {
 340                 return true;
 341         }
 342         else if (oper->AllowedPrivs.find("*") != oper->AllowedPrivs.end())
 343         {
 344                 return true;
 345         }
 346
 347         if (noisy)
 348                 this->WriteNotice("Oper type " + oper->name + " does not have access to priv " + privstr);
 349
 350         return false;
 351 }
 352
 353 void UserIOHandler::OnDataReady()
 354 {
 355         if (user->quitting)
 356                 return;
 357
 358         if (recvq.length() > user->MyClass->GetRecvqMax() && !user->HasPrivPermission("users/flood/increased-buffers"))
 359         {
 360                 ServerInstance->Users->QuitUser(user, "RecvQ exceeded");
 361                 ServerInstance->SNO->WriteToSnoMask('a', "User %s RecvQ of %lu exceeds connect class maximum of %lu",
 362                         user->nick.c_str(), (unsigned long)recvq.length(), user->MyClass->GetRecvqMax());
 363                 return;
 364         }
 365         unsigned long sendqmax = ULONG_MAX;
 366         if (!user->HasPrivPermission("users/flood/increased-buffers"))
 367                 sendqmax = user->MyClass->GetSendqSoftMax();
 368         unsigned long penaltymax = ULONG_MAX;
 369         if (!user->HasPrivPermission("users/flood/no-fakelag"))
 370                 penaltymax = user->MyClass->GetPenaltyThreshold() * 1000;
 371
 372         while (user->CommandFloodPenalty < penaltymax && getSendQSize() < sendqmax)
 373         {
 374                 std::string line;
 375                 line.reserve(ServerInstance->Config->Limits.MaxLine);
 376                 std::string::size_type qpos = 0;
 377                 while (qpos < recvq.length())
 378                 {
 379                         char c = recvq[qpos++];
 380                         switch (c)
 381                         {
 382                         case '\0':
 383                                 c = ' ';
 384                                 break;
 385                         case '\r':
 386                                 continue;
 387                         case '\n':
 388                                 goto eol_found;
 389                         }
 390                         if (line.length() < ServerInstance->Config->Limits.MaxLine - 2)
 391                                 line.push_back(c);
 392                 }
 393                 // if we got here, the recvq ran out before we found a newline
 394                 return;
 395 eol_found:
 396                 // just found a newline. Terminate the string, and pull it out of recvq
 397                 recvq = recvq.substr(qpos);
 398
 399                 // TODO should this be moved to when it was inserted in recvq?
 400                 ServerInstance->stats->statsRecv += qpos;
 401                 user->bytes_in += qpos;
 402                 user->cmds_in++;
 403
 404                 ServerInstance->Parser->ProcessBuffer(line, user);
 405                 if (user->quitting)
 406                         return;
 407         }
 408         if (user->CommandFloodPenalty >= penaltymax && !user->MyClass->fakelag)
 409                 ServerInstance->Users->QuitUser(user, "Excess Flood");
 410 }
 411
 412 void UserIOHandler::AddWriteBuf(const std::string &data)
 413 {
 414         if (user->quitting_sendq)
 415                 return;
 416         if (!user->quitting && getSendQSize() + data.length() > user->MyClass->GetSendqHardMax() &&
 417                 !user->HasPrivPermission("users/flood/increased-buffers"))
 418         {
 419                 user->quitting_sendq = true;
 420                 ServerInstance->GlobalCulls.AddSQItem(user);
 421                 return;
 422         }
 423
 424         // We still want to append data to the sendq of a quitting user,
 425         // e.g. their ERROR message that says 'closing link'
 426
 427         WriteData(data);
 428 }
 429
 430 void UserIOHandler::OnError(BufferedSocketError)
 431 {
 432         ServerInstance->Users->QuitUser(user, getError());
 433 }
 434
 435 CullResult User::cull()
 436 {
 437         if (!quitting)
 438                 ServerInstance->Users->QuitUser(this, "Culled without QuitUser");
 439         PurgeEmptyChannels();
 440
 441         if (client_sa.sa.sa_family != AF_UNSPEC)
 442                 ServerInstance->Users->RemoveCloneCounts(this);
 443
 444         return Extensible::cull();
 445 }
 446
 447 CullResult LocalUser::cull()
 448 {
 449         // The iterator is initialized to local_users.end() in the constructor. It is
 450         // overwritten in UserManager::AddUser() with the real iterator so this check
 451         // is only a precaution currently.
 452         if (localuseriter != ServerInstance->Users->local_users.end())
 453         {
 454                 ServerInstance->Users->local_count--;
 455                 ServerInstance->Users->local_users.erase(localuseriter);
 456         }
 457         else
 458                 ServerInstance->Logs->Log("USERS", LOG_DEFAULT, "ERROR: LocalUserIter does not point to a valid entry for " + this->nick);
 459
 460         ClearInvites();
 461         eh.cull();
 462         return User::cull();
 463 }
 464
 465 CullResult FakeUser::cull()
 466 {
 467         // Fake users don't quit, they just get culled.
 468         quitting = true;
 469         ServerInstance->Users->clientlist->erase(nick);
 470         ServerInstance->Users->uuidlist->erase(uuid);
 471         return User::cull();
 472 }
 473
 474 void User::Oper(OperInfo* info)
 475 {
 476         if (this->IsModeSet('o'))
 477                 this->UnOper();
 478
 479         this->modes[UM_OPERATOR] = 1;
 480         this->oper = info;
 481         this->WriteServ("MODE %s :+o", this->nick.c_str());
 482         FOREACH_MOD(I_OnOper, OnOper(this, info->name));
 483
 484         std::string opername;
 485         if (info->oper_block)
 486                 opername = info->oper_block->getString("name");
 487
 488         if (IS_LOCAL(this))
 489         {
 490                 LocalUser* l = IS_LOCAL(this);
 491                 std::string vhost = oper->getConfig("vhost");
 492                 if (!vhost.empty())
 493                         l->ChangeDisplayedHost(vhost.c_str());
 494                 std::string opClass = oper->getConfig("class");
 495                 if (!opClass.empty())
 496                         l->SetClass(opClass);
 497         }
 498
 499         ServerInstance->SNO->WriteToSnoMask('o',"%s (%s@%s) is now an IRC operator of type %s (using oper '%s')",
 500                 nick.c_str(), ident.c_str(), host.c_str(), oper->name.c_str(), opername.c_str());
 501         this->WriteNumeric(381, "%s :You are now %s %s", nick.c_str(), strchr("aeiouAEIOU", oper->name[0]) ? "an" : "a", oper->name.c_str());
 502
 503         ServerInstance->Logs->Log("OPER", LOG_DEFAULT, "%s opered as type: %s", GetFullRealHost().c_str(), oper->name.c_str());
 504         ServerInstance->Users->all_opers.push_back(this);
 505
 506         // Expand permissions from config for faster lookup
 507         if (IS_LOCAL(this))
 508                 oper->init();
 509
 510         FOREACH_MOD(I_OnPostOper,OnPostOper(this, oper->name, opername));
 511 }
 512
 513 void OperInfo::init()
 514 {
 515         AllowedOperCommands.clear();
 516         AllowedPrivs.clear();
 517         AllowedUserModes.reset();
 518         AllowedChanModes.reset();
 519         AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want.
 520
 521         for(std::vector<reference<ConfigTag> >::iterator iter = class_blocks.begin(); iter != class_blocks.end(); ++iter)
 522         {
 523                 ConfigTag* tag = *iter;
 524                 std::string mycmd, mypriv;
 525                 /* Process commands */
 526                 irc::spacesepstream CommandList(tag->getString("commands"));
 527                 while (CommandList.GetToken(mycmd))
 528                 {
 529                         AllowedOperCommands.insert(mycmd);
 530                 }
 531
 532                 irc::spacesepstream PrivList(tag->getString("privs"));
 533                 while (PrivList.GetToken(mypriv))
 534                 {
 535                         AllowedPrivs.insert(mypriv);
 536                 }
 537
 538                 std::string modes = tag->getString("usermodes");
 539                 for (std::string::const_iterator c = modes.begin(); c != modes.end(); ++c)
 540                 {
 541                         if (*c == '*')
 542                         {
 543                                 this->AllowedUserModes.set();
 544                         }
 545                         else if (*c >= 'A' && *c < 'z')
 546                         {
 547                                 this->AllowedUserModes[*c - 'A'] = true;
 548                         }
 549                 }
 550
 551                 modes = tag->getString("chanmodes");
 552                 for (std::string::const_iterator c = modes.begin(); c != modes.end(); ++c)
 553                 {
 554                         if (*c == '*')
 555                         {
 556                                 this->AllowedChanModes.set();
 557                         }
 558                         else if (*c >= 'A' && *c < 'z')
 559                         {
 560                                 this->AllowedChanModes[*c - 'A'] = true;
 561                         }
 562                 }
 563         }
 564 }
 565
 566 void User::UnOper()
 567 {
 568         if (!this->IsOper())
 569                 return;
 570
 571         /*
 572          * unset their oper type (what IS_OPER checks).
 573          * note, order is important - this must come before modes as -o attempts
 574          * to call UnOper. -- w00t
 575          */
 576         oper = NULL;
 577
 578
 579         /* Remove all oper only modes from the user when the deoper - Bug #466*/
 580         std::string moderemove("-");
 581
 582         for (unsigned char letter = 'A'; letter <= 'z'; letter++)
 583         {
 584                 ModeHandler* mh = ServerInstance->Modes->FindMode(letter, MODETYPE_USER);
 585                 if (mh && mh->NeedsOper())
 586                         moderemove += letter;
 587         }
 588
 589
 590         std::vector<std::string> parameters;
 591         parameters.push_back(this->nick);
 592         parameters.push_back(moderemove);
 593
 594         ServerInstance->Parser->CallHandler("MODE", parameters, this);
 595
 596         /* remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 */
 597         ServerInstance->Users->all_opers.remove(this);
 598
 599         this->modes[UM_OPERATOR] = 0;
 600 }
 601
 602 /*
 603  * Check class restrictions
 604  */
 605 void LocalUser::CheckClass()
 606 {
 607         ConnectClass* a = this->MyClass;
 608
 609         if (!a)
 610         {
 611                 ServerInstance->Users->QuitUser(this, "Access denied by configuration");
 612                 return;
 613         }
 614         else if (a->type == CC_DENY)
 615         {
 616                 ServerInstance->Users->QuitUser(this, a->config->getString("reason", "Unauthorised connection"));
 617                 return;
 618         }
 619         else if ((a->GetMaxLocal()) && (ServerInstance->Users->LocalCloneCount(this) > a->GetMaxLocal()))
 620         {
 621                 ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (local)");
 622                 if (a->maxconnwarn)
 623                         ServerInstance->SNO->WriteToSnoMask('a', "WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString().c_str());
 624                 return;
 625         }
 626         else if ((a->GetMaxGlobal()) && (ServerInstance->Users->GlobalCloneCount(this) > a->GetMaxGlobal()))
 627         {
 628                 ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (global)");
 629                 if (a->maxconnwarn)
 630                         ServerInstance->SNO->WriteToSnoMask('a', "WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString().c_str());
 631                 return;
 632         }
 633
 634         this->nping = ServerInstance->Time() + a->GetPingTime() + ServerInstance->Config->dns_timeout;
 635 }
 636
 637 bool LocalUser::CheckLines(bool doZline)
 638 {
 639         const char* check[] = { "G" , "K", (doZline) ? "Z" : NULL, NULL };
 640
 641         if (!this->exempt)
 642         {
 643                 for (int n = 0; check[n]; ++n)
 644                 {
 645                         XLine *r = ServerInstance->XLines->MatchesLine(check[n], this);
 646
 647                         if (r)
 648                         {
 649                                 r->Apply(this);
 650                                 return true;
 651                         }
 652                 }
 653         }
 654
 655         return false;
 656 }
 657
 658 void LocalUser::FullConnect()
 659 {
 660         ServerInstance->stats->statsConnects++;
 661         this->idle_lastmsg = ServerInstance->Time();
 662
 663         /*
 664          * You may be thinking "wtf, we checked this in User::AddClient!" - and yes, we did, BUT.
 665          * At the time AddClient is called, we don't have a resolved host, by here we probably do - which
 666          * may put the user into a totally seperate class with different restrictions! so we *must* check again.
 667          * Don't remove this! -- w00t
 668          */
 669         MyClass = NULL;
 670         SetClass();
 671         CheckClass();
 672         CheckLines();
 673
 674         if (quitting)
 675                 return;
 676
 677         this->WriteNumeric(RPL_WELCOME, "%s :Welcome to the %s IRC Network %s",this->nick.c_str(), ServerInstance->Config->Network.c_str(), GetFullRealHost().c_str());
 678         this->WriteNumeric(RPL_YOURHOSTIS, "%s :Your host is %s, running version %s",this->nick.c_str(),ServerInstance->Config->ServerName.c_str(),BRANCH);
 679         this->WriteNumeric(RPL_SERVERCREATED, "%s :This server was created %s %s", this->nick.c_str(), __TIME__, __DATE__);
 680
 681         const std::string& modelist = ServerInstance->Modes->GetModeListFor004Numeric();
 682         this->WriteNumeric(RPL_SERVERVERSION, "%s %s %s %s", this->nick.c_str(), ServerInstance->Config->ServerName.c_str(), BRANCH, modelist.c_str());
 683
 684         ServerInstance->ISupport.SendTo(this);
 685         this->WriteNumeric(RPL_YOURUUID, "%s %s :your unique ID", this->nick.c_str(), this->uuid.c_str());
 686
 687         /* Now registered */
 688         if (ServerInstance->Users->unregistered_count)
 689                 ServerInstance->Users->unregistered_count--;
 690
 691         /* Trigger MOTD and LUSERS output, give modules a chance too */
 692         ModResult MOD_RESULT;
 693         std::string command("LUSERS");
 694         std::vector<std::string> parameters;
 695         FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, command));
 696         if (!MOD_RESULT)
 697                 ServerInstance->Parser->CallHandler(command, parameters, this);
 698
 699         MOD_RESULT = MOD_RES_PASSTHRU;
 700         command = "MOTD";
 701         FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, command));
 702         if (!MOD_RESULT)
 703                 ServerInstance->Parser->CallHandler(command, parameters, this);
 704
 705         if (ServerInstance->Config->RawLog)
 706                 WriteServ("PRIVMSG %s :*** Raw I/O logging is enabled on this server. All messages, passwords, and commands are being recorded.", nick.c_str());
 707
 708         /*
 709          * We don't set REG_ALL until triggering OnUserConnect, so some module events don't spew out stuff
 710          * for a user that doesn't exist yet.
 711          */
 712         FOREACH_MOD(I_OnUserConnect,OnUserConnect(this));
 713
 714         this->registered = REG_ALL;
 715
 716         FOREACH_MOD(I_OnPostConnect,OnPostConnect(this));
 717
 718         ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d (class %s): %s (%s) [%s]",
 719                 this->GetServerPort(), this->MyClass->name.c_str(), GetFullRealHost().c_str(), this->GetIPString().c_str(), this->fullname.c_str());
 720         ServerInstance->Logs->Log("BANCACHE", LOG_DEBUG, "BanCache: Adding NEGATIVE hit for " + this->GetIPString());
 721         ServerInstance->BanCache->AddHit(this->GetIPString(), "", "");
 722         // reset the flood penalty (which could have been raised due to things like auto +x)
 723         CommandFloodPenalty = 0;
 724 }
 725
 726 void User::InvalidateCache()
 727 {
 728         /* Invalidate cache */
 729         cached_fullhost.clear();
 730         cached_hostip.clear();
 731         cached_makehost.clear();
 732         cached_fullrealhost.clear();
 733 }
 734
 735 bool User::ChangeNick(const std::string& newnick, bool force)
 736 {
 737         if (quitting)
 738         {
 739                 ServerInstance->Logs->Log("USERS", LOG_DEFAULT, "ERROR: Attempted to change nick of a quitting user: " + this->nick);
 740                 return false;
 741         }
 742
 743         if (!force)
 744         {
 745                 ModResult MOD_RESULT;
 746                 FIRST_MOD_RESULT(OnUserPreNick, MOD_RESULT, (this, newnick));
 747
 748                 if (MOD_RESULT == MOD_RES_DENY)
 749                 {
 750                         ServerInstance->stats->statsCollisions++;
 751                         return false;
 752                 }
 753         }
 754
 755         if (assign(newnick) == assign(nick))
 756         {
 757                 // case change, don't need to check Q:lines and such
 758                 // and, if it's identical including case, we can leave right now
 759                 if (newnick == nick)
 760                         return true;
 761         }
 762         else
 763         {
 764                 /*
 765                  * Don't check Q:Lines if it's a server-enforced change, just on the off-chance some fucking *moron*
 766                  * tries to Q:Line SIDs, also, this means we just get our way period, as it really should be.
 767                  * Thanks Kein for finding this. -- w00t
 768                  *
 769                  * Also don't check Q:Lines for remote nickchanges, they should have our Q:Lines anyway to enforce themselves.
 770                  *              -- w00t
 771                  */
 772                 if (IS_LOCAL(this) && !force)
 773                 {
 774                         XLine* mq = ServerInstance->XLines->MatchesLine("Q",newnick);
 775                         if (mq)
 776                         {
 777                                 if (this->registered == REG_ALL)
 778                                 {
 779                                         ServerInstance->SNO->WriteGlobalSno('a', "Q-Lined nickname %s from %s: %s",
 780                                                 newnick.c_str(), GetFullRealHost().c_str(), mq->reason.c_str());
 781                                 }
 782                                 this->WriteNumeric(432, "%s %s :Invalid nickname: %s",this->nick.c_str(), newnick.c_str(), mq->reason.c_str());
 783                                 return false;
 784                         }
 785
 786                         if (ServerInstance->Config->RestrictBannedUsers)
 787                         {
 788                                 for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
 789                                 {
 790                                         Channel *chan = *i;
 791                                         if (chan->GetPrefixValue(this) < VOICE_VALUE && chan->IsBanned(this))
 792                                         {
 793                                                 this->WriteNumeric(404, "%s %s :Cannot send to channel (you're banned)", this->nick.c_str(), chan->name.c_str());
 794                                                 return false;
 795                                         }
 796                                 }
 797                         }
 798                 }
 799
 800                 /*
 801                  * Uh oh.. if the nickname is in use, and it's not in use by the person using it (doh) --
 802                  * then we have a potential collide. Check whether someone else is camping on the nick
 803                  * (i.e. connect -> send NICK, don't send USER.) If they are camping, force-change the
 804                  * camper to their UID, and allow the incoming nick change.
 805                  *
 806                  * If the guy using the nick is already using it, tell the incoming nick change to gtfo,
 807                  * because the nick is already (rightfully) in use. -- w00t
 808                  */
 809                 User* InUse = ServerInstance->FindNickOnly(newnick);
 810                 if (InUse && (InUse != this))
 811                 {
 812                         if (InUse->registered != REG_ALL)
 813                         {
 814                                 /* force the camper to their UUID, and ask them to re-send a NICK. */
 815                                 InUse->WriteTo(InUse, "NICK %s", InUse->uuid.c_str());
 816                                 InUse->WriteNumeric(433, "%s %s :Nickname overruled.", InUse->nick.c_str(), InUse->nick.c_str());
 817
 818                                 ServerInstance->Users->clientlist->erase(InUse->nick);
 819                                 (*(ServerInstance->Users->clientlist))[InUse->uuid] = InUse;
 820
 821                                 InUse->nick = InUse->uuid;
 822                                 InUse->InvalidateCache();
 823                                 InUse->registered &= ~REG_NICK;
 824                         }
 825                         else
 826                         {
 827                                 /* No camping, tell the incoming user  to stop trying to change nick ;p */
 828                                 this->WriteNumeric(433, "%s %s :Nickname is already in use.", this->registered >= REG_NICK ? this->nick.c_str() : "*", newnick.c_str());
 829                                 return false;
 830                         }
 831                 }
 832         }
 833
 834         if (this->registered == REG_ALL)
 835                 this->WriteCommon("NICK %s",newnick.c_str());
 836         std::string oldnick = nick;
 837         nick = newnick;
 838
 839         InvalidateCache();
 840         ServerInstance->Users->clientlist->erase(oldnick);
 841         (*(ServerInstance->Users->clientlist))[newnick] = this;
 842
 843         if (registered == REG_ALL)
 844                 FOREACH_MOD(I_OnUserPostNick,OnUserPostNick(this,oldnick));
 845
 846         return true;
 847 }
 848
 849 int LocalUser::GetServerPort()
 850 {
 851         switch (this->server_sa.sa.sa_family)
 852         {
 853                 case AF_INET6:
 854                         return htons(this->server_sa.in6.sin6_port);
 855                 case AF_INET:
 856                         return htons(this->server_sa.in4.sin_port);
 857         }
 858         return 0;
 859 }
 860
 861 const std::string& User::GetIPString()
 862 {
 863         int port;
 864         if (cachedip.empty())
 865         {
 866                 irc::sockets::satoap(client_sa, cachedip, port);
 867                 /* IP addresses starting with a : on irc are a Bad Thing (tm) */
 868                 if (cachedip[0] == ':')
 869                         cachedip.insert(0,1,'0');
 870         }
 871
 872         return cachedip;
 873 }
 874
 875 irc::sockets::cidr_mask User::GetCIDRMask()
 876 {
 877         int range = 0;
 878         switch (client_sa.sa.sa_family)
 879         {
 880                 case AF_INET6:
 881                         range = ServerInstance->Config->c_ipv6_range;
 882                         break;
 883                 case AF_INET:
 884                         range = ServerInstance->Config->c_ipv4_range;
 885                         break;
 886         }
 887         return irc::sockets::cidr_mask(client_sa, range);
 888 }
 889
 890 bool User::SetClientIP(const char* sip, bool recheck_eline)
 891 {
 892         cachedip.clear();
 893         cached_hostip.clear();
 894         return irc::sockets::aptosa(sip, 0, client_sa);
 895 }
 896
 897 void User::SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline)
 898 {
 899         cachedip.clear();
 900         cached_hostip.clear();
 901         memcpy(&client_sa, &sa, sizeof(irc::sockets::sockaddrs));
 902 }
 903
 904 bool LocalUser::SetClientIP(const char* sip, bool recheck_eline)
 905 {
 906         irc::sockets::sockaddrs sa;
 907         if (!irc::sockets::aptosa(sip, 0, sa))
 908                 // Invalid
 909                 return false;
 910
 911         LocalUser::SetClientIP(sa, recheck_eline);
 912         return true;
 913 }
 914
 915 void LocalUser::SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline)
 916 {
 917         if (sa != client_sa)
 918         {
 919                 User::SetClientIP(sa);
 920                 if (recheck_eline)
 921                         this->exempt = (ServerInstance->XLines->MatchesLine("E", this) != NULL);
 922
 923                 FOREACH_MOD(I_OnSetUserIP,OnSetUserIP(this));
 924         }
 925 }
 926
 927 static std::string wide_newline("\r\n");
 928
 929 void User::Write(const std::string& text)
 930 {
 931 }
 932
 933 void User::Write(const char *text, ...)
 934 {
 935 }
 936
 937 void LocalUser::Write(const std::string& text)
 938 {
 939         if (!ServerInstance->SE->BoundsCheckFd(&eh))
 940                 return;
 941
 942         if (text.length() > ServerInstance->Config->Limits.MaxLine - 2)
 943         {
 944                 // this should happen rarely or never. Crop the string at 512 and try again.
 945                 std::string try_again = text.substr(0, ServerInstance->Config->Limits.MaxLine - 2);
 946                 Write(try_again);
 947                 return;
 948         }
 949
 950         ServerInstance->Logs->Log("USEROUTPUT", LOG_RAWIO, "C[%s] O %s", uuid.c_str(), text.c_str());
 951
 952         eh.AddWriteBuf(text);
 953         eh.AddWriteBuf(wide_newline);
 954
 955         ServerInstance->stats->statsSent += text.length() + 2;
 956         this->bytes_out += text.length() + 2;
 957         this->cmds_out++;
 958 }
 959
 960 /** Write()
 961  */
 962 void LocalUser::Write(const char *text, ...)
 963 {
 964         std::string textbuffer;
 965         VAFORMAT(textbuffer, text, text);
 966         this->Write(textbuffer);
 967 }
 968
 969 void User::WriteServ(const std::string& text)
 970 {
 971         this->Write(":%s %s",ServerInstance->Config->ServerName.c_str(),text.c_str());
 972 }
 973
 974 /** WriteServ()
 975  *  Same as Write(), except `text' is prefixed with `:server.name '.
 976  */
 977 void User::WriteServ(const char* text, ...)
 978 {
 979         std::string textbuffer;
 980         VAFORMAT(textbuffer, text, text);
 981         this->WriteServ(textbuffer);
 982 }
 983
 984 void User::WriteNotice(const std::string& text)
 985 {
 986         this->WriteServ("NOTICE " + (this->registered == REG_ALL ? this->nick : "*") + " :" + text);
 987 }
 988
 989 void User::WriteNumeric(unsigned int numeric, const char* text, ...)
 990 {
 991         std::string textbuffer;
 992         VAFORMAT(textbuffer, text, text);
 993         this->WriteNumeric(numeric, textbuffer);
 994 }
 995
 996 void User::WriteNumeric(unsigned int numeric, const std::string &text)
 997 {
 998         ModResult MOD_RESULT;
 999
1000         FIRST_MOD_RESULT(OnNumeric, MOD_RESULT, (this, numeric, text));
1001
1002         if (MOD_RESULT == MOD_RES_DENY)
1003                 return;
1004
1005         const std::string message = InspIRCd::Format(":%s %03u %s", ServerInstance->Config->ServerName.c_str(),
1006                 numeric, text.c_str());
1007         this->Write(message);
1008 }
1009
1010 void User::WriteFrom(User *user, const std::string &text)
1011 {
1012         const std::string message = ":" + user->GetFullHost() + " " + text;
1013         this->Write(message);
1014 }
1015
1016
1017 /* write text from an originating user to originating user */
1018
1019 void User::WriteFrom(User *user, const char* text, ...)
1020 {
1021         std::string textbuffer;
1022         VAFORMAT(textbuffer, text, text);
1023         this->WriteFrom(user, textbuffer);
1024 }
1025
1026
1027 /* write text to an destination user from a source user (e.g. user privmsg) */
1028
1029 void User::WriteTo(User *dest, const char *data, ...)
1030 {
1031         std::string textbuffer;
1032         VAFORMAT(textbuffer, data, data);
1033         this->WriteTo(dest, textbuffer);
1034 }
1035
1036 void User::WriteTo(User *dest, const std::string &data)
1037 {
1038         dest->WriteFrom(this, data);
1039 }
1040
1041 void User::WriteCommon(const char* text, ...)
1042 {
1043         if (this->registered != REG_ALL || quitting)
1044                 return;
1045
1046         std::string textbuffer;
1047         VAFORMAT(textbuffer, text, text);
1048         textbuffer = ":" + this->GetFullHost() + " " + textbuffer;
1049         this->WriteCommonRaw(textbuffer, true);
1050 }
1051
1052 void User::WriteCommonExcept(const char* text, ...)
1053 {
1054         if (this->registered != REG_ALL || quitting)
1055                 return;
1056
1057         std::string textbuffer;
1058         VAFORMAT(textbuffer, text, text);
1059         textbuffer = ":" + this->GetFullHost() + " " + textbuffer;
1060         this->WriteCommonRaw(textbuffer, false);
1061 }
1062
1063 void User::WriteCommonRaw(const std::string &line, bool include_self)
1064 {
1065         if (this->registered != REG_ALL || quitting)
1066                 return;
1067
1068         LocalUser::already_sent_id++;
1069
1070         UserChanList include_c(chans);
1071         std::map<User*,bool> exceptions;
1072
1073         exceptions[this] = include_self;
1074
1075         FOREACH_MOD(I_OnBuildNeighborList,OnBuildNeighborList(this, include_c, exceptions));
1076
1077         for (std::map<User*,bool>::iterator i = exceptions.begin(); i != exceptions.end(); ++i)
1078         {
1079                 LocalUser* u = IS_LOCAL(i->first);
1080                 if (u && !u->quitting)
1081                 {
1082                         u->already_sent = LocalUser::already_sent_id;
1083                         if (i->second)
1084                                 u->Write(line);
1085                 }
1086         }
1087         for (UCListIter v = include_c.begin(); v != include_c.end(); ++v)
1088         {
1089                 Channel* c = *v;
1090                 const UserMembList* ulist = c->GetUsers();
1091                 for (UserMembList::const_iterator i = ulist->begin(); i != ulist->end(); i++)
1092                 {
1093                         LocalUser* u = IS_LOCAL(i->first);
1094                         if (u && !u->quitting && u->already_sent != LocalUser::already_sent_id)
1095                         {
1096                                 u->already_sent = LocalUser::already_sent_id;
1097                                 u->Write(line);
1098                         }
1099                 }
1100         }
1101 }
1102
1103 void User::WriteCommonQuit(const std::string &normal_text, const std::string &oper_text)
1104 {
1105         if (this->registered != REG_ALL)
1106                 return;
1107
1108         already_sent_t uniq_id = ++LocalUser::already_sent_id;
1109
1110         const std::string normalMessage = ":" + this->GetFullHost() + " QUIT :" + normal_text;
1111         const std::string operMessage = ":" + this->GetFullHost() + " QUIT :" + oper_text;
1112
1113         UserChanList include_c(chans);
1114         std::map<User*,bool> exceptions;
1115
1116         FOREACH_MOD(I_OnBuildNeighborList,OnBuildNeighborList(this, include_c, exceptions));
1117
1118         for (std::map<User*,bool>::iterator i = exceptions.begin(); i != exceptions.end(); ++i)
1119         {
1120                 LocalUser* u = IS_LOCAL(i->first);
1121                 if (u && !u->quitting)
1122                 {
1123                         u->already_sent = uniq_id;
1124                         if (i->second)
1125                                 u->Write(u->IsOper() ? operMessage : normalMessage);
1126                 }
1127         }
1128         for (UCListIter v = include_c.begin(); v != include_c.end(); ++v)
1129         {
1130                 const UserMembList* ulist = (*v)->GetUsers();
1131                 for (UserMembList::const_iterator i = ulist->begin(); i != ulist->end(); i++)
1132                 {
1133                         LocalUser* u = IS_LOCAL(i->first);
1134                         if (u && !u->quitting && (u->already_sent != uniq_id))
1135                         {
1136                                 u->already_sent = uniq_id;
1137                                 u->Write(u->IsOper() ? operMessage : normalMessage);
1138                         }
1139                 }
1140         }
1141 }
1142
1143 void LocalUser::SendText(const std::string& line)
1144 {
1145         Write(line);
1146 }
1147
1148 void RemoteUser::SendText(const std::string& line)
1149 {
1150         ServerInstance->PI->PushToClient(this, line);
1151 }
1152
1153 void FakeUser::SendText(const std::string& line)
1154 {
1155 }
1156
1157 void User::SendText(const char *text, ...)
1158 {
1159         std::string line;
1160         VAFORMAT(line, text, text);
1161         SendText(line);
1162 }
1163
1164 void User::SendText(const std::string &LinePrefix, std::stringstream &TextStream)
1165 {
1166         char line[MAXBUF];
1167         int start_pos = LinePrefix.length();
1168         int pos = start_pos;
1169         memcpy(line, LinePrefix.data(), pos);
1170         std::string Word;
1171         while (TextStream >> Word)
1172         {
1173                 int len = Word.length();
1174                 if (pos + len + 12 > MAXBUF)
1175                 {
1176                         line[pos] = '\0';
1177                         SendText(std::string(line));
1178                         pos = start_pos;
1179                 }
1180                 line[pos] = ' ';
1181                 memcpy(line + pos + 1, Word.data(), len);
1182                 pos += len + 1;
1183         }
1184         line[pos] = '\0';
1185         SendText(std::string(line));
1186 }
1187
1188 /* return 0 or 1 depending if users u and u2 share one or more common channels
1189  * (used by QUIT, NICK etc which arent channel specific notices)
1190  *
1191  * The old algorithm in 1.0 for this was relatively inefficient, iterating over
1192  * the first users channels then the second users channels within the outer loop,
1193  * therefore it was a maximum of x*y iterations (upon returning 0 and checking
1194  * all possible iterations). However this new function instead checks against the
1195  * channel's userlist in the inner loop which is a std::map<User*,User*>
1196  * and saves us time as we already know what pointer value we are after.
1197  * Don't quote me on the maths as i am not a mathematician or computer scientist,
1198  * but i believe this algorithm is now x+(log y) maximum iterations instead.
1199  */
1200 bool User::SharesChannelWith(User *other)
1201 {
1202         if ((!other) || (this->registered != REG_ALL) || (other->registered != REG_ALL))
1203                 return false;
1204
1205         /* Outer loop */
1206         for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
1207         {
1208                 /* Eliminate the inner loop (which used to be ~equal in size to the outer loop)
1209                  * by replacing it with a map::find which *should* be more efficient
1210                  */
1211                 if ((*i)->HasUser(other))
1212                         return true;
1213         }
1214         return false;
1215 }
1216
1217 bool User::ChangeName(const char* gecos)
1218 {
1219         if (!this->fullname.compare(gecos))
1220                 return true;
1221
1222         if (IS_LOCAL(this))
1223         {
1224                 ModResult MOD_RESULT;
1225                 FIRST_MOD_RESULT(OnChangeLocalUserGECOS, MOD_RESULT, (IS_LOCAL(this),gecos));
1226                 if (MOD_RESULT == MOD_RES_DENY)
1227                         return false;
1228                 FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos));
1229         }
1230         this->fullname.assign(gecos, 0, ServerInstance->Config->Limits.MaxGecos);
1231
1232         return true;
1233 }
1234
1235 void User::DoHostCycle(const std::string &quitline)
1236 {
1237         if (!ServerInstance->Config->CycleHosts)
1238                 return;
1239
1240         already_sent_t silent_id = ++LocalUser::already_sent_id;
1241         already_sent_t seen_id = ++LocalUser::already_sent_id;
1242
1243         UserChanList include_c(chans);
1244         std::map<User*,bool> exceptions;
1245
1246         FOREACH_MOD(I_OnBuildNeighborList,OnBuildNeighborList(this, include_c, exceptions));
1247
1248         for (std::map<User*,bool>::iterator i = exceptions.begin(); i != exceptions.end(); ++i)
1249         {
1250                 LocalUser* u = IS_LOCAL(i->first);
1251                 if (u && !u->quitting)
1252                 {
1253                         if (i->second)
1254                         {
1255                                 u->already_sent = seen_id;
1256                                 u->Write(quitline);
1257                         }
1258                         else
1259                         {
1260                                 u->already_sent = silent_id;
1261                         }
1262                 }
1263         }
1264         for (UCListIter v = include_c.begin(); v != include_c.end(); ++v)
1265         {
1266                 Channel* c = *v;
1267                 Membership* memb = c->GetUser(this);
1268                 const std::string joinline = ":" + GetFullHost() + " JOIN " + c->name;
1269                 std::string modeline;
1270
1271                 if (!memb->modes.empty())
1272                 {
1273                         modeline = ":" + (ServerInstance->Config->CycleHostsFromUser ? GetFullHost() : ServerInstance->Config->ServerName)
1274                                 + " MODE " + c->name + " +" + memb->modes;
1275
1276                         for (size_t i = 0; i < memb->modes.length(); i++)
1277                                 modeline.append(" ").append(nick);
1278                 }
1279
1280                 const UserMembList *ulist = c->GetUsers();
1281                 for (UserMembList::const_iterator i = ulist->begin(); i != ulist->end(); i++)
1282                 {
1283                         LocalUser* u = IS_LOCAL(i->first);
1284                         if (u == NULL || u == this)
1285                                 continue;
1286                         if (u->already_sent == silent_id)
1287                                 continue;
1288
1289                         if (u->already_sent != seen_id)
1290                         {
1291                                 u->Write(quitline);
1292                                 u->already_sent = seen_id;
1293                         }
1294                         u->Write(joinline);
1295                         if (!memb->modes.empty())
1296                                 u->Write(modeline);
1297                 }
1298         }
1299 }
1300
1301 bool User::ChangeDisplayedHost(const char* shost)
1302 {
1303         if (dhost == shost)
1304                 return true;
1305
1306         if (IS_LOCAL(this))
1307         {
1308                 ModResult MOD_RESULT;
1309                 FIRST_MOD_RESULT(OnChangeLocalUserHost, MOD_RESULT, (IS_LOCAL(this),shost));
1310                 if (MOD_RESULT == MOD_RES_DENY)
1311                         return false;
1312         }
1313
1314         FOREACH_MOD(I_OnChangeHost, OnChangeHost(this,shost));
1315
1316         std::string quitstr = ":" + GetFullHost() + " QUIT :Changing host";
1317
1318         /* Fix by Om: User::dhost is 65 long, this was truncating some long hosts */
1319         this->dhost.assign(shost, 0, 64);
1320
1321         this->InvalidateCache();
1322
1323         this->DoHostCycle(quitstr);
1324
1325         if (IS_LOCAL(this))
1326                 this->WriteNumeric(RPL_YOURDISPLAYEDHOST, "%s %s :is now your displayed host",this->nick.c_str(),this->dhost.c_str());
1327
1328         return true;
1329 }
1330
1331 bool User::ChangeIdent(const char* newident)
1332 {
1333         if (this->ident == newident)
1334                 return true;
1335
1336         FOREACH_MOD(I_OnChangeIdent, OnChangeIdent(this,newident));
1337
1338         std::string quitstr = ":" + GetFullHost() + " QUIT :Changing ident";
1339
1340         this->ident.assign(newident, 0, ServerInstance->Config->Limits.IdentMax);
1341
1342         this->InvalidateCache();
1343
1344         this->DoHostCycle(quitstr);
1345
1346         return true;
1347 }
1348
1349 void User::SendAll(const char* command, const char* text, ...)
1350 {
1351         std::string textbuffer;
1352         VAFORMAT(textbuffer, text, text);
1353         const std::string message = ":" + this->GetFullHost() + " " + command + " $* :" + textbuffer;
1354
1355         for (LocalUserList::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++)
1356         {
1357                 if ((*i)->registered == REG_ALL)
1358                         (*i)->Write(message);
1359         }
1360 }
1361
1362 /*
1363  * Sets a user's connection class.
1364  * If the class name is provided, it will be used. Otherwise, the class will be guessed using host/ip/ident/etc.
1365  * NOTE: If the <ALLOW> or <DENY> tag specifies an ip, and this user resolves,
1366  * then their ip will be taken as 'priority' anyway, so for example,
1367  * <connect allow="127.0.0.1"> will match joe!bloggs@localhost
1368  */
1369 void LocalUser::SetClass(const std::string &explicit_name)
1370 {
1371         ConnectClass *found = NULL;
1372
1373         ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Setting connect class for UID %s", this->uuid.c_str());
1374
1375         if (!explicit_name.empty())
1376         {
1377                 for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++)
1378                 {
1379                         ConnectClass* c = *i;
1380
1381                         if (explicit_name == c->name)
1382                         {
1383                                 ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Explicitly set to %s", explicit_name.c_str());
1384                                 found = c;
1385                         }
1386                 }
1387         }
1388         else
1389         {
1390                 for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++)
1391                 {
1392                         ConnectClass* c = *i;
1393                         ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Checking %s", c->GetName().c_str());
1394
1395                         ModResult MOD_RESULT;
1396                         FIRST_MOD_RESULT(OnSetConnectClass, MOD_RESULT, (this,c));
1397                         if (MOD_RESULT == MOD_RES_DENY)
1398                                 continue;
1399                         if (MOD_RESULT == MOD_RES_ALLOW)
1400                         {
1401                                 ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Class forced by module to %s", c->GetName().c_str());
1402                                 found = c;
1403                                 break;
1404                         }
1405
1406                         if (c->type == CC_NAMED)
1407                                 continue;
1408
1409                         bool regdone = (registered != REG_NONE);
1410                         if (c->config->getBool("registered", regdone) != regdone)
1411                                 continue;
1412
1413                         /* check if host matches.. */
1414                         if (!InspIRCd::MatchCIDR(this->GetIPString(), c->GetHost(), NULL) &&
1415                             !InspIRCd::MatchCIDR(this->host, c->GetHost(), NULL))
1416                         {
1417                                 ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "No host match (for %s)", c->GetHost().c_str());
1418                                 continue;
1419                         }
1420
1421                         /*
1422                          * deny change if change will take class over the limit check it HERE, not after we found a matching class,
1423                          * because we should attempt to find another class if this one doesn't match us. -- w00t
1424                          */
1425                         if (c->limit && (c->GetReferenceCount() >= c->limit))
1426                         {
1427                                 ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "OOPS: Connect class limit (%lu) hit, denying", c->limit);
1428                                 continue;
1429                         }
1430
1431                         /* if it requires a port ... */
1432                         int port = c->config->getInt("port");
1433                         if (port)
1434                         {
1435                                 ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Requires port (%d)", port);
1436
1437                                 /* and our port doesn't match, fail. */
1438                                 if (this->GetServerPort() != port)
1439                                         continue;
1440                         }
1441
1442                         if (regdone && !c->config->getString("password").empty())
1443                         {
1444                                 if (ServerInstance->PassCompare(this, c->config->getString("password"), password, c->config->getString("hash")))
1445                                 {
1446                                         ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "Bad password, skipping");
1447                                         continue;
1448                                 }
1449                         }
1450
1451                         /* we stop at the first class that meets ALL critera. */
1452                         found = c;
1453                         break;
1454                 }
1455         }
1456
1457         /*
1458          * Okay, assuming we found a class that matches.. switch us into that class, keeping refcounts up to date.
1459          */
1460         if (found)
1461         {
1462                 MyClass = found;
1463         }
1464 }
1465
1466 /* looks up a users password for their connection class (<ALLOW>/<DENY> tags)
1467  * NOTE: If the <ALLOW> or <DENY> tag specifies an ip, and this user resolves,
1468  * then their ip will be taken as 'priority' anyway, so for example,
1469  * <connect allow="127.0.0.1"> will match joe!bloggs@localhost
1470  */
1471 ConnectClass* LocalUser::GetClass()
1472 {
1473         return MyClass;
1474 }
1475
1476 ConnectClass* User::GetClass()
1477 {
1478         return NULL;
1479 }
1480
1481 void User::PurgeEmptyChannels()
1482 {
1483         // firstly decrement the count on each channel
1484         for (UCListIter f = this->chans.begin(); f != this->chans.end(); f++)
1485         {
1486                 Channel* c = *f;
1487                 c->DelUser(this);
1488         }
1489
1490         this->UnOper();
1491 }
1492
1493 const std::string& FakeUser::GetFullHost()
1494 {
1495         if (!ServerInstance->Config->HideWhoisServer.empty())
1496                 return ServerInstance->Config->HideWhoisServer;
1497         return server;
1498 }
1499
1500 const std::string& FakeUser::GetFullRealHost()
1501 {
1502         if (!ServerInstance->Config->HideWhoisServer.empty())
1503                 return ServerInstance->Config->HideWhoisServer;
1504         return server;
1505 }
1506
1507 ConnectClass::ConnectClass(ConfigTag* tag, char t, const std::string& mask)
1508         : config(tag), type(t), fakelag(true), name("unnamed"), registration_timeout(0), host(mask),
1509         pingtime(0), softsendqmax(0), hardsendqmax(0), recvqmax(0),
1510         penaltythreshold(0), commandrate(0), maxlocal(0), maxglobal(0), maxconnwarn(true), maxchans(0),
1511         limit(0), nouserdns(false)
1512 {
1513 }
1514
1515 ConnectClass::ConnectClass(ConfigTag* tag, char t, const std::string& mask, const ConnectClass& parent)
1516         : config(tag), type(t), fakelag(parent.fakelag), name("unnamed"),
1517         registration_timeout(parent.registration_timeout), host(mask), pingtime(parent.pingtime),
1518         softsendqmax(parent.softsendqmax), hardsendqmax(parent.hardsendqmax), recvqmax(parent.recvqmax),
1519         penaltythreshold(parent.penaltythreshold), commandrate(parent.commandrate),
1520         maxlocal(parent.maxlocal), maxglobal(parent.maxglobal), maxconnwarn(parent.maxconnwarn), maxchans(parent.maxchans),
1521         limit(parent.limit), nouserdns(parent.nouserdns)
1522 {
1523 }
1524
1525 void ConnectClass::Update(const ConnectClass* src)
1526 {
1527         config = src->config;
1528         type = src->type;
1529         fakelag = src->fakelag;
1530         name = src->name;
1531         registration_timeout = src->registration_timeout;
1532         host = src->host;
1533         pingtime = src->pingtime;
1534         softsendqmax = src->softsendqmax;
1535         hardsendqmax = src->hardsendqmax;
1536         recvqmax = src->recvqmax;
1537         penaltythreshold = src->penaltythreshold;
1538         commandrate = src->commandrate;
1539         maxlocal = src->maxlocal;
1540         maxglobal = src->maxglobal;
1541         maxconnwarn = src->maxconnwarn;
1542         maxchans = src->maxchans;
1543         limit = src->limit;
1544         nouserdns = src->nouserdns;
1545 }