X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fusers.cpp;h=b81cd6d912d2bd6ca3bc8bbdc3833183144f12ae;hb=5d67a5fff127bf95bca69b436ef7f645f2fe3281;hp=538f8d33be27c5f2bf8099e941eb2b4476793199;hpb=72fe978b29fa7d9fd7f8e9c2766c06ab1a0a8bc7;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/users.cpp b/src/users.cpp index 538f8d33b..6087f4d1c 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -2,8 +2,8 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * InspIRCd: (C) 2002-2009 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits * * This program is free but copyrighted software; see * the file COPYING for details. @@ -11,20 +11,27 @@ * --------------------------------------------------- */ -/* $Core: libIRCDusers */ +/* $Core */ #include "inspircd.h" #include #include "socketengine.h" -#include "wildcard.h" #include "xline.h" #include "bancache.h" #include "commands/cmd_whowas.h" -static unsigned long already_sent[MAX_DESCRIPTORS] = {0}; - /* XXX: Used for speeding up WriteCommon operations */ -unsigned long uniq_id = 0; +unsigned long uniq_id = 1; + +static unsigned long* already_sent = NULL; + + +void InitializeAlreadySent(SocketEngine* SE) +{ + already_sent = new unsigned long[SE->GetMaxFds()]; + memset(already_sent, 0, SE->GetMaxFds() * sizeof(unsigned long)); +} + std::string User::ProcessNoticeMasks(const char *sm) { @@ -73,6 +80,9 @@ std::string User::ProcessNoticeMasks(const char *sm) output += *c; } } + else + this->WriteNumeric(ERR_UNKNOWNSNOMASK, "%s %c :is unknown snomask char to me", this->nick.c_str(), *c); + oldadding = adding; break; } @@ -80,6 +90,12 @@ std::string User::ProcessNoticeMasks(const char *sm) *c++; } + std::string s = this->FormatNoticeMasks(); + if (s.length() == 0) + { + this->modes[UM_SNOMASK] = false; + } + return output; } @@ -87,30 +103,32 @@ void User::StartDNSLookup() { try { - bool cached; - const char* ip = this->GetIPString(); + bool cached = false; + const char* sip = this->GetIPString(); + UserResolver *res_reverse; - /* Special case for 4in6 (Have i mentioned i HATE 4in6?) */ - if (!strncmp(ip, "0::ffff:", 8)) - res_reverse = new UserResolver(this->ServerInstance, this, ip + 8, DNS_QUERY_PTR4, cached); - else - res_reverse = new UserResolver(this->ServerInstance, this, ip, this->GetProtocolFamily() == AF_INET ? DNS_QUERY_PTR4 : DNS_QUERY_PTR6, cached); + QueryType resolvtype = this->client_sa.sa.sa_family == AF_INET6 ? DNS_QUERY_PTR6 : DNS_QUERY_PTR4; + res_reverse = new UserResolver(this->ServerInstance, this, sip, resolvtype, cached); this->ServerInstance->AddResolver(res_reverse, cached); } catch (CoreException& e) { - ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason()); + ServerInstance->Logs->Log("USERS", DEBUG,"Error in resolver: %s",e.GetReason()); } } bool User::IsNoticeMaskSet(unsigned char sm) { + if (!isalpha(sm)) + return false; return (snomasks[sm-65]); } void User::SetNoticeMask(unsigned char sm, bool value) { + if (!isalpha(sm)) + return; snomasks[sm-65] = value; } @@ -129,43 +147,57 @@ const char* User::FormatNoticeMasks() return data; } - - bool User::IsModeSet(unsigned char m) { + if (!isalpha(m)) + return false; return (modes[m-65]); } void User::SetMode(unsigned char m, bool value) { + if (!isalpha(m)) + return; modes[m-65] = value; } -const char* User::FormatModes() +const char* User::FormatModes(bool showparameters) { static char data[MAXBUF]; + std::string params; int offset = 0; - for (int n = 0; n < 64; n++) + + for (unsigned char n = 0; n < 64; n++) { if (modes[n]) - data[offset++] = n+65; + { + data[offset++] = n + 65; + ModeHandler* mh = ServerInstance->Modes->FindMode(n + 65, MODETYPE_USER); + if (showparameters && mh && mh->GetNumParams(true)) + { + std::string p = mh->GetUserParameter(this); + if (p.length()) + params.append(" ").append(p); + } + } } data[offset] = 0; + strlcat(data, params.c_str(), MAXBUF); return data; } void User::DecrementModes() { - ServerInstance->Log(DEBUG,"DecrementModes()"); + ServerInstance->Logs->Log("USERS", DEBUG, "DecrementModes()"); for (unsigned char n = 'A'; n <= 'z'; n++) { if (modes[n-65]) { - ServerInstance->Log(DEBUG,"DecrementModes() found mode %c", n); + ServerInstance->Logs->Log("USERS", DEBUG,"DecrementModes() found mode %c", n); ModeHandler* mh = ServerInstance->Modes->FindMode(n, MODETYPE_USER); if (mh) { - ServerInstance->Log(DEBUG,"Found handler %c and call ChangeCount", n); + ServerInstance->Logs->Log("USERS", DEBUG,"Found handler %c and call ChangeCount", n); mh->ChangeCount(-1); } } @@ -174,40 +206,33 @@ void User::DecrementModes() User::User(InspIRCd* Instance, const std::string &uid) : ServerInstance(Instance) { - *password = *nick = *ident = *host = *dhost = *fullname = *awaymsg = *oper = *uuid = 0; - server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName); - reset_due = ServerInstance->Time(); - age = ServerInstance->Time(true); + server = Instance->FindServerNamePtr(Instance->Config->ServerName); + age = ServerInstance->Time(); Penalty = 0; - lines_in = lastping = signon = idle_lastmsg = nping = registered = 0; - ChannelCount = timeout = bytes_in = bytes_out = cmds_in = cmds_out = 0; - OverPenalty = ExemptFromPenalty = muted = exempt = haspassed = dns_done = false; + lastping = signon = idle_lastmsg = nping = registered = 0; + bytes_in = bytes_out = cmds_in = cmds_out = 0; + quietquit = quitting = exempt = haspassed = dns_done = false; fd = -1; + server_sa.sa.sa_family = AF_UNSPEC; + client_sa.sa.sa_family = AF_UNSPEC; recvq.clear(); sendq.clear(); - WriteError.clear(); - res_forward = res_reverse = NULL; Visibility = NULL; - ip = NULL; MyClass = NULL; - AllowedOperCommands = NULL; + AllowedPrivs = AllowedOperCommands = NULL; chans.clear(); invites.clear(); - memset(modes,0,sizeof(modes)); - memset(snomasks,0,sizeof(snomasks)); - /* Invalidate cache */ - cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL; if (uid.empty()) - strlcpy(uuid, Instance->GetUID().c_str(), UUID_LENGTH); + uuid.assign(Instance->GetUID(), 0, UUID_LENGTH - 1); else - strlcpy(uuid, uid.c_str(), UUID_LENGTH); + uuid.assign(uid, 0, UUID_LENGTH - 1); - ServerInstance->Log(DEBUG,"New UUID for user: %s (%s)", uuid, uid.empty() ? "allocated new" : "used remote"); + ServerInstance->Logs->Log("USERS", DEBUG,"New UUID for user: %s (%s)", uuid.c_str(), uid.empty() ? "allocated new" : "used remote"); - user_hash::iterator finduuid = Instance->uuidlist->find(uuid); - if (finduuid == Instance->uuidlist->end()) - (*Instance->uuidlist)[uuid] = this; + user_hash::iterator finduuid = Instance->Users->uuidlist->find(uuid); + if (finduuid == Instance->Users->uuidlist->end()) + (*Instance->Users->uuidlist)[uuid] = this; else throw CoreException("Duplicate UUID "+std::string(uuid)+" in User constructor"); } @@ -218,100 +243,99 @@ User::~User() if (this->MyClass) { this->MyClass->RefCount--; - ServerInstance->Log(DEBUG, "User destructor -- connect refcount now: %u", this->MyClass->RefCount); + ServerInstance->Logs->Log("USERS", DEBUG, "User destructor -- connect refcount now: %lu", this->MyClass->RefCount); + if (MyClass->RefCount == 0) + delete MyClass; } + if (this->AllowedOperCommands) { delete AllowedOperCommands; AllowedOperCommands = NULL; } + if (this->AllowedPrivs) + { + delete AllowedPrivs; + AllowedPrivs = NULL; + } + this->InvalidateCache(); this->DecrementModes(); - if (ip) - { + if (client_sa.sa.sa_family != AF_UNSPEC) ServerInstance->Users->RemoveCloneCounts(this); - if (this->GetProtocolFamily() == AF_INET) - { - delete (sockaddr_in*)ip; - } -#ifdef SUPPORT_IP6LINKS - else - { - delete (sockaddr_in6*)ip; - } -#endif - } - - ServerInstance->uuidlist->erase(uuid); + ServerInstance->Users->uuidlist->erase(uuid); } -char* User::MakeHost() +const std::string& User::MakeHost() { - if (this->cached_makehost) + if (!this->cached_makehost.empty()) return this->cached_makehost; char nhost[MAXBUF]; /* This is much faster than snprintf */ char* t = nhost; - for(char* n = ident; *n; n++) + for(const char* n = ident.c_str(); *n; n++) *t++ = *n; *t++ = '@'; - for(char* n = host; *n; n++) + for(const char* n = host.c_str(); *n; n++) *t++ = *n; *t = 0; - this->cached_makehost = strdup(nhost); + this->cached_makehost.assign(nhost); return this->cached_makehost; } -char* User::MakeHostIP() +const std::string& User::MakeHostIP() { - if (this->cached_hostip) + if (!this->cached_hostip.empty()) return this->cached_hostip; char ihost[MAXBUF]; /* This is much faster than snprintf */ char* t = ihost; - for(char* n = ident; *n; n++) + for(const char* n = ident.c_str(); *n; n++) *t++ = *n; *t++ = '@'; for(const char* n = this->GetIPString(); *n; n++) *t++ = *n; *t = 0; - this->cached_hostip = strdup(ihost); + this->cached_hostip = ihost; return this->cached_hostip; } void User::CloseSocket() { - ServerInstance->SE->Shutdown(this, 2); - ServerInstance->SE->Close(this); + if (this->fd > -1) + { + ServerInstance->SE->Shutdown(this, 2); + ServerInstance->SE->Close(this); + } } -char* User::GetFullHost() +const std::string User::GetFullHost() { - if (this->cached_fullhost) + if (!this->cached_fullhost.empty()) return this->cached_fullhost; char result[MAXBUF]; char* t = result; - for(char* n = nick; *n; n++) + for(const char* n = nick.c_str(); *n; n++) *t++ = *n; *t++ = '!'; - for(char* n = ident; *n; n++) + for(const char* n = ident.c_str(); *n; n++) *t++ = *n; *t++ = '@'; - for(char* n = dhost; *n; n++) + for(const char* n = dhost.c_str(); *n; n++) *t++ = *n; *t = 0; - this->cached_fullhost = strdup(result); + this->cached_fullhost = result; return this->cached_fullhost; } @@ -322,7 +346,7 @@ char* User::MakeWildHost() char* t = nresult; *t++ = '*'; *t++ = '!'; *t++ = '*'; *t++ = '@'; - for(char* n = dhost; *n; n++) + for(const char* n = dhost.c_str(); *n; n++) *t++ = *n; *t = 0; return nresult; @@ -343,34 +367,44 @@ int User::ReadData(void* buffer, size_t size) } -char* User::GetFullRealHost() +const std::string User::GetFullRealHost() { - if (this->cached_fullrealhost) + if (!this->cached_fullrealhost.empty()) return this->cached_fullrealhost; char fresult[MAXBUF]; char* t = fresult; - for(char* n = nick; *n; n++) + for(const char* n = nick.c_str(); *n; n++) *t++ = *n; *t++ = '!'; - for(char* n = ident; *n; n++) + for(const char* n = ident.c_str(); *n; n++) *t++ = *n; *t++ = '@'; - for(char* n = host; *n; n++) + for(const char* n = host.c_str(); *n; n++) *t++ = *n; *t = 0; - this->cached_fullrealhost = strdup(fresult); + this->cached_fullrealhost = fresult; return this->cached_fullrealhost; } bool User::IsInvited(const irc::string &channel) { - for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++) + time_t now = ServerInstance->Time(); + InvitedList::iterator safei; + for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i) { - if (channel == *i) + if (channel == i->first) { + if (i->second != 0 && now > i->second) + { + /* Expired invite, remove it. */ + safei = i; + --i; + invites.erase(safei); + continue; + } return true; } } @@ -379,19 +413,46 @@ bool User::IsInvited(const irc::string &channel) InvitedList* User::GetInviteList() { + time_t now = ServerInstance->Time(); + /* Weed out expired invites here. */ + InvitedList::iterator safei; + for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i) + { + if (i->second != 0 && now > i->second) + { + /* Expired invite, remove it. */ + safei = i; + --i; + invites.erase(safei); + } + } return &invites; } -void User::InviteTo(const irc::string &channel) +void User::InviteTo(const irc::string &channel, time_t invtimeout) { - invites.push_back(channel); + time_t now = ServerInstance->Time(); + if (invtimeout != 0 && now > invtimeout) return; /* Don't add invites that are expired from the get-go. */ + for (InvitedList::iterator i = invites.begin(); i != invites.end(); ++i) + { + if (channel == i->first) + { + if (i->second != 0 && invtimeout > i->second) + { + i->second = invtimeout; + } + + return; + } + } + invites.push_back(std::make_pair(channel, invtimeout)); } void User::RemoveInvite(const irc::string &channel) { for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++) { - if (channel == *i) + if (channel == i->first) { invites.erase(i); return; @@ -399,6 +460,20 @@ void User::RemoveInvite(const irc::string &channel) } } +bool User::HasModePermission(unsigned char mode, ModeType type) +{ + if (!IS_LOCAL(this)) + return true; + + if (!IS_OPER(this)) + return false; + + if (mode < 'A' || mode > ('A' + 64)) return false; + + return ((type == MODETYPE_USER ? AllowedUserModes : AllowedChanModes))[(mode - 'A')]; + +} + bool User::HasPermission(const std::string &command) { /* @@ -428,42 +503,105 @@ bool User::HasPermission(const std::string &command) return false; } -/** NOTE: We cannot pass a const reference to this method. - * The string is changed by the workings of the method, - * so that if we pass const ref, we end up copying it to - * something we can change anyway. Makes sense to just let - * the compiler do that copy for us. - */ -bool User::AddBuffer(std::string a) + +bool User::HasPrivPermission(const std::string &privstr, bool noisy) { - try + if (!IS_LOCAL(this)) { - std::string::size_type i = a.rfind('\r'); + ServerInstance->Logs->Log("PRIVS", DEBUG, "Remote (yes)"); + return true; + } + + if (!IS_OPER(this)) + { + if (noisy) + this->WriteServ("NOTICE %s :You are not an oper", this->nick.c_str()); + return false; + } + + if (!AllowedPrivs) + { + if (noisy) + this->WriteServ("NOTICE %s :Privset empty(!?)", this->nick.c_str()); + return false; + } + + if (AllowedPrivs->find(privstr) != AllowedPrivs->end()) + { + return true; + } + else if (AllowedPrivs->find("*") != AllowedPrivs->end()) + { + return true; + } + + if (noisy) + this->WriteServ("NOTICE %s :Oper type %s does not have access to priv %s", this->nick.c_str(), this->oper.c_str(), privstr.c_str()); + return false; +} +bool User::AddBuffer(const std::string &a) +{ + std::string::size_type start = 0; + std::string::size_type i = a.find('\r'); + + /* + * The old implementation here took a copy, and rfind() on \r, removing as it found them, before + * copying a second time onto the recvq. That's ok, but involves three copies minimum (recv() to buffer, + * buffer to here, here to recvq) - The new method now copies twice (recv() to buffer, buffer to recvq). + * + * We use find() instead of rfind() for clarity, however unlike the old code, our scanning of the string is + * contiguous: as we specify a startpoint, we never see characters we have scanned previously, making this + * marginally faster in cases with a number of \r hidden early on in the buffer. + * + * How it works: + * Start at first pos of string, find first \r, append everything in the chunk (excluding \r) to recvq. Set + * i ahead of the \r, search for next \r, add next chunk to buffer... repeat. + * -- w00t (7 may, 2008) + */ + if (i == std::string::npos) + { + // no \r that we need to dance around, just add to buffer + recvq.append(a); + } + else + { + // While we can find the end of a chunk to add while (i != std::string::npos) { - a.erase(i, 1); - i = a.rfind('\r'); - } + // Append the chunk that we have + recvq.append(a, start, (i - start)); - if (a.length()) - recvq.append(a); + // Start looking for the next one + start = i + 1; + i = a.find('\r', start); + } - if (this->MyClass && (recvq.length() > this->MyClass->GetRecvqMax())) + if (start != a.length()) { - this->SetWriteError("RecvQ exceeded"); - ServerInstance->WriteOpers("*** User %s RecvQ of %d exceeds connect class maximum of %d",this->nick,recvq.length(),this->MyClass->GetRecvqMax()); - return false; + /* + * This is here to catch a corner case when we get something like: + * NICK w0 + * 0t\r\nU + * SER ... + * in successive calls to us. + * + * Without this conditional, the 'U' on the second case will be dropped, + * which is most *certainly* not the behaviour we want! + * -- w00t + */ + recvq.append(a, start, (a.length() - start)); } - - return true; } - catch (...) + if (this->MyClass && !this->HasPrivPermission("users/flood/increased-buffers") && recvq.length() > this->MyClass->GetRecvqMax()) { - ServerInstance->Log(DEBUG,"Exception in User::AddBuffer()"); + ServerInstance->Users->QuitUser(this, "RecvQ exceeded"); + ServerInstance->SNO->WriteToSnoMask('a', "User %s RecvQ of %lu exceeds connect class maximum of %lu",this->nick.c_str(),(unsigned long int)recvq.length(),this->MyClass->GetRecvqMax()); return false; } + + return true; } bool User::BufferIsReady() @@ -511,208 +649,222 @@ std::string User::GetBuffer() catch (...) { - ServerInstance->Log(DEBUG,"Exception in User::GetBuffer()"); + ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::GetBuffer()"); return ""; } } void User::AddWriteBuf(const std::string &data) { - if (*this->GetWriteError()) - return; - - if (this->MyClass && (sendq.length() + data.length() > this->MyClass->GetSendqMax())) + if (!this->quitting && this->MyClass && !this->HasPrivPermission("users/flood/increased-buffers") && sendq.length() + data.length() > this->MyClass->GetSendqMax()) { /* - * Fix by brain - Set the error text BEFORE calling writeopers, because + * Fix by brain - Set the error text BEFORE calling, because * if we dont it'll recursively call here over and over again trying * to repeatedly add the text to the sendq! */ - this->SetWriteError("SendQ exceeded"); - ServerInstance->WriteOpers("*** User %s SendQ of %d exceeds connect class maximum of %d",this->nick,sendq.length() + data.length(),this->MyClass->GetSendqMax()); + ServerInstance->Users->QuitUser(this, "SendQ exceeded"); + ServerInstance->SNO->WriteToSnoMask('a', "User %s SendQ of %lu exceeds connect class maximum of %lu",this->nick.c_str(),(unsigned long int)sendq.length() + data.length(),this->MyClass->GetSendqMax()); return; } - try - { - if (data.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */ - sendq.append(data.substr(0,MAXBUF - 4)).append("\r\n"); /* MAXBUF-4 = 510 */ - else - sendq.append(data); - } - catch (...) - { - this->SetWriteError("SendQ exceeded"); - ServerInstance->WriteOpers("*** User %s SendQ got an exception",this->nick); - } + // We still want to append data to the sendq of a quitting user, + // e.g. their ERROR message that says 'closing link' + + if (data.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */ + sendq.append(data.substr(0,MAXBUF - 4)).append("\r\n"); /* MAXBUF-4 = 510 */ + else + sendq.append(data); } // send AS MUCH OF THE USERS SENDQ as we are able to (might not be all of it) void User::FlushWriteBuf() { - try + if (this->fd == FD_MAGIC_NUMBER) { - if ((this->fd == FD_MAGIC_NUMBER) || (*this->GetWriteError())) - { - sendq.clear(); - } - if ((sendq.length()) && (this->fd != FD_MAGIC_NUMBER)) - { - int old_sendq_length = sendq.length(); - int n_sent = ServerInstance->SE->Send(this, this->sendq.data(), this->sendq.length(), 0); + sendq.clear(); + return; + } + + if ((sendq.length()) && (this->fd != FD_MAGIC_NUMBER)) + { + int old_sendq_length = sendq.length(); + int n_sent = ServerInstance->SE->Send(this, this->sendq.data(), this->sendq.length(), 0); - if (n_sent == -1) + if (n_sent == -1) + { + if (errno == EAGAIN) { - if (errno == EAGAIN) - { - /* The socket buffer is full. This isnt fatal, - * try again later. - */ - this->ServerInstance->SE->WantWrite(this); - } - else - { - /* Fatal error, set write error and bail - */ - this->SetWriteError(errno ? strerror(errno) : "EOF from client"); - return; - } + /* The socket buffer is full. This isnt fatal, + * try again later. + */ + ServerInstance->SE->WantWrite(this); } else { - /* advance the queue */ - if (n_sent) - this->sendq = this->sendq.substr(n_sent); - /* update the user's stats counters */ - this->bytes_out += n_sent; - this->cmds_out++; - if (n_sent != old_sendq_length) - this->ServerInstance->SE->WantWrite(this); + /* Fatal error, set write error and bail */ + ServerInstance->Users->QuitUser(this, errno ? strerror(errno) : "Write error"); + return; } } + else + { + /* advance the queue */ + if (n_sent) + this->sendq = this->sendq.substr(n_sent); + /* update the user's stats counters */ + this->bytes_out += n_sent; + this->cmds_out++; + if (n_sent != old_sendq_length) + this->ServerInstance->SE->WantWrite(this); + } } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::FlushWriteBuf()"); - } - + /* note: NOT else if! */ if (this->sendq.empty()) { FOREACH_MOD(I_OnBufferFlushed,OnBufferFlushed(this)); } } -void User::SetWriteError(const std::string &error) +void User::Oper(const std::string &opertype, const std::string &opername) { - try - { - // don't try to set the error twice, its already set take the first string. - if (this->WriteError.empty()) - this->WriteError = error; - } + if (this->IsModeSet('o')) + this->UnOper(); - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::SetWriteError()"); - } -} + this->modes[UM_OPERATOR] = 1; + this->WriteServ("MODE %s :+o", this->nick.c_str()); + FOREACH_MOD(I_OnOper, OnOper(this, opertype)); -const char* User::GetWriteError() -{ - return this->WriteError.c_str(); -} + ServerInstance->SNO->WriteToSnoMask('o',"%s (%s@%s) is now an IRC operator of type %s (using oper '%s')", this->nick.c_str(), this->ident.c_str(), this->host.c_str(), irc::Spacify(opertype.c_str()), opername.c_str()); + this->WriteNumeric(381, "%s :You are now %s %s", this->nick.c_str(), strchr("aeiouAEIOU", *opertype.c_str()) ? "an" : "a", irc::Spacify(opertype.c_str())); -void User::Oper(const std::string &opertype, const std::string &opername) -{ - char* mycmd; - char* savept; - char* savept2; + ServerInstance->Logs->Log("OPER", DEFAULT, "%s!%s@%s opered as type: %s", this->nick.c_str(), this->ident.c_str(), this->host.c_str(), opertype.c_str()); + this->oper.assign(opertype, 0, 512); + ServerInstance->Users->all_opers.push_back(this); - try + /* + * This might look like it's in the wrong place. + * It is *not*! + * + * For multi-network servers, we may not have the opertypes of the remote server, but we still want to mark the user as an oper of that type. + * -- w00t + */ + opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper.c_str()); + if (iter_opertype != ServerInstance->Config->opertypes.end()) { - this->modes[UM_OPERATOR] = 1; - this->WriteServ("MODE %s :+o", this->nick); - FOREACH_MOD(I_OnOper, OnOper(this, opertype)); - ServerInstance->Log(DEFAULT,"OPER: %s!%s@%s opered as type: %s", this->nick, this->ident, this->host, opertype.c_str()); - strlcpy(this->oper, opertype.c_str(), NICKMAX - 1); - ServerInstance->all_opers.push_back(this); + if (AllowedOperCommands) + AllowedOperCommands->clear(); + else + AllowedOperCommands = new std::set; - opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper); - if (iter_opertype != ServerInstance->Config->opertypes.end()) - { + if (AllowedPrivs) + AllowedPrivs->clear(); + else + AllowedPrivs = new std::set; - if (AllowedOperCommands) - AllowedOperCommands->clear(); - else - AllowedOperCommands = new std::map; + AllowedUserModes.reset(); + AllowedChanModes.reset(); + this->AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want. - char* Classes = strdup(iter_opertype->second); - char* myclass = strtok_r(Classes," ",&savept); - while (myclass) + std::string myclass, mycmd, mypriv; + irc::spacesepstream Classes(iter_opertype->second.c_str()); + while (Classes.GetToken(myclass)) + { + operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass.c_str()); + if (iter_operclass != ServerInstance->Config->operclass.end()) { - operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass); - if (iter_operclass != ServerInstance->Config->operclass.end()) + /* Process commands */ + irc::spacesepstream CommandList(iter_operclass->second.commandlist); + while (CommandList.GetToken(mycmd)) + { + this->AllowedOperCommands->insert(mycmd); + } + + irc::spacesepstream PrivList(iter_operclass->second.privs); + while (PrivList.GetToken(mypriv)) { - char* CommandList = strdup(iter_operclass->second); - mycmd = strtok_r(CommandList," ",&savept2); - while (mycmd) + this->AllowedPrivs->insert(mypriv); + } + + for (unsigned char* c = (unsigned char*)iter_operclass->second.umodelist; *c; ++c) + { + if (*c == '*') + { + this->AllowedUserModes.set(); + } + else { - this->AllowedOperCommands->insert(std::make_pair(mycmd, true)); - mycmd = strtok_r(NULL," ",&savept2); + this->AllowedUserModes[*c - 'A'] = true; + } + } + + for (unsigned char* c = (unsigned char*)iter_operclass->second.cmodelist; *c; ++c) + { + if (*c == '*') + { + this->AllowedChanModes.set(); + } + else + { + this->AllowedChanModes[*c - 'A'] = true; } - free(CommandList); } - myclass = strtok_r(NULL," ",&savept); } - free(Classes); } - - FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype, opername)); } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::Oper()"); - } + FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype, opername)); } void User::UnOper() { - try + if (IS_OPER(this)) { - if (IS_OPER(this)) + /* + * unset their oper type (what IS_OPER checks). + * note, order is important - this must come before modes as -o attempts + * to call UnOper. -- w00t + */ + this->oper.clear(); + + + /* Remove all oper only modes from the user when the deoper - Bug #466*/ + std::string moderemove("-"); + + for (unsigned char letter = 'A'; letter <= 'z'; letter++) { - // unset their oper type (what IS_OPER checks), and remove +o - *this->oper = 0; - this->modes[UM_OPERATOR] = 0; - - // remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 - ServerInstance->all_opers.remove(this); - - if (AllowedOperCommands) - { - delete AllowedOperCommands; - AllowedOperCommands = NULL; - } + ModeHandler* mh = ServerInstance->Modes->FindMode(letter, MODETYPE_USER); + if (mh && mh->NeedsOper()) + moderemove += letter; } - } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::UnOper()"); - } -} -void User::QuitUser(InspIRCd* Instance, User *user, const std::string &quitreason, const char* operreason) -{ - Instance->Log(DEBUG,"QuitUser: %s '%s'", user->nick, quitreason.c_str()); - user->Write("ERROR :Closing link (%s@%s) [%s]", user->ident, user->host, *operreason ? operreason : quitreason.c_str()); - user->muted = true; - user->quietquit = false; - user->quitmsg = quitreason; - user->operquitmsg = operreason; - Instance->GlobalCulls.AddItem(user); + std::vector parameters; + parameters.push_back(this->nick); + parameters.push_back(moderemove); + + ServerInstance->Parser->CallHandler("MODE", parameters, this); + + /* remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 */ + ServerInstance->Users->all_opers.remove(this); + + if (AllowedOperCommands) + { + delete AllowedOperCommands; + AllowedOperCommands = NULL; + } + + if (AllowedPrivs) + { + delete AllowedPrivs; + AllowedPrivs = NULL; + } + + AllowedUserModes.reset(); + AllowedChanModes.reset(); + this->modes[UM_OPERATOR] = 0; + } } /* adds or updates an entry in the whowas list */ @@ -734,27 +886,46 @@ void User::CheckClass() { ConnectClass* a = this->MyClass; - if ((!a) || (a->GetType() == CC_DENY)) + if ((!a) || (a->type == CC_DENY)) { - User::QuitUser(ServerInstance, this, "Unauthorised connection"); + ServerInstance->Users->QuitUser(this, "Unauthorised connection"); return; } else if ((a->GetMaxLocal()) && (ServerInstance->Users->LocalCloneCount(this) > a->GetMaxLocal())) { - User::QuitUser(ServerInstance, this, "No more connections allowed from your host via this connect class (local)"); - ServerInstance->WriteOpers("*** WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString()); + ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (local)"); + ServerInstance->SNO->WriteToSnoMask('a', "WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a->GetMaxLocal(), this->GetIPString()); return; } else if ((a->GetMaxGlobal()) && (ServerInstance->Users->GlobalCloneCount(this) > a->GetMaxGlobal())) { - User::QuitUser(ServerInstance, this, "No more connections allowed from your host via this connect class (global)"); - ServerInstance->WriteOpers("*** WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString()); + ServerInstance->Users->QuitUser(this, "No more connections allowed from your host via this connect class (global)"); + ServerInstance->SNO->WriteToSnoMask('a', "WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s", a->GetMaxGlobal(), this->GetIPString()); return; } this->nping = ServerInstance->Time() + a->GetPingTime() + ServerInstance->Config->dns_timeout; - this->timeout = ServerInstance->Time() + a->GetRegTimeout(); - this->MaxChans = a->GetMaxChans(); +} + +bool User::CheckLines(bool doZline) +{ + const char* check[] = { "G" , "K", (doZline) ? "Z" : NULL, NULL }; + + if (!this->exempt) + { + for (int n = 0; check[n]; ++n) + { + XLine *r = ServerInstance->XLines->MatchesLine(check[n], this); + + if (r) + { + r->Apply(this); + return true; + } + } + } + + return false; } void User::FullConnect() @@ -769,57 +940,42 @@ void User::FullConnect() * Don't remove this! -- w00t */ this->SetClass(); - + /* Check the password, if one is required by the user's connect class. * This CANNOT be in CheckClass(), because that is called prior to PASS as well! */ if (this->MyClass && !this->MyClass->GetPass().empty() && !this->haspassed) { - User::QuitUser(ServerInstance, this, "Invalid password"); + ServerInstance->Users->QuitUser(this, "Invalid password"); return; } - if (!this->exempt) - { - GLine *r = (GLine *)ServerInstance->XLines->MatchesLine("G", this); - - if (r) - { - r->Apply(this); - return; - } - - KLine *n = (KLine *)ServerInstance->XLines->MatchesLine("K", this); - - if (n) - { - n->Apply(this); - return; - } - } + if (this->CheckLines()) + return; this->WriteServ("NOTICE Auth :Welcome to \002%s\002!",ServerInstance->Config->Network); - this->WriteServ("001 %s :Welcome to the %s IRC Network %s!%s@%s",this->nick, ServerInstance->Config->Network, this->nick, this->ident, this->host); - this->WriteServ("002 %s :Your host is %s, running version %s",this->nick,ServerInstance->Config->ServerName,VERSION); - this->WriteServ("003 %s :This server was created %s %s", this->nick, __TIME__, __DATE__); - this->WriteServ("004 %s %s %s %s %s %s", this->nick, ServerInstance->Config->ServerName, VERSION, ServerInstance->Modes->UserModeList().c_str(), ServerInstance->Modes->ChannelModeList().c_str(), ServerInstance->Modes->ParaModeList().c_str()); + this->WriteNumeric(RPL_WELCOME, "%s :Welcome to the %s IRC Network %s!%s@%s",this->nick.c_str(), ServerInstance->Config->Network, this->nick.c_str(), this->ident.c_str(), this->host.c_str()); + this->WriteNumeric(RPL_YOURHOSTIS, "%s :Your host is %s, running version InspIRCd-1.2",this->nick.c_str(),ServerInstance->Config->ServerName); + this->WriteNumeric(RPL_SERVERCREATED, "%s :This server was created %s %s", this->nick.c_str(), __TIME__, __DATE__); + this->WriteNumeric(RPL_SERVERVERSION, "%s %s InspIRCd-1.2 %s %s %s", this->nick.c_str(), ServerInstance->Config->ServerName, ServerInstance->Modes->UserModeList().c_str(), ServerInstance->Modes->ChannelModeList().c_str(), ServerInstance->Modes->ParaModeList().c_str()); ServerInstance->Config->Send005(this); - - this->WriteServ("042 %s %s :your unique ID", this->nick, this->uuid); + this->WriteNumeric(RPL_YOURUUID, "%s %s :your unique ID", this->nick.c_str(), this->uuid.c_str()); this->ShowMOTD(); /* Now registered */ - if (ServerInstance->unregistered_count) - ServerInstance->unregistered_count--; + if (ServerInstance->Users->unregistered_count) + ServerInstance->Users->unregistered_count--; /* Trigger LUSERS output, give modules a chance too */ int MOD_RESULT = 0; - FOREACH_RESULT(I_OnPreCommand, OnPreCommand("LUSERS", NULL, 0, this, true, "LUSERS")); + std::string command("LUSERS"); + std::vector parameters; + FOREACH_RESULT(I_OnPreCommand, OnPreCommand(command, parameters, this, true, "LUSERS")); if (!MOD_RESULT) - ServerInstance->CallCommandHandler("LUSERS", NULL, 0, this); + ServerInstance->CallCommandHandler(command, parameters, this); /* * We don't set REG_ALL until triggering OnUserConnect, so some module events don't spew out stuff @@ -831,9 +987,9 @@ void User::FullConnect() FOREACH_MOD(I_OnPostConnect,OnPostConnect(this)); - ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d: %s!%s@%s [%s] [%s]", this->GetPort(), this->nick, this->ident, this->host, this->GetIPString(), this->fullname); - - ServerInstance->Log(DEBUG, "BanCache: Adding NEGATIVE hit for %s", this->GetIPString()); + ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d: %s!%s@%s [%s] [%s]", + this->GetServerPort(), this->nick.c_str(), this->ident.c_str(), this->host.c_str(), this->GetIPString(), this->fullname.c_str()); + ServerInstance->Logs->Log("BANCACHE", DEBUG, "BanCache: Adding NEGATIVE hit for %s", this->GetIPString()); ServerInstance->BanCache->AddHit(this->GetIPString(), "", ""); } @@ -843,196 +999,200 @@ void User::FullConnect() */ User* User::UpdateNickHash(const char* New) { - try - { - //user_hash::iterator newnick; - user_hash::iterator oldnick = ServerInstance->clientlist->find(this->nick); + //user_hash::iterator newnick; + user_hash::iterator oldnick = ServerInstance->Users->clientlist->find(this->nick); - if (!strcasecmp(this->nick,New)) - return oldnick->second; + if (!irc::string(this->nick.c_str()).compare(New)) + return oldnick->second; - if (oldnick == ServerInstance->clientlist->end()) - return NULL; /* doesnt exist */ - - User* olduser = oldnick->second; - (*(ServerInstance->clientlist))[New] = olduser; - ServerInstance->clientlist->erase(oldnick); - return olduser; - } + if (oldnick == ServerInstance->Users->clientlist->end()) + return NULL; /* doesnt exist */ - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::UpdateNickHash()"); - return NULL; - } + User* olduser = oldnick->second; + ServerInstance->Users->clientlist->erase(oldnick); + (*(ServerInstance->Users->clientlist))[New] = olduser; + return olduser; } void User::InvalidateCache() { /* Invalidate cache */ - if (cached_fullhost) - free(cached_fullhost); - if (cached_hostip) - free(cached_hostip); - if (cached_makehost) - free(cached_makehost); - if (cached_fullrealhost) - free(cached_fullrealhost); - cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL; + cached_fullhost.clear(); + cached_hostip.clear(); + cached_makehost.clear(); + cached_fullrealhost.clear(); } bool User::ForceNickChange(const char* newnick) { - try - { - int MOD_RESULT = 0; + int MOD_RESULT = 0; - this->InvalidateCache(); + this->InvalidateCache(); - FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick)); + this->Extend("NICKForced", "Enabled"); - if (MOD_RESULT) - { - ServerInstance->stats->statsCollisions++; - return false; - } + FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick)); - if (ServerInstance->XLines->MatchesLine("Q",newnick)) - { - ServerInstance->stats->statsCollisions++; - return false; - } + this->Shrink("NICKForced"); - if (this->registered == REG_ALL) - { - std::deque dummy; - Command* nickhandler = ServerInstance->Parser->GetHandler("NICK"); - if (nickhandler) - { - nickhandler->HandleInternal(1, dummy); - bool result = (ServerInstance->Parser->CallHandler("NICK", &newnick, 1, this) == CMD_SUCCESS); - nickhandler->HandleInternal(0, dummy); - return result; - } - } + if (MOD_RESULT) + { + ServerInstance->stats->statsCollisions++; return false; } - catch (...) + std::deque dummy; + Command* nickhandler = ServerInstance->Parser->GetHandler("NICK"); + if (nickhandler) // wtfbbq, when would this not be here { - ServerInstance->Log(DEBUG,"Exception in User::ForceNickChange()"); - return false; + std::vector parameters; + nickhandler->HandleInternal(1, dummy); + parameters.push_back(newnick); + this->Extend("NICKForced", "Enabled"); + bool result = (ServerInstance->Parser->CallHandler("NICK", parameters, this) == CMD_SUCCESS); + this->Shrink("NICKForced"); + nickhandler->HandleInternal(0, dummy); + return result; } + + // Unreachable, we hope + return false; } -void User::SetSockAddr(int protocol_family, const char* ip, int port) +int User::GetServerPort() { - switch (protocol_family) + switch (this->server_sa.sa.sa_family) { -#ifdef SUPPORT_IP6LINKS case AF_INET6: - { - sockaddr_in6* sin = new sockaddr_in6; - sin->sin6_family = AF_INET6; - sin->sin6_port = port; - inet_pton(AF_INET6, ip, &sin->sin6_addr); - this->ip = (sockaddr*)sin; - } - break; -#endif + return htons(this->server_sa.in6.sin6_port); case AF_INET: - { - sockaddr_in* sin = new sockaddr_in; - sin->sin_family = AF_INET; - sin->sin_port = port; - inet_pton(AF_INET, ip, &sin->sin_addr); - this->ip = (sockaddr*)sin; - } - break; - default: - ServerInstance->Log(DEBUG,"Uh oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick); - break; + return htons(this->server_sa.in4.sin_port); } + return 0; } -int User::GetPort() +const char* User::GetCIDRMask(int range) { - if (this->ip == NULL) - return 0; + static char buf[44]; - switch (this->GetProtocolFamily()) + if (range < 0) + throw "Negative range, sorry, no."; + + /* + * Original code written by Oliver Lupton (Om). + * Integrated by me. Thanks. :) -- w00t + */ + switch (this->client_sa.sa.sa_family) { -#ifdef SUPPORT_IP6LINKS case AF_INET6: { - sockaddr_in6* sin = (sockaddr_in6*)this->ip; - return sin->sin6_port; + /* unsigned char s6_addr[16]; */ + struct in6_addr v6; + int i, bytestozero, extrabits; + char buffer[40]; + + if(range > 128) + throw "CIDR mask width greater than address width (IPv6, 128 bit)"; + + /* To create the CIDR mask we want to set all the bits after 'range' bits of the address + * to zero. This means the last (128 - range) bits of the address must be set to zero. + * Hence this number divided by 8 is the number of whole bytes from the end of the address + * which must be set to zero. + */ + bytestozero = (128 - range) / 8; + + /* Some of the least significant bits of the next most significant byte may also have to + * be zeroed. The number of bits is the remainder of the above division. + */ + extrabits = (128 - range) % 8; + + /* Populate our working struct with the parts of the user's IP which are required in the + * final CIDR mask. Set all the subsequent bytes to zero. + * (16 - bytestozero) is the number of bytes which must be populated with actual IP data. + */ + for(i = 0; i < (16 - bytestozero); i++) + { + v6.s6_addr[i] = client_sa.in6.sin6_addr.s6_addr[i]; + } + + /* And zero all the remaining bytes in the IP. */ + for(; i < 16; i++) + { + v6.s6_addr[i] = 0; + } + + /* And finally, zero the extra bits required. */ + v6.s6_addr[15 - bytestozero] = (v6.s6_addr[15 - bytestozero] >> extrabits) << extrabits; + + snprintf(buf, 44, "%s/%d", inet_ntop(AF_INET6, &v6, buffer, 40), range); + return buf; } break; -#endif case AF_INET: { - sockaddr_in* sin = (sockaddr_in*)this->ip; - return sin->sin_port; + struct in_addr v4; + char buffer[16]; + + if (range > 32) + throw "CIDR mask width greater than address width (IPv4, 32 bit)"; + + /* Users already have a sockaddr* pointer (User::ip) which contains either a v4 or v6 structure */ + v4.s_addr = client_sa.in4.sin_addr.s_addr; + + /* To create the CIDR mask we want to set all the bits after 'range' bits of the address + * to zero. This means the last (32 - range) bits of the address must be set to zero. + * This is done by shifting the value right and then back left by (32 - range) bits. + */ + if(range > 0) + { + v4.s_addr = ntohl(v4.s_addr); + v4.s_addr = (v4.s_addr >> (32 - range)) << (32 - range); + v4.s_addr = htonl(v4.s_addr); + } + else + { + /* a range of zero would cause a 32 bit value to be shifted by 32 bits. + * this has undefined behaviour, but for CIDR purposes the resulting mask + * from a.b.c.d/0 is 0.0.0.0/0 + */ + v4.s_addr = 0; + } + + snprintf(buf, 44, "%s/%d", inet_ntop(AF_INET, &v4, buffer, 16), range); + return buf; } break; - default: - break; } - return 0; + + return ""; // unused, but oh well } -int User::GetProtocolFamily() +std::string User::GetServerIP() { - if (this->ip == NULL) - return 0; - - sockaddr_in* sin = (sockaddr_in*)this->ip; - return sin->sin_family; + int port; + std::string ip; + irc::sockets::satoap(&server_sa, ip, port); + return ip; } -/* - * XXX the duplication here is horrid.. - * do we really need two methods doing essentially the same thing? - */ const char* User::GetIPString() { - static char buf[1024]; - - if (this->ip == NULL) - return ""; - - switch (this->GetProtocolFamily()) + int port; + if (cachedip.empty()) { -#ifdef SUPPORT_IP6LINKS - case AF_INET6: - { - static char temp[1024]; - - sockaddr_in6* sin = (sockaddr_in6*)this->ip; - inet_ntop(sin->sin6_family, &sin->sin6_addr, buf, sizeof(buf)); - /* IP addresses starting with a : on irc are a Bad Thing (tm) */ - if (*buf == ':') - { - strlcpy(&temp[1], buf, sizeof(temp) - 1); - *temp = '0'; - return temp; - } - return buf; - } - break; -#endif - case AF_INET: - { - sockaddr_in* sin = (sockaddr_in*)this->ip; - inet_ntop(sin->sin_family, &sin->sin_addr, buf, sizeof(buf)); - return buf; - } - break; - default: - break; + irc::sockets::satoap(&client_sa, cachedip, port); + /* IP addresses starting with a : on irc are a Bad Thing (tm) */ + if (cachedip.c_str()[0] == ':') + cachedip.insert(0,1,'0'); } - return ""; + + return cachedip.c_str(); +} + +bool User::SetClientIP(const char* sip) +{ + this->cachedip = ""; + return irc::sockets::aptosa(sip, 0, &client_sa); } /** NOTE: We cannot pass a const reference to this method. @@ -1048,31 +1208,27 @@ void User::Write(std::string text) try { - /* ServerInstance->Log(DEBUG,"C[%d] O %s", this->GetFd(), text.c_str()); - * WARNING: The above debug line is VERY loud, do NOT - * enable it till we have a good way of filtering it - * out of the logs (e.g. 1.2 would be good). - */ + ServerInstance->Logs->Log("USEROUTPUT", DEBUG,"C[%d] O %s", this->GetFd(), text.c_str()); text.append("\r\n"); } catch (...) { - ServerInstance->Log(DEBUG,"Exception in User::Write() std::string::append"); + ServerInstance->Logs->Log("USEROUTPUT", DEBUG,"Exception in User::Write() std::string::append"); return; } - if (ServerInstance->Config->GetIOHook(this->GetPort())) + if (this->GetIOHook()) { + /* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to + * implement their own buffering mechanisms + */ try { - /* XXX: The lack of buffering here is NOT a bug, modules implementing this interface have to - * implement their own buffering mechanisms - */ - ServerInstance->Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, text.data(), text.length()); + this->GetIOHook()->OnRawSocketWrite(this->fd, text.data(), text.length()); } catch (CoreException& modexcept) { - ServerInstance->Log(DEBUG, "%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); + ServerInstance->Logs->Log("USEROUTPUT", DEBUG, "%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } else @@ -1121,11 +1277,37 @@ void User::WriteServ(const char* text, ...) } +void User::WriteNumeric(unsigned int numeric, const char* text, ...) +{ + va_list argsPtr; + char textbuffer[MAXBUF]; + + va_start(argsPtr, text); + vsnprintf(textbuffer, MAXBUF, text, argsPtr); + va_end(argsPtr); + + this->WriteNumeric(numeric, std::string(textbuffer)); +} + +void User::WriteNumeric(unsigned int numeric, const std::string &text) +{ + char textbuffer[MAXBUF]; + int MOD_RESULT = 0; + + FOREACH_RESULT(I_OnNumeric, OnNumeric(this, numeric, text)); + + if (MOD_RESULT) + return; + + snprintf(textbuffer,MAXBUF,":%s %03u %s",ServerInstance->Config->ServerName, numeric, text.c_str()); + this->Write(std::string(textbuffer)); +} + void User::WriteFrom(User *user, const std::string &text) { char tb[MAXBUF]; - snprintf(tb,MAXBUF,":%s %s",user->GetFullHost(),text.c_str()); + snprintf(tb,MAXBUF,":%s %s",user->GetFullHost().c_str(),text.c_str()); this->Write(std::string(tb)); } @@ -1183,47 +1365,42 @@ void User::WriteCommon(const char* text, ...) void User::WriteCommon(const std::string &text) { - try - { - bool sent_to_at_least_one = false; - char tb[MAXBUF]; + bool sent_to_at_least_one = false; + char tb[MAXBUF]; - if (this->registered != REG_ALL) - return; + if (this->registered != REG_ALL) + return; - uniq_id++; + uniq_id++; + + if (!already_sent) + InitializeAlreadySent(ServerInstance->SE); - /* We dont want to be doing this n times, just once */ - snprintf(tb,MAXBUF,":%s %s",this->GetFullHost(),text.c_str()); - std::string out = tb; + /* We dont want to be doing this n times, just once */ + snprintf(tb,MAXBUF,":%s %s",this->GetFullHost().c_str(),text.c_str()); + std::string out = tb; - for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) + for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) + { + CUList* ulist = v->first->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - CUList* ulist = v->first->GetUsers(); - for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id)) { - if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id)) - { - already_sent[i->first->fd] = uniq_id; - i->first->Write(out); - sent_to_at_least_one = true; - } + already_sent[i->first->fd] = uniq_id; + i->first->Write(out); + sent_to_at_least_one = true; } } - - /* - * if the user was not in any channels, no users will receive the text. Make sure the user - * receives their OWN message for WriteCommon - */ - if (!sent_to_at_least_one) - { - this->Write(std::string(tb)); - } } - catch (...) + /* + * if the user was not in any channels, no users will receive the text. Make sure the user + * receives their OWN message for WriteCommon + */ + if (!sent_to_at_least_one) { - ServerInstance->Log(DEBUG,"Exception in User::WriteCommon()"); + this->Write(std::string(tb)); } } @@ -1253,8 +1430,12 @@ void User::WriteCommonQuit(const std::string &normal_text, const std::string &op return; uniq_id++; - snprintf(tb1,MAXBUF,":%s QUIT :%s",this->GetFullHost(),normal_text.c_str()); - snprintf(tb2,MAXBUF,":%s QUIT :%s",this->GetFullHost(),oper_text.c_str()); + + if (!already_sent) + InitializeAlreadySent(ServerInstance->SE); + + snprintf(tb1,MAXBUF,":%s QUIT :%s",this->GetFullHost().c_str(),normal_text.c_str()); + snprintf(tb2,MAXBUF,":%s QUIT :%s",this->GetFullHost().c_str(),oper_text.c_str()); std::string out1 = tb1; std::string out2 = tb2; @@ -1284,7 +1465,11 @@ void User::WriteCommonExcept(const std::string &text) return; uniq_id++; - snprintf(tb1,MAXBUF,":%s %s",this->GetFullHost(),text.c_str()); + + if (!already_sent) + InitializeAlreadySent(ServerInstance->SE); + + snprintf(tb1,MAXBUF,":%s %s",this->GetFullHost().c_str(),text.c_str()); out1 = tb1; for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) @@ -1307,13 +1492,10 @@ void User::WriteCommonExcept(const std::string &text) void User::WriteWallOps(const std::string &text) { - if (!IS_OPER(this) && IS_LOCAL(this)) - return; - std::string wallop("WALLOPS :"); wallop.append(text); - for (std::vector::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++) + for (std::vector::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++) { User* t = *i; if (t->IsModeSet('w')) @@ -1323,6 +1505,9 @@ void User::WriteWallOps(const std::string &text) void User::WriteWallOps(const char* text, ...) { + if (!IS_LOCAL(this)) + return; + char textbuffer[MAXBUF]; va_list argsPtr; @@ -1364,7 +1549,7 @@ bool User::SharesChannelWith(User *other) bool User::ChangeName(const char* gecos) { - if (!strcmp(gecos, this->fullname)) + if (!this->fullname.compare(gecos)) return true; if (IS_LOCAL(this)) @@ -1375,76 +1560,84 @@ bool User::ChangeName(const char* gecos) return false; FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos)); } - strlcpy(this->fullname,gecos,MAXGECOS+1); + this->fullname.assign(gecos, 0, ServerInstance->Config->Limits.MaxGecos); return true; } -bool User::ChangeDisplayedHost(const char* host) +bool User::ChangeDisplayedHost(const char* shost) { - if (!strcmp(host, this->dhost)) + if (dhost == shost) return true; if (IS_LOCAL(this)) { int MOD_RESULT = 0; - FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(this,host)); + FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(this,shost)); if (MOD_RESULT) return false; - FOREACH_MOD(I_OnChangeHost,OnChangeHost(this,host)); } - if (this->ServerInstance->Config->CycleHosts) + + FOREACH_MOD(I_OnChangeHost, OnChangeHost(this,shost)); + + int MOD_RESULT = 0; + FOREACH_RESULT(I_OnHostCycle, OnHostCycle(this)); + + if (this->ServerInstance->Config->CycleHosts && !MOD_RESULT) this->WriteCommonExcept("QUIT :Changing hosts"); /* Fix by Om: User::dhost is 65 long, this was truncating some long hosts */ - strlcpy(this->dhost,host,64); + this->dhost.assign(shost, 0, 64); this->InvalidateCache(); - if (this->ServerInstance->Config->CycleHosts) + if (this->ServerInstance->Config->CycleHosts && !MOD_RESULT) { for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name); + i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name.c_str()); std::string n = this->ServerInstance->Modes->ModeString(this, i->first); if (n.length() > 0) - i->first->WriteAllExceptSender(this, true, 0, "MODE %s +%s", i->first->name, n.c_str()); + i->first->WriteAllExceptSender(this, true, 0, "MODE %s +%s", i->first->name.c_str(), n.c_str()); } } if (IS_LOCAL(this)) - this->WriteServ("396 %s %s :is now your displayed host",this->nick,this->dhost); + this->WriteNumeric(RPL_YOURDISPLAYEDHOST, "%s %s :is now your displayed host",this->nick.c_str(),this->dhost.c_str()); return true; } bool User::ChangeIdent(const char* newident) { - if (!strcmp(newident, this->ident)) + if (this->ident == newident) return true; - if (this->ServerInstance->Config->CycleHosts) + int MOD_RESULT = 0; + FOREACH_RESULT(I_OnHostCycle, OnHostCycle(this)); + + if (this->ServerInstance->Config->CycleHosts && !MOD_RESULT) this->WriteCommonExcept("%s","QUIT :Changing ident"); - strlcpy(this->ident, newident, IDENTMAX+2); + this->ident.assign(newident, 0, ServerInstance->Config->Limits.IdentMax + 1); this->InvalidateCache(); - if (this->ServerInstance->Config->CycleHosts) + if (this->ServerInstance->Config->CycleHosts && !MOD_RESULT) { for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name); + i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name.c_str()); std::string n = this->ServerInstance->Modes->ModeString(this, i->first); if (n.length() > 0) - i->first->WriteAllExceptSender(this, true, 0, "MODE %s +%s", i->first->name, n.c_str()); + i->first->WriteAllExceptSender(this, true, 0, "MODE %s +%s", i->first->name.c_str(), n.c_str()); } } return true; } -void User::SendAll(const char* command, char* text, ...) +void User::SendAll(const char* command, const char* text, ...) { char textbuffer[MAXBUF]; char formatbuffer[MAXBUF]; @@ -1454,10 +1647,10 @@ void User::SendAll(const char* command, char* text, ...) vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); - snprintf(formatbuffer,MAXBUF,":%s %s $* :%s", this->GetFullHost(), command, textbuffer); + snprintf(formatbuffer,MAXBUF,":%s %s $* :%s", this->GetFullHost().c_str(), command, textbuffer); std::string fmt = formatbuffer; - for (std::vector::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++) + for (std::vector::const_iterator i = ServerInstance->Users->local_users.begin(); i != ServerInstance->Users->local_users.end(); i++) { (*i)->Write(fmt); } @@ -1466,27 +1659,21 @@ void User::SendAll(const char* command, char* text, ...) std::string User::ChannelList(User* source) { - try + std::string list; + + for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - std::string list; - for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) + /* If the target is the same as the sender, let them see all their channels. + * If the channel is NOT private/secret OR the user shares a common channel + * If the user is an oper, and the option is set. + */ + if ((source == this) || (IS_OPER(source) && ServerInstance->Config->OperSpyWhois) || (((!i->first->IsModeSet('p')) && (!i->first->IsModeSet('s'))) || (i->first->HasUser(source)))) { - /* If the target is the same as the sender, let them see all their channels. - * If the channel is NOT private/secret OR the user shares a common channel - * If the user is an oper, and the option is set. - */ - if ((source == this) || (IS_OPER(source) && ServerInstance->Config->OperSpyWhois) || (((!i->first->IsModeSet('p')) && (!i->first->IsModeSet('s'))) || (i->first->HasUser(source)))) - { - list.append(i->first->GetPrefixChar(this)).append(i->first->name).append(" "); - } + list.append(i->first->GetPrefixChar(this)).append(i->first->name).append(" "); } - return list; - } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::ChannelList()"); - return ""; } + + return list; } void User::SplitChanList(User* dest, const std::string &cl) @@ -1495,51 +1682,37 @@ void User::SplitChanList(User* dest, const std::string &cl) std::ostringstream prefix; std::string::size_type start, pos, length; - try + prefix << this->nick << " " << dest->nick << " :"; + line = prefix.str(); + int namelen = strlen(ServerInstance->Config->ServerName) + 6; + + for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1) { - prefix << this->nick << " " << dest->nick << " :"; - line = prefix.str(); - int namelen = strlen(ServerInstance->Config->ServerName) + 6; + length = (pos == std::string::npos) ? cl.length() : pos; - for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1) + if (line.length() + namelen + length - start > 510) { - length = (pos == std::string::npos) ? cl.length() : pos; - - if (line.length() + namelen + length - start > 510) - { - ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); - line = prefix.str(); - } - - if(pos == std::string::npos) - { - line.append(cl.substr(start, length - start)); - break; - } - else - { - line.append(cl.substr(start, length - start + 1)); - } + ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); + line = prefix.str(); } - if (line.length()) + if(pos == std::string::npos) { - ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); + line.append(cl.substr(start, length - start)); + break; + } + else + { + line.append(cl.substr(start, length - start + 1)); } } - catch (...) + if (line.length()) { - ServerInstance->Log(DEBUG,"Exception in User::SplitChanList()"); + ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); } } -unsigned int User::GetMaxChans() -{ - return this->MaxChans; -} - - /* * Sets a user's connection class. * If the class name is provided, it will be used. Otherwise, the class will be guessed using host/ip/ident/etc. @@ -1554,14 +1727,17 @@ ConnectClass* User::SetClass(const std::string &explicit_name) if (!IS_LOCAL(this)) return NULL; + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Setting connect class for UID %s", this->uuid.c_str()); + if (!explicit_name.empty()) { for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++) { ConnectClass* c = *i; - if (explicit_name == c->GetName() && !c->GetDisabled()) + if (explicit_name == c->name) { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Explicitly set to %s", explicit_name.c_str()); found = c; } } @@ -1572,48 +1748,71 @@ ConnectClass* User::SetClass(const std::string &explicit_name) { ConnectClass* c = *i; - if (((match(this->GetIPString(),c->GetHost().c_str(),true)) || (match(this->host,c->GetHost().c_str())))) + if (c->type == CC_ALLOW) { - if (c->GetPort()) - { - if (this->GetPort() == c->GetPort() && !c->GetDisabled()) - { - found = c; - } - else - continue; - } - else + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "ALLOW %s %d %s", c->host.c_str(), c->GetPort(), c->GetName().c_str()); + } + else + { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "DENY %s %d %s", c->GetHost().c_str(), c->GetPort(), c->GetName().c_str()); + } + + /* check if host matches.. */ + if (c->GetHost().length() && !InspIRCd::MatchCIDR(this->GetIPString(), c->GetHost(), NULL) && + !InspIRCd::MatchCIDR(this->host, c->GetHost(), NULL)) + { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "No host match (for %s)", c->GetHost().c_str()); + continue; + } + + /* + * deny change if change will take class over the limit check it HERE, not after we found a matching class, + * because we should attempt to find another class if this one doesn't match us. -- w00t + */ + if (c->limit && (c->RefCount >= c->limit)) + { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "OOPS: Connect class limit (%lu) hit, denying", c->limit); + continue; + } + + /* if it requires a port ... */ + if (c->GetPort()) + { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Requires port (%d)", c->GetPort()); + + /* and our port doesn't match, fail. */ + if (this->GetServerPort() != c->GetPort()) { - if (!c->GetDisabled()) - found = c; + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Port match failed (%d)", this->GetServerPort()); + continue; } } + + /* we stop at the first class that meets ALL critera. */ + found = c; + break; } } - /* ensure we don't fuck things up refcount wise, only remove them from a class if we find a new one :P */ + /* + * Okay, assuming we found a class that matches.. switch us into that class, keeping refcounts up to date. + */ if (found) { - /* deny change if change will take class over the limit */ - if (found->limit && (found->RefCount + 1 >= found->limit)) - { - ServerInstance->Log(DEBUG, "OOPS: Connect class limit (%u) hit, denying", found->limit); - return this->MyClass; - } - - /* should always be valid, but just in case .. */ + /* only fiddle with refcounts if they are already in a class .. */ if (this->MyClass) { if (found == this->MyClass) // no point changing this shit :P return this->MyClass; this->MyClass->RefCount--; - ServerInstance->Log(DEBUG, "Untying user from connect class -- refcount: %u", this->MyClass->RefCount); + ServerInstance->Logs->Log("USERS", DEBUG, "Untying user from connect class -- refcount: %lu", this->MyClass->RefCount); + if (MyClass->RefCount == 0) + delete MyClass; } this->MyClass = found; this->MyClass->RefCount++; - ServerInstance->Log(DEBUG, "User tied to new class -- connect refcount now: %u", this->MyClass->RefCount); + ServerInstance->Logs->Log("USERS", DEBUG, "User tied to new class -- connect refcount now: %lu", this->MyClass->RefCount); } return this->MyClass; @@ -1646,7 +1845,7 @@ void User::PurgeEmptyChannels() } catch (...) { - ServerInstance->Log(DEBUG,"Exception in User::PurgeEmptyChannels to_delete.push_back()"); + ServerInstance->Logs->Log("USERS", DEBUG,"Exception in User::PurgeEmptyChannels to_delete.push_back()"); } } } @@ -1657,6 +1856,10 @@ void User::PurgeEmptyChannels() chan_hash::iterator i2 = ServerInstance->chanlist->find(thischan->name); if (i2 != ServerInstance->chanlist->end()) { + int MOD_RESULT = 0; + FOREACH_RESULT_I(ServerInstance,I_OnChannelPreDelete, OnChannelPreDelete(i2->second)); + if (MOD_RESULT == 1) + continue; // delete halted by module FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second)); delete i2->second; ServerInstance->chanlist->erase(i2); @@ -1671,69 +1874,49 @@ void User::ShowMOTD() { if (!ServerInstance->Config->MOTD.size()) { - this->WriteServ("422 %s :Message of the day file is missing.",this->nick); + this->WriteNumeric(ERR_NOMOTD, "%s :Message of the day file is missing.",this->nick.c_str()); return; } - this->WriteServ("375 %s :%s message of the day", this->nick, ServerInstance->Config->ServerName); + this->WriteNumeric(RPL_MOTDSTART, "%s :%s message of the day", this->nick.c_str(), ServerInstance->Config->ServerName); for (file_cache::iterator i = ServerInstance->Config->MOTD.begin(); i != ServerInstance->Config->MOTD.end(); i++) - this->WriteServ("372 %s :- %s",this->nick,i->c_str()); + this->WriteNumeric(RPL_MOTD, "%s :- %s",this->nick.c_str(),i->c_str()); - this->WriteServ("376 %s :End of message of the day.", this->nick); + this->WriteNumeric(RPL_ENDOFMOTD, "%s :End of message of the day.", this->nick.c_str()); } void User::ShowRULES() { if (!ServerInstance->Config->RULES.size()) { - this->WriteServ("434 %s :RULES File is missing",this->nick); + this->WriteNumeric(ERR_NORULES, "%s :RULES File is missing",this->nick.c_str()); return; } - this->WriteServ("308 %s :- %s Server Rules -",this->nick,ServerInstance->Config->ServerName); + this->WriteNumeric(RPL_RULESTART, "%s :- %s Server Rules -",this->nick.c_str(),ServerInstance->Config->ServerName); for (file_cache::iterator i = ServerInstance->Config->RULES.begin(); i != ServerInstance->Config->RULES.end(); i++) - this->WriteServ("232 %s :- %s",this->nick,i->c_str()); + this->WriteNumeric(RPL_RULES, "%s :- %s",this->nick.c_str(),i->c_str()); - this->WriteServ("309 %s :End of RULES command.",this->nick); + this->WriteNumeric(RPL_RULESEND, "%s :End of RULES command.",this->nick.c_str()); } void User::HandleEvent(EventType et, int errornum) { - if (this->muted) // drop everything, user is due to be quit + if (this->quitting) // drop everything, user is due to be quit return; - /* WARNING: May delete this user! */ - int thisfd = this->GetFd(); - - try - { - switch (et) - { - case EVENT_READ: - ServerInstance->ProcessUser(this); - break; - case EVENT_WRITE: - this->FlushWriteBuf(); - break; - case EVENT_ERROR: - /** This should be safe, but dont DARE do anything after it -- Brain */ - this->SetWriteError(errornum ? strerror(errornum) : "EOF from client"); - break; - } - } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::HandleEvent intercepted"); - } - - /* If the user has raised an error whilst being processed, quit them now we're safe to */ - if ((ServerInstance->SE->GetRef(thisfd) == this)) + switch (et) { - if (!WriteError.empty()) - { - User::QuitUser(ServerInstance, this, GetWriteError()); - } + case EVENT_READ: + ServerInstance->ProcessUser(this); + break; + case EVENT_WRITE: + this->FlushWriteBuf(); + break; + case EVENT_ERROR: + ServerInstance->Users->QuitUser(this, errornum ? strerror(errornum) : "Client closed the connection"); + break; } } @@ -1742,9 +1925,9 @@ void User::SetOperQuit(const std::string &oquit) operquitmsg = oquit; } -const char* User::GetOperQuit() +const std::string& User::GetOperQuit() { - return operquitmsg.c_str(); + return operquitmsg; } void User::IncreasePenalty(int increase) @@ -1757,6 +1940,26 @@ void User::DecreasePenalty(int decrease) this->Penalty -= decrease; } +void FakeUser::SetFakeServer(std::string name) +{ + this->nick = name; + this->server = nick.c_str(); +} + +const std::string FakeUser::GetFullHost() +{ + if (*ServerInstance->Config->HideWhoisServer) + return ServerInstance->Config->HideWhoisServer; + return nick; +} + +const std::string FakeUser::GetFullRealHost() +{ + if (*ServerInstance->Config->HideWhoisServer) + return ServerInstance->Config->HideWhoisServer; + return nick; +} + VisData::VisData() { } @@ -1770,3 +1973,28 @@ bool VisData::VisibleTo(User* user) return true; } + +ConnectClass::ConnectClass(char t, const std::string& mask) + : type(t), name("unnamed"), registration_timeout(0), host(mask), pingtime(0), pass(""), hash(""), sendqmax(0), recvqmax(0), maxlocal(0), maxglobal(0), maxchans(0), port(0), limit(0), RefCount(1) +{ +} + +ConnectClass::ConnectClass(char t, const std::string& mask, const ConnectClass& parent) + : type(t), name("unnamed"), registration_timeout(parent.registration_timeout), host(mask), pingtime(parent.pingtime), pass(parent.pass), hash(parent.hash), sendqmax(parent.sendqmax), recvqmax(parent.recvqmax), maxlocal(parent.maxlocal), maxglobal(parent.maxglobal), maxchans(parent.maxchans), port(parent.port), limit(parent.limit), RefCount(1) +{ +} + +void ConnectClass::Update(const ConnectClass* src) +{ + name = src->name; + registration_timeout = src->registration_timeout; + host = src->host; + pingtime = src->pingtime; + pass = src->pass; + hash = src->hash; + sendqmax = src->sendqmax; + recvqmax = src->recvqmax; + maxlocal = src->maxlocal; + maxglobal = src->maxglobal; + limit = src->limit; +}