src/users.cpp

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