X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fusers.cpp;h=eb87824fcf1f22d7ba543f49edc6d61931c1d9f7;hb=0a1f9bc59494a532a91bc9c8afcecb31ece656ee;hp=41caa5c5a4b8a69cef4c8e6d97a5abc92cdc550c;hpb=6efee33e920a15fb2bd14a4c5275f678d33318cb;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/users.cpp b/src/users.cpp index 41caa5c5a..eb87824fc 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -26,6 +26,8 @@ #include "inspircd.h" #include "xline.h" +ClientProtocol::MessageList LocalUser::sendmsglist; + bool User::IsNoticeMaskSet(unsigned char sm) { if (!isalpha(sm)) @@ -87,6 +89,7 @@ User::User(const std::string& uid, Server* srv, UserType type) LocalUser::LocalUser(int myfd, irc::sockets::sockaddrs* client, irc::sockets::sockaddrs* servaddr) : User(ServerInstance->UIDGen.GetUID(), ServerInstance->FakeClient->server, USERTYPE_LOCAL) , eh(this) + , serializer(NULL) , bytes_in(0) , bytes_out(0) , cmds_in(0) @@ -227,37 +230,56 @@ void UserIOHandler::OnDataReady() user->nick.c_str(), (unsigned long)recvq.length(), user->MyClass->GetRecvqMax()); return; } + unsigned long sendqmax = ULONG_MAX; if (!user->HasPrivPermission("users/flood/increased-buffers")) sendqmax = user->MyClass->GetSendqSoftMax(); + unsigned long penaltymax = ULONG_MAX; if (!user->HasPrivPermission("users/flood/no-fakelag")) penaltymax = user->MyClass->GetPenaltyThreshold() * 1000; + // The maximum size of an IRC message minus the terminating CR+LF. + const size_t maxmessage = ServerInstance->Config->Limits.MaxLine - 2; + std::string line; + line.reserve(maxmessage); + + bool eol_found; + std::string::size_type qpos; + while (user->CommandFloodPenalty < penaltymax && getSendQSize() < sendqmax) { - std::string line; - line.reserve(ServerInstance->Config->Limits.MaxLine); - std::string::size_type qpos = 0; - while (qpos < recvq.length()) + qpos = 0; + eol_found = false; + + const size_t qlen = recvq.length(); + while (qpos < qlen) { char c = recvq[qpos++]; switch (c) { - case '\0': - c = ' '; - break; - case '\r': - continue; - case '\n': - goto eol_found; + case '\0': + c = ' '; + break; + case '\r': + continue; + case '\n': + eol_found = true; + break; } - if (line.length() < ServerInstance->Config->Limits.MaxLine - 2) + + if (eol_found) + break; + + if (line.length() < maxmessage) line.push_back(c); } - // if we got here, the recvq ran out before we found a newline - return; -eol_found: + + // if we return here, we haven't found a newline and make no modifications to recvq + // so we can wait for more data + if (!eol_found) + return; + // just found a newline. Terminate the string, and pull it out of recvq recvq.erase(0, qpos); @@ -266,10 +288,14 @@ eol_found: user->bytes_in += qpos; user->cmds_in++; - ServerInstance->Parser.ProcessBuffer(line, user); + ServerInstance->Parser.ProcessBuffer(user, line); if (user->quitting) return; + + // clear() does not reclaim memory associated with the string, so our .reserve() call is safe + line.clear(); } + if (user->CommandFloodPenalty >= penaltymax && !user->MyClass->fakelag) ServerInstance->Users->QuitUser(user, "Excess Flood"); } @@ -292,6 +318,13 @@ void UserIOHandler::AddWriteBuf(const std::string &data) WriteData(data); } +bool UserIOHandler::OnSetEndPoint(const irc::sockets::sockaddrs& server, const irc::sockets::sockaddrs& client) +{ + memcpy(&user->server_sa, &server, sizeof(irc::sockets::sockaddrs)); + user->SetClientIP(client); + return !user->quitting; +} + void UserIOHandler::OnError(BufferedSocketError) { ServerInstance->Users->QuitUser(user, getError()); @@ -302,7 +335,7 @@ CullResult User::cull() if (!quitting) ServerInstance->Users->QuitUser(this, "Culled without QuitUser"); - if (client_sa.sa.sa_family != AF_UNSPEC) + if (client_sa.family() != AF_UNSPEC) ServerInstance->Users->RemoveCloneCounts(this); return Extensible::cull(); @@ -325,12 +358,23 @@ CullResult FakeUser::cull() void User::Oper(OperInfo* info) { ModeHandler* opermh = ServerInstance->Modes->FindMode('o', MODETYPE_USER); - if (this->IsModeSet(opermh)) - this->UnOper(); - - this->SetMode(opermh, true); + if (opermh) + { + if (this->IsModeSet(opermh)) + this->UnOper(); + this->SetMode(opermh, true); + } this->oper = info; - this->WriteCommand("MODE", "+o"); + + LocalUser* localuser = IS_LOCAL(this); + if (localuser) + { + Modes::ChangeList changelist; + changelist.push_add(opermh); + ClientProtocol::Events::Mode modemsg(ServerInstance->FakeClient, NULL, localuser, changelist); + localuser->Send(modemsg); + } + FOREACH_MOD(OnOper, (this, info->name)); std::string opername; @@ -352,11 +396,10 @@ void User::Oper(OperInfo* info) nick.c_str(), ident.c_str(), GetRealHost().c_str(), oper->name.c_str(), opername.c_str()); this->WriteNumeric(RPL_YOUAREOPER, InspIRCd::Format("You are now %s %s", strchr("aeiouAEIOU", oper->name[0]) ? "an" : "a", oper->name.c_str())); - ServerInstance->Logs->Log("OPER", LOG_DEFAULT, "%s opered as type: %s", GetFullRealHost().c_str(), oper->name.c_str()); ServerInstance->Users->all_opers.push_back(this); // Expand permissions from config for faster lookup - if (IS_LOCAL(this)) + if (localuser) oper->init(); FOREACH_MOD(OnPostOper, (this, oper->name, opername)); @@ -434,7 +477,9 @@ void User::UnOper() stdalgo::vector::swaperase(ServerInstance->Users->all_opers, this); ModeHandler* opermh = ServerInstance->Modes->FindMode('o', MODETYPE_USER); - this->SetMode(opermh, false); + if (opermh) + this->SetMode(opermh, false); + FOREACH_MOD(OnPostDeoper, (this)); } /* @@ -516,48 +561,21 @@ void LocalUser::FullConnect() if (quitting) return; - this->WriteNumeric(RPL_WELCOME, InspIRCd::Format("Welcome to the %s IRC Network %s", ServerInstance->Config->Network.c_str(), GetFullRealHost().c_str())); - this->WriteNumeric(RPL_YOURHOSTIS, InspIRCd::Format("Your host is %s, running version %s", ServerInstance->Config->ServerName.c_str(), INSPIRCD_BRANCH)); - this->WriteNumeric(RPL_SERVERCREATED, InspIRCd::TimeString(ServerInstance->startup_time, "This server was created %H:%M:%S %b %d %Y")); - - const TR1NS::array& modelist = ServerInstance->Modes->GetModeListFor004Numeric(); - this->WriteNumeric(RPL_SERVERVERSION, ServerInstance->Config->ServerName, INSPIRCD_BRANCH, modelist[0], modelist[1], modelist[2]); - - ServerInstance->ISupport.SendTo(this); - - /* Now registered */ - if (ServerInstance->Users->unregistered_count) - ServerInstance->Users->unregistered_count--; - - /* Trigger MOTD and LUSERS output, give modules a chance too */ - ModResult MOD_RESULT; - std::string command("LUSERS"); - std::vector parameters; - FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, command)); - if (!MOD_RESULT) - ServerInstance->Parser.CallHandler(command, parameters, this); - - MOD_RESULT = MOD_RES_PASSTHRU; - command = "MOTD"; - FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (command, parameters, this, true, command)); - if (!MOD_RESULT) - ServerInstance->Parser.CallHandler(command, parameters, this); - - if (ServerInstance->Config->RawLog) - WriteServ("PRIVMSG %s :*** Raw I/O logging is enabled on this server. All messages, passwords, and commands are being recorded.", nick.c_str()); - /* * We don't set REG_ALL until triggering OnUserConnect, so some module events don't spew out stuff * for a user that doesn't exist yet. */ FOREACH_MOD(OnUserConnect, (this)); + /* Now registered */ + if (ServerInstance->Users->unregistered_count) + ServerInstance->Users->unregistered_count--; this->registered = REG_ALL; FOREACH_MOD(OnPostConnect, (this)); ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d (class %s): %s (%s) [%s]", - this->GetServerPort(), this->MyClass->name.c_str(), GetFullRealHost().c_str(), this->GetIPString().c_str(), this->fullname.c_str()); + this->GetServerPort(), this->MyClass->name.c_str(), GetFullRealHost().c_str(), this->GetIPString().c_str(), this->GetRealName().c_str()); ServerInstance->Logs->Log("BANCACHE", LOG_DEBUG, "BanCache: Adding NEGATIVE hit for " + this->GetIPString()); ServerInstance->BanCache.AddHit(this->GetIPString(), "", ""); // reset the flood penalty (which could have been raised due to things like auto +x) @@ -622,8 +640,12 @@ bool User::ChangeNick(const std::string& newnick, time_t newts) } if (this->registered == REG_ALL) - this->WriteCommon("NICK %s",newnick.c_str()); - std::string oldnick = nick; + { + ClientProtocol::Messages::Nick nickmsg(this, newnick); + ClientProtocol::Event nickevent(ServerInstance->GetRFCEvents().nick, nickmsg); + this->WriteCommonRaw(nickevent, true); + } + const std::string oldnick = nick; nick = newnick; InvalidateCache(); @@ -638,7 +660,10 @@ bool User::ChangeNick(const std::string& newnick, time_t newts) void LocalUser::OverruleNick() { - this->WriteFrom(this, "NICK %s", this->uuid.c_str()); + { + ClientProtocol::Messages::Nick nickmsg(this, this->uuid); + this->Send(ServerInstance->GetRFCEvents().nick, nickmsg); + } this->WriteNumeric(ERR_NICKNAMEINUSE, this->nick, "Nickname overruled."); // Clear the bit before calling ChangeNick() to make it NOT run the OnUserPostNick() hook @@ -648,14 +673,7 @@ void LocalUser::OverruleNick() int LocalUser::GetServerPort() { - switch (this->server_sa.sa.sa_family) - { - case AF_INET6: - return htons(this->server_sa.in6.sin6_port); - case AF_INET: - return htons(this->server_sa.in4.sin_port); - } - return 0; + return this->server_sa.port(); } const std::string& User::GetIPString() @@ -686,10 +704,15 @@ const std::string& User::GetRealHost() const return realhost; } +const std::string& User::GetRealName() const +{ + return realname; +} + irc::sockets::cidr_mask User::GetCIDRMask() { unsigned char range = 0; - switch (client_sa.sa.sa_family) + switch (client_sa.family()) { case AF_INET6: range = ServerInstance->Config->c_ipv6_range; @@ -701,121 +724,128 @@ irc::sockets::cidr_mask User::GetCIDRMask() return irc::sockets::cidr_mask(client_sa, range); } -bool User::SetClientIP(const std::string& address, bool recheck_eline) +bool User::SetClientIP(const std::string& address) { - this->InvalidateCache(); - return irc::sockets::aptosa(address, 0, client_sa); + irc::sockets::sockaddrs sa; + if (!irc::sockets::aptosa(address, client_sa.port(), sa)) + return false; + + User::SetClientIP(sa); + return true; } -void User::SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline) +void User::SetClientIP(const irc::sockets::sockaddrs& sa) { - this->InvalidateCache(); + const std::string oldip(GetIPString()); memcpy(&client_sa, &sa, sizeof(irc::sockets::sockaddrs)); + this->InvalidateCache(); + + // If the users hostname was their IP then update it. + if (GetRealHost() == oldip) + ChangeRealHost(GetIPString(), false); + if (GetDisplayedHost() == oldip) + ChangeDisplayedHost(GetIPString()); } -bool LocalUser::SetClientIP(const std::string& address, bool recheck_eline) +bool LocalUser::SetClientIP(const std::string& address) { irc::sockets::sockaddrs sa; - if (!irc::sockets::aptosa(address, 0, sa)) - // Invalid + if (!irc::sockets::aptosa(address, client_sa.port(), sa)) return false; - LocalUser::SetClientIP(sa, recheck_eline); + LocalUser::SetClientIP(sa); return true; } -void LocalUser::SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline) +void LocalUser::SetClientIP(const irc::sockets::sockaddrs& sa) { - if (sa != client_sa) - { - User::SetClientIP(sa); - if (recheck_eline) - this->exempt = (ServerInstance->XLines->MatchesLine("E", this) != NULL); + if (sa == client_sa) + return; - FOREACH_MOD(OnSetUserIP, (this)); - } -} + ServerInstance->Users->RemoveCloneCounts(this); -static std::string wide_newline("\r\n"); + User::SetClientIP(sa); -void User::Write(const std::string& text) -{ -} + FOREACH_MOD(OnSetUserIP, (this)); -void User::Write(const char *text, ...) -{ + ServerInstance->Users->AddClone(this); + + // Recheck the connect class. + this->MyClass = NULL; + this->SetClass(); + this->CheckClass(); } -void LocalUser::Write(const std::string& text) +void LocalUser::Write(const ClientProtocol::SerializedMessage& text) { if (!SocketEngine::BoundsCheckFd(&eh)) return; - if (text.length() > ServerInstance->Config->Limits.MaxLine - 2) + if (ServerInstance->Config->RawLog) { - // this should happen rarely or never. Crop the string at 512 and try again. - std::string try_again(text, 0, ServerInstance->Config->Limits.MaxLine - 2); - Write(try_again); - return; - } + if (text.empty()) + return; + + std::string::size_type nlpos = text.find_first_of("\r\n", 0, 2); + if (nlpos == std::string::npos) + nlpos = text.length(); // TODO is this ok, test it - ServerInstance->Logs->Log("USEROUTPUT", LOG_RAWIO, "C[%s] O %s", uuid.c_str(), text.c_str()); + ServerInstance->Logs->Log("USEROUTPUT", LOG_RAWIO, "C[%s] O %.*s", uuid.c_str(), (int) nlpos, text.c_str()); + } eh.AddWriteBuf(text); - eh.AddWriteBuf(wide_newline); - ServerInstance->stats.Sent += text.length() + 2; - this->bytes_out += text.length() + 2; + const size_t bytessent = text.length() + 2; + ServerInstance->stats.Sent += bytessent; + this->bytes_out += bytessent; this->cmds_out++; } -/** Write() - */ -void LocalUser::Write(const char *text, ...) -{ - std::string textbuffer; - VAFORMAT(textbuffer, text, text); - this->Write(textbuffer); -} - -void User::WriteServ(const std::string& text) +void LocalUser::Send(ClientProtocol::Event& protoev) { - this->Write(":%s %s",ServerInstance->Config->ServerName.c_str(),text.c_str()); -} - -/** WriteServ() - * Same as Write(), except `text' is prefixed with `:server.name '. - */ -void User::WriteServ(const char* text, ...) -{ - std::string textbuffer; - VAFORMAT(textbuffer, text, text); - this->WriteServ(textbuffer); -} + if (!serializer) + { + ServerInstance->Logs->Log("USERS", LOG_DEBUG, "BUG: LocalUser::Send() called on %s who does not have a serializer!", + GetFullRealHost().c_str()); + return; + } -void User::WriteCommand(const char* command, const std::string& text) -{ - this->WriteServ(command + (this->registered & REG_NICK ? " " + this->nick : " *") + " " + text); + // In the most common case a static LocalUser field, sendmsglist, is passed to the event to be + // populated. The list is cleared before returning. + // To handle re-enters, if sendmsglist is non-empty upon entering the method then a temporary + // list is used instead of the static one. + if (sendmsglist.empty()) + { + Send(protoev, sendmsglist); + sendmsglist.clear(); + } + else + { + ClientProtocol::MessageList msglist; + Send(protoev, msglist); + } } -namespace +void LocalUser::Send(ClientProtocol::Event& protoev, ClientProtocol::MessageList& msglist) { - std::string BuildNumeric(const std::string& source, User* targetuser, unsigned int num, const std::vector& params) + // Modules can personalize the messages sent per user for the event + protoev.GetMessagesForUser(this, msglist); + for (ClientProtocol::MessageList::const_iterator i = msglist.begin(); i != msglist.end(); ++i) { - const char* const target = (targetuser->registered & REG_NICK ? targetuser->nick.c_str() : "*"); - std::string raw = InspIRCd::Format(":%s %03u %s", source.c_str(), num, target); - if (!params.empty()) - { - for (std::vector::const_iterator i = params.begin(); i != params.end()-1; ++i) - raw.append(1, ' ').append(*i); - raw.append(" :").append(params.back()); - } - return raw; + ClientProtocol::Message& curr = **i; + ModResult res; + FIRST_MOD_RESULT(OnUserWrite, res, (this, curr)); + if (res != MOD_RES_DENY) + Write(serializer->SerializeForUser(this, curr)); } } void User::WriteNumeric(const Numeric::Numeric& numeric) { + LocalUser* const localuser = IS_LOCAL(this); + if (!localuser) + return; + ModResult MOD_RESULT; FIRST_MOD_RESULT(OnNumeric, MOD_RESULT, (this, numeric)); @@ -823,24 +853,8 @@ void User::WriteNumeric(const Numeric::Numeric& numeric) if (MOD_RESULT == MOD_RES_DENY) return; - const std::string& servername = (numeric.GetServer() ? numeric.GetServer()->GetName() : ServerInstance->Config->ServerName); - this->Write(BuildNumeric(servername, this, numeric.GetNumeric(), numeric.GetParams())); -} - -void User::WriteFrom(User *user, const std::string &text) -{ - const std::string message = ":" + user->GetFullHost() + " " + text; - this->Write(message); -} - - -/* write text from an originating user to originating user */ - -void User::WriteFrom(User *user, const char* text, ...) -{ - std::string textbuffer; - VAFORMAT(textbuffer, text, text); - this->WriteFrom(user, textbuffer); + ClientProtocol::Messages::Numeric numericmsg(numeric, localuser); + localuser->Send(ServerInstance->GetRFCEvents().numeric, numericmsg); } void User::WriteRemoteNotice(const std::string& text) @@ -857,32 +871,24 @@ namespace { class WriteCommonRawHandler : public User::ForEachNeighborHandler { - const std::string& msg; + ClientProtocol::Event& ev; void Execute(LocalUser* user) CXX11_OVERRIDE { - user->Write(msg); + user->Send(ev); } public: - WriteCommonRawHandler(const std::string& message) - : msg(message) + WriteCommonRawHandler(ClientProtocol::Event& protoev) + : ev(protoev) { } }; } -void User::WriteCommon(const char* text, ...) -{ - std::string textbuffer; - VAFORMAT(textbuffer, text, text); - textbuffer = ":" + this->GetFullHost() + " " + textbuffer; - this->WriteCommonRaw(textbuffer, true); -} - -void User::WriteCommonRaw(const std::string &line, bool include_self) +void User::WriteCommonRaw(ClientProtocol::Event& protoev, bool include_self) { - WriteCommonRawHandler handler(line); + WriteCommonRawHandler handler(protoev); ForEachNeighbor(handler, include_self); } @@ -970,20 +976,20 @@ bool User::SharesChannelWith(User *other) return false; } -bool User::ChangeName(const std::string& gecos) +bool User::ChangeRealName(const std::string& real) { - if (!this->fullname.compare(gecos)) + if (!this->realname.compare(real)) return true; if (IS_LOCAL(this)) { ModResult MOD_RESULT; - FIRST_MOD_RESULT(OnChangeLocalUserGECOS, MOD_RESULT, (IS_LOCAL(this),gecos)); + FIRST_MOD_RESULT(OnPreChangeRealName, MOD_RESULT, (IS_LOCAL(this), real)); if (MOD_RESULT == MOD_RES_DENY) return false; - FOREACH_MOD(OnChangeName, (this,gecos)); + FOREACH_MOD(OnChangeRealName, (this, real)); } - this->fullname.assign(gecos, 0, ServerInstance->Config->Limits.MaxGecos); + this->realname.assign(real, 0, ServerInstance->Config->Limits.MaxReal); return true; } @@ -993,10 +999,11 @@ bool User::ChangeDisplayedHost(const std::string& shost) if (GetDisplayedHost() == shost) return true; - if (IS_LOCAL(this)) + LocalUser* luser = IS_LOCAL(this); + if (luser) { ModResult MOD_RESULT; - FIRST_MOD_RESULT(OnChangeLocalUserHost, MOD_RESULT, (IS_LOCAL(this),shost)); + FIRST_MOD_RESULT(OnPreChangeHost, MOD_RESULT, (luser, shost)); if (MOD_RESULT == MOD_RES_DENY) return false; } @@ -1169,8 +1176,16 @@ void User::PurgeEmptyChannels() ++i; c->DelUser(this); } +} + +void User::WriteNotice(const std::string& text) +{ + LocalUser* const localuser = IS_LOCAL(this); + if (!localuser) + return; - this->UnOper(); + ClientProtocol::Messages::Privmsg msg(ClientProtocol::Messages::Privmsg::nocopy, ServerInstance->FakeClient, localuser, text, MSG_NOTICE); + localuser->Send(ServerInstance->GetRFCEvents().privmsg, msg); } const std::string& FakeUser::GetFullHost() @@ -1212,7 +1227,7 @@ ConnectClass::ConnectClass(ConfigTag* tag, char t, const std::string& mask, cons for (ConfigItems::const_iterator piter = parentkeys.begin(); piter != parentkeys.end(); ++piter) { // The class name and parent name are not inherited - if (piter->first == "name" || piter->first == "parent") + if (stdalgo::string::equalsci(piter->first, "name") || stdalgo::string::equalsci(piter->first, "parent")) continue; // Store the item in the config tag. If this item also