X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fusers.cpp;h=b81cd6d912d2bd6ca3bc8bbdc3833183144f12ae;hb=5d67a5fff127bf95bca69b436ef7f645f2fe3281;hp=5141053bab2e1bb2852c2478a80a218c58b871c3;hpb=b57c7f4e466f72fdd2ac3deca42caa1ea7748338;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/users.cpp b/src/users.cpp index 5141053ba..6087f4d1c 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -2,8 +2,8 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd: (C) 2002-2007 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,70 +11,27 @@ * --------------------------------------------------- */ +/* $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; - -bool InitTypes(ServerConfig* conf, const char* tag) -{ - if (conf->opertypes.size()) - { - for (opertype_t::iterator n = conf->opertypes.begin(); n != conf->opertypes.end(); n++) - { - if (n->second) - delete[] n->second; - } - } - - conf->opertypes.clear(); - return true; -} - -bool InitClasses(ServerConfig* conf, const char* tag) -{ - if (conf->operclass.size()) - { - for (operclass_t::iterator n = conf->operclass.begin(); n != conf->operclass.end(); n++) - { - if (n->second) - delete[] n->second; - } - } +unsigned long uniq_id = 1; - conf->operclass.clear(); - return true; -} - -bool DoType(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types) -{ - const char* TypeName = values[0].GetString(); - const char* Classes = values[1].GetString(); +static unsigned long* already_sent = NULL; - conf->opertypes[TypeName] = strnewdup(Classes); - return true; -} -bool DoClass(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types) +void InitializeAlreadySent(SocketEngine* SE) { - const char* ClassName = values[0].GetString(); - const char* CommandList = values[1].GetString(); - - conf->operclass[ClassName] = strnewdup(CommandList); - return true; + already_sent = new unsigned long[SE->GetMaxFds()]; + memset(already_sent, 0, SE->GetMaxFds() * sizeof(unsigned long)); } -bool DoneClassesAndTypes(ServerConfig* conf, const char* tag) -{ - return true; -} std::string User::ProcessNoticeMasks(const char *sm) { @@ -123,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; } @@ -130,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; } @@ -137,133 +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()); } } -UserResolver::UserResolver(InspIRCd* Instance, User* user, std::string to_resolve, QueryType qt, bool &cache) : - Resolver(Instance, to_resolve, qt, cache), bound_user(user) -{ - this->fwd = (qt == DNS_QUERY_A || qt == DNS_QUERY_AAAA); - this->bound_fd = user->GetFd(); -} - -void UserResolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached, int resultnum) -{ - /* We are only interested in the first matching result */ - if (resultnum) - return; - - if ((!this->fwd) && (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user)) - { - this->bound_user->stored_host = result; - try - { - /* Check we didnt time out */ - if (this->bound_user->registered != REG_ALL) - { - bool cached; -#ifdef IPV6 - if (this->bound_user->GetProtocolFamily() == AF_INET6) - { - /* IPV6 forward lookup (with possibility of 4in6) */ - const char* ip = this->bound_user->GetIPString(); - bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, (!strncmp(ip, "0::ffff:", 8) ? DNS_QUERY_A : DNS_QUERY_AAAA), cached); - } - else - /* IPV4 lookup (mixed protocol mode) */ -#endif - /* IPV4 lookup (ipv4 only mode) */ - bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A, cached); - this->ServerInstance->AddResolver(bound_user->res_forward, cached); - } - } - catch (CoreException& e) - { - ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason()); - } - } - else if ((this->fwd) && (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user)) - { - /* Both lookups completed */ - std::string result2("0::ffff:"); - result2.append(result); - if (this->bound_user->GetIPString() == result || this->bound_user->GetIPString() == result2) - { - std::string hostname = this->bound_user->stored_host; - if (hostname.length() < 65) - { - /* Check we didnt time out */ - if ((this->bound_user->registered != REG_ALL) && (!this->bound_user->dns_done)) - { - /* Hostnames starting with : are not a good thing (tm) */ - if (*(hostname.c_str()) == ':') - hostname.insert(0, "0"); - - this->bound_user->WriteServ("NOTICE Auth :*** Found your hostname (%s)%s", hostname.c_str(), (cached ? " -- cached" : "")); - this->bound_user->dns_done = true; - strlcpy(this->bound_user->dhost, hostname.c_str(),64); - strlcpy(this->bound_user->host, hostname.c_str(),64); - /* Invalidate cache */ - this->bound_user->InvalidateCache(); - } - } - else - { - if (!this->bound_user->dns_done) - { - this->bound_user->WriteServ("NOTICE Auth :*** Your hostname is longer than the maximum of 64 characters, using your IP address (%s) instead.", this->bound_user->GetIPString()); - this->bound_user->dns_done = true; - } - } - } - else - { - if (!this->bound_user->dns_done) - { - this->bound_user->WriteServ("NOTICE Auth :*** Your hostname does not match up with your IP address. Sorry, using your IP address (%s) instead.", this->bound_user->GetIPString()); - this->bound_user->dns_done = true; - } - } - } -} - -void UserResolver::OnError(ResolverError e, const std::string &errormessage) -{ - if (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user) - { - /* Since dns timeout is implemented outside of the resolver, this was a race condition that could result in this message being sent *after* - * the user was fully connected. This check fixes that issue - Special */ - if (!this->bound_user->dns_done) - { - /* Error message here */ - this->bound_user->WriteServ("NOTICE Auth :*** Could not resolve your hostname: %s; using your IP address (%s) instead.", errormessage.c_str(), this->bound_user->GetIPString()); - this->bound_user->dns_done = true; - } - } -} - - 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; } @@ -282,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); } } @@ -327,153 +206,136 @@ 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); - lines_in = lastping = signon = idle_lastmsg = nping = registered = 0; - ChannelCount = timeout = flood = bytes_in = bytes_out = cmds_in = cmds_out = 0; - muted = exempt = haspassed = dns_done = false; + server = Instance->FindServerNamePtr(Instance->Config->ServerName); + age = ServerInstance->Time(); + Penalty = 0; + 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; + AllowedPrivs = AllowedOperCommands = NULL; chans.clear(); invites.clear(); - memset(modes,0,sizeof(modes)); - memset(snomasks,0,sizeof(snomasks)); - /* Invalidate cache */ - operquit = 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"); } -void User::RemoveCloneCounts() +User::~User() { - clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString()); - if (x != ServerInstance->local_clones.end()) + /* NULL for remote users :) */ + if (this->MyClass) { - x->second--; - if (!x->second) - { - ServerInstance->local_clones.erase(x); - } + this->MyClass->RefCount--; + ServerInstance->Logs->Log("USERS", DEBUG, "User destructor -- connect refcount now: %lu", this->MyClass->RefCount); + if (MyClass->RefCount == 0) + delete MyClass; } - - clonemap::iterator y = ServerInstance->global_clones.find(this->GetIPString()); - if (y != ServerInstance->global_clones.end()) + + if (this->AllowedOperCommands) { - y->second--; - if (!y->second) - { - ServerInstance->global_clones.erase(y); - } + delete AllowedOperCommands; + AllowedOperCommands = NULL; + } + + if (this->AllowedPrivs) + { + delete AllowedPrivs; + AllowedPrivs = NULL; } -} -User::~User() -{ this->InvalidateCache(); this->DecrementModes(); - if (operquit) - free(operquit); - if (ip) - { - this->RemoveCloneCounts(); - if (this->GetProtocolFamily() == AF_INET) - { - delete (sockaddr_in*)ip; - } -#ifdef SUPPORT_IP6LINKS - else - { - delete (sockaddr_in6*)ip; - } -#endif - } + if (client_sa.sa.sa_family != AF_UNSPEC) + ServerInstance->Users->RemoveCloneCounts(this); - 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; } @@ -484,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; @@ -505,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; } } @@ -541,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; @@ -561,12 +460,22 @@ void User::RemoveInvite(const irc::string &channel) } } -bool User::HasPermission(const std::string &command) +bool User::HasModePermission(unsigned char mode, ModeType type) { - char* mycmd; - char* savept; - char* savept2; + 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) +{ /* * users on remote servers can completely bypass all permissions based checks. * This prevents desyncs when one server has different type/class tags to another. @@ -578,76 +487,121 @@ bool User::HasPermission(const std::string &command) return true; // are they even an oper at all? - if (IS_OPER(this)) + if (!IS_OPER(this)) { - opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper); - if (iter_opertype != ServerInstance->Config->opertypes.end()) - { - char* Classes = strdup(iter_opertype->second); - char* myclass = strtok_r(Classes," ",&savept); - while (myclass) - { - operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass); - if (iter_operclass != ServerInstance->Config->operclass.end()) - { - char* CommandList = strdup(iter_operclass->second); - mycmd = strtok_r(CommandList," ",&savept2); - while (mycmd) - { - if ((!strcasecmp(mycmd,command.c_str())) || (*mycmd == '*')) - { - free(Classes); - free(CommandList); - return true; - } - mycmd = strtok_r(NULL," ",&savept2); - } - free(CommandList); - } - myclass = strtok_r(NULL," ",&savept); - } - free(Classes); - } + return false; } + + if (!AllowedOperCommands) + return false; + + if (AllowedOperCommands->find(command) != AllowedOperCommands->end()) + return true; + else if (AllowedOperCommands->find("*") != AllowedOperCommands->end()) + return true; + 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)) + { + 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()) { - std::string::size_type i = a.rfind('\r'); + 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 (recvq.length() > (unsigned)this->recvqmax) + 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->recvqmax); - 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() @@ -664,7 +618,7 @@ std::string User::GetBuffer() { try { - if (!recvq.length()) + if (recvq.empty()) return ""; /* Strip any leading \r or \n off the string. @@ -695,356 +649,283 @@ 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 (sendq.length() + data.length() > (unsigned)this->sendqmax) + 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->sendqmax); + 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 (n_sent == -1) + 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 (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) -{ - try - { - 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); - FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype)); - } + 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); - catch (...) + /* + * 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()) { - ServerInstance->Log(DEBUG,"Exception in User::Oper()"); - } -} + if (AllowedOperCommands) + AllowedOperCommands->clear(); + else + AllowedOperCommands = new std::set; -void User::UnOper() -{ - try - { - if (IS_OPER(this)) + if (AllowedPrivs) + AllowedPrivs->clear(); + else + AllowedPrivs = new std::set; + + AllowedUserModes.reset(); + AllowedChanModes.reset(); + this->AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want. + + std::string myclass, mycmd, mypriv; + irc::spacesepstream Classes(iter_opertype->second.c_str()); + while (Classes.GetToken(myclass)) { - // 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); - } - } + operclass_t::iterator iter_operclass = ServerInstance->Config->operclass.find(myclass.c_str()); + if (iter_operclass != ServerInstance->Config->operclass.end()) + { + /* Process commands */ + irc::spacesepstream CommandList(iter_operclass->second.commandlist); + while (CommandList.GetToken(mycmd)) + { + this->AllowedOperCommands->insert(mycmd); + } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::UnOper()"); - } -} + irc::spacesepstream PrivList(iter_operclass->second.privs); + while (PrivList.GetToken(mypriv)) + { + this->AllowedPrivs->insert(mypriv); + } -void User::QuitUser(InspIRCd* Instance, User *user, const std::string &quitreason, const char* operreason) -{ - user->Write("ERROR :Closing link (%s@%s) [%s]", user->ident, user->host, operreason); - user->muted = true; - Instance->GlobalCulls.AddItem(user, quitreason.c_str(), operreason); -} + for (unsigned char* c = (unsigned char*)iter_operclass->second.umodelist; *c; ++c) + { + if (*c == '*') + { + this->AllowedUserModes.set(); + } + else + { + this->AllowedUserModes[*c - 'A'] = true; + } + } -/* adds or updates an entry in the whowas list */ -void User::AddToWhoWas() -{ - Command* whowas_command = ServerInstance->Parser->GetHandler("WHOWAS"); - if (whowas_command) - { - std::deque params; - params.push_back(this); - whowas_command->HandleInternal(WHOWAS_ADD, params); + for (unsigned char* c = (unsigned char*)iter_operclass->second.cmodelist; *c; ++c) + { + if (*c == '*') + { + this->AllowedChanModes.set(); + } + else + { + this->AllowedChanModes[*c - 'A'] = true; + } + } + } + } } + + FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype, opername)); } -/* add a client connection to the sockets list */ -void User::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, int socketfamily, sockaddr* ip) +void User::UnOper() { - /* NOTE: Calling this one parameter constructor for User automatically - * allocates a new UUID and places it in the hash_map. - */ - User* New = NULL; - try - { - New = new User(Instance); - } - catch (...) + if (IS_OPER(this)) { - Instance->Log(DEFAULT,"*** WTF *** Duplicated UUID! -- Crack smoking monkies have been unleashed."); - Instance->WriteOpers("*** WARNING *** Duplicate UUID allocated!"); - return; - } - - int j = 0; - - Instance->unregistered_count++; - - char ipaddr[MAXBUF]; -#ifdef IPV6 - if (socketfamily == AF_INET6) - inet_ntop(AF_INET6, &((const sockaddr_in6*)ip)->sin6_addr, ipaddr, sizeof(ipaddr)); - else -#endif - inet_ntop(AF_INET, &((const sockaddr_in*)ip)->sin_addr, ipaddr, sizeof(ipaddr)); - - (*(Instance->clientlist))[New->uuid] = New; - New->SetFd(socket); - - /* The users default nick is their UUID */ - strlcpy(New->nick, New->uuid, NICKMAX - 1); - - New->server = Instance->FindServerNamePtr(Instance->Config->ServerName); - /* We don't need range checking here, we KNOW 'unknown\0' will fit into the ident field. */ - strcpy(New->ident, "unknown"); - - New->registered = REG_NONE; - New->signon = Instance->Time() + Instance->Config->dns_timeout; - New->lastping = 1; - - New->SetSockAddr(socketfamily, ipaddr, port); + /* + * 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(); - /* Smarter than your average bear^H^H^H^Hset of strlcpys. */ - for (const char* temp = New->GetIPString(); *temp && j < 64; temp++, j++) - New->dhost[j] = New->host[j] = *temp; - New->dhost[j] = New->host[j] = 0; - Instance->AddLocalClone(New); - Instance->AddGlobalClone(New); + /* Remove all oper only modes from the user when the deoper - Bug #466*/ + std::string moderemove("-"); - /* - * First class check. We do this again in FullConnect after DNS is done, and NICK/USER is recieved. - * See my note down there for why this is required. DO NOT REMOVE. :) -- w00t - */ - ConnectClass* i = New->GetClass(); - - if (!i) - { - User::QuitUser(Instance, New, "Access denied by configuration"); - return; - } + for (unsigned char letter = 'A'; letter <= 'z'; letter++) + { + ModeHandler* mh = ServerInstance->Modes->FindMode(letter, MODETYPE_USER); + if (mh && mh->NeedsOper()) + moderemove += letter; + } - /* - * Check connect class settings and initialise settings into User. - * This will be done again after DNS resolution. -- w00t - */ - New->CheckClass(); - Instance->local_users.push_back(New); + std::vector parameters; + parameters.push_back(this->nick); + parameters.push_back(moderemove); - if ((Instance->local_users.size() > Instance->Config->SoftLimit) || (Instance->local_users.size() >= MAXCLIENTS)) - { - Instance->WriteOpers("*** Warning: softlimit value has been reached: %d clients", Instance->Config->SoftLimit); - User::QuitUser(Instance, New,"No more connections allowed"); - return; - } + ServerInstance->Parser->CallHandler("MODE", parameters, this); - /* - * XXX - - * this is done as a safety check to keep the file descriptors within range of fd_ref_table. - * its a pretty big but for the moment valid assumption: - * file descriptors are handed out starting at 0, and are recycled as theyre freed. - * therefore if there is ever an fd over 65535, 65536 clients must be connected to the - * irc server at once (or the irc server otherwise initiating this many connections, files etc) - * which for the time being is a physical impossibility (even the largest networks dont have more - * than about 10,000 users on ONE server!) - */ -#ifndef WINDOWS - if ((unsigned int)socket >= MAX_DESCRIPTORS) - { - User::QuitUser(Instance, New, "Server is full"); - return; - } -#endif + /* remove the user from the oper list. Will remove multiple entries as a safeguard against bug #404 */ + ServerInstance->Users->all_opers.remove(this); - New->exempt = (Instance->XLines->matches_exception(New) != NULL); - if (!New->exempt) - { - ZLine* r = Instance->XLines->matches_zline(ipaddr); - if (r) + if (AllowedOperCommands) { - char reason[MAXBUF]; - if (*Instance->Config->MoronBanner) - New->WriteServ("NOTICE %s :*** %s", New->nick, Instance->Config->MoronBanner); - snprintf(reason,MAXBUF,"Z-Lined: %s",r->reason); - User::QuitUser(Instance, New, reason); - return; + delete AllowedOperCommands; + AllowedOperCommands = NULL; } - } - - if (socket > -1) - { - if (!Instance->SE->AddFd(New)) - { - User::QuitUser(Instance, New, "Internal error handling connection"); - } - } - /* NOTE: even if dns lookups are *off*, we still need to display this. - * BOPM and other stuff requires it. - */ - New->WriteServ("NOTICE Auth :*** Looking up your hostname..."); -} + if (AllowedPrivs) + { + delete AllowedPrivs; + AllowedPrivs = NULL; + } -unsigned long User::GlobalCloneCount() -{ - clonemap::iterator x = ServerInstance->global_clones.find(this->GetIPString()); - if (x != ServerInstance->global_clones.end()) - return x->second; - else - return 0; + AllowedUserModes.reset(); + AllowedChanModes.reset(); + this->modes[UM_OPERATOR] = 0; + } } -unsigned long User::LocalCloneCount() +/* adds or updates an entry in the whowas list */ +void User::AddToWhoWas() { - clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString()); - if (x != ServerInstance->local_clones.end()) - return x->second; - else - return 0; + Command* whowas_command = ServerInstance->Parser->GetHandler("WHOWAS"); + if (whowas_command) + { + std::deque params; + params.push_back(this); + whowas_command->HandleInternal(WHOWAS_ADD, params); + } } /* * Check class restrictions */ -void User::CheckClass(const std::string &explicit_class) +void User::CheckClass() { - ConnectClass* a = this->GetClass(explicit_class); + 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()) && (this->LocalCloneCount() > a->GetMaxLocal())) + 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()) && (this->GlobalCloneCount() > a->GetMaxGlobal())) + 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->pingmax = a->GetPingTime(); this->nping = ServerInstance->Time() + a->GetPingTime() + ServerInstance->Config->dns_timeout; - this->timeout = ServerInstance->Time() + a->GetRegTimeout(); - this->flood = a->GetFlood(); - this->threshold = a->GetThreshold(); - this->sendqmax = a->GetSendqMax(); - this->recvqmax = a->GetRecvqMax(); - 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() @@ -1058,72 +939,47 @@ void User::FullConnect() * may put the user into a totally seperate class with different restrictions! so we *must* check again. * Don't remove this! -- w00t */ - this->CheckClass(); - + 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->GetClass()->GetPass().empty()) && (!this->haspassed)) + 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 = ServerInstance->XLines->matches_gline(this); - - if (r) - { - this->muted = true; - char reason[MAXBUF]; - if (*ServerInstance->Config->MoronBanner) - this->WriteServ("NOTICE %s :*** %s", this->nick, ServerInstance->Config->MoronBanner); - snprintf(reason,MAXBUF,"G-Lined: %s",r->reason); - User::QuitUser(ServerInstance, this, reason); - return; - } - - KLine* n = ServerInstance->XLines->matches_kline(this); - if (n) - { - this->muted = true; - char reason[MAXBUF]; - if (*ServerInstance->Config->MoronBanner) - this->WriteServ("NOTICE %s :*** %s", this, ServerInstance->Config->MoronBanner); - snprintf(reason,MAXBUF,"K-Lined: %s",n->reason); - User::QuitUser(ServerInstance, this, reason); - 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); /* - * fix 3 by brain, move registered = 7 below these so that spurious modes and host - * changes dont go out onto the network and produce 'fake direction'. + * 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(I_OnUserConnect,OnUserConnect(this)); @@ -1131,7 +987,10 @@ 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->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(), "", ""); } /** User::UpdateNick() @@ -1140,234 +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 */ + if (oldnick == ServerInstance->Users->clientlist->end()) + return NULL; /* doesnt exist */ - User* olduser = oldnick->second; - (*(ServerInstance->clientlist))[New] = olduser; - ServerInstance->clientlist->erase(oldnick); - return olduser; - } - - 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; - - this->InvalidateCache(); - - FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick)); - - if (MOD_RESULT) - { - ServerInstance->stats->statsCollisions++; - return false; - } - - if (ServerInstance->XLines->matches_qline(newnick)) - { - ServerInstance->stats->statsCollisions++; - return false; - } + int MOD_RESULT = 0; - 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; - } - } - return false; - } + this->InvalidateCache(); - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in User::ForceNickChange()"); - return false; - } -} + this->Extend("NICKForced", "Enabled"); -void User::SetSockAddr(int protocol_family, const char* ip, int port) -{ - switch (protocol_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 - 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,"Ut oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick); - break; + FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick)); + + this->Shrink("NICKForced"); + + if (MOD_RESULT) + { + ServerInstance->stats->statsCollisions++; + return false; } + + std::deque dummy; + Command* nickhandler = ServerInstance->Parser->GetHandler("NICK"); + if (nickhandler) // wtfbbq, when would this not be here + { + 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; } -int User::GetPort() +int User::GetServerPort() { - if (this->ip == NULL) - return 0; - - switch (this->GetProtocolFamily()) + switch (this->server_sa.sa.sa_family) { -#ifdef SUPPORT_IP6LINKS case AF_INET6: - { - sockaddr_in6* sin = (sockaddr_in6*)this->ip; - return sin->sin6_port; - } - break; -#endif + return htons(this->server_sa.in6.sin6_port); case AF_INET: - { - sockaddr_in* sin = (sockaddr_in*)this->ip; - return sin->sin_port; - } - break; - default: - break; + return htons(this->server_sa.in4.sin_port); } return 0; } -int User::GetProtocolFamily() -{ - if (this->ip == NULL) - return 0; - - sockaddr_in* sin = (sockaddr_in*)this->ip; - return sin->sin_family; -} - -const char* User::GetIPString() +const char* User::GetCIDRMask(int range) { - static char buf[1024]; + static char buf[44]; - if (this->ip == NULL) - return ""; + if (range < 0) + throw "Negative range, sorry, no."; - switch (this->GetProtocolFamily()) + /* + * 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: { - static char temp[1024]; + /* 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]; + } - 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 == ':') + /* And zero all the remaining bytes in the IP. */ + for(; i < 16; i++) { - strlcpy(&temp[1], buf, sizeof(temp) - 1); - *temp = '0'; - return temp; + 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; - inet_ntop(sin->sin_family, &sin->sin_addr, buf, sizeof(buf)); + 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 ""; + + return ""; // unused, but oh well } -const char* User::GetIPString(char* buf) +std::string User::GetServerIP() { - if (this->ip == NULL) - { - *buf = 0; - return buf; - } + int port; + std::string ip; + irc::sockets::satoap(&server_sa, ip, port); + return ip; +} - switch (this->GetProtocolFamily()) +const char* User::GetIPString() +{ + int port; + if (cachedip.empty()) { -#ifdef SUPPORT_IP6LINKS - case AF_INET6: - { - static char temp[1024]; + 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'); + } - 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'; - strlcpy(buf, temp, sizeof(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; + return cachedip.c_str(); +} - default: - break; - } - return ""; +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. @@ -1383,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 @@ -1456,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)); } @@ -1518,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)); } } @@ -1588,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; @@ -1619,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++) @@ -1642,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')) @@ -1658,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; @@ -1699,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)) @@ -1710,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]; @@ -1789,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); } @@ -1801,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) @@ -1830,84 +1682,150 @@ 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; -} - -/* looks up a users password for their connection class (/ tags) +/* + * 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. * NOTE: If the or tag specifies an ip, and this user resolves, * then their ip will be taken as 'priority' anyway, so for example, * will match joe!bloggs@localhost */ -ConnectClass* User::GetClass(const std::string &explicit_name) +ConnectClass* User::SetClass(const std::string &explicit_name) { + ConnectClass *found = NULL; + + 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++) { - if (explicit_name == i->GetName()) - return &(*i); + ConnectClass* c = *i; + + if (explicit_name == c->name) + { + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Explicitly set to %s", explicit_name.c_str()); + found = c; + } } } else { for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++) { - if (((match(this->GetIPString(),i->GetHost().c_str(),true)) || (match(this->host,i->GetHost().c_str())))) + ConnectClass* c = *i; + + if (c->type == CC_ALLOW) + { + 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()) { - if (i->GetPort()) + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Requires port (%d)", c->GetPort()); + + /* and our port doesn't match, fail. */ + if (this->GetServerPort() != c->GetPort()) { - if (this->GetPort() == i->GetPort()) - return &(*i); - else - continue; + ServerInstance->Logs->Log("CONNECTCLASS", DEBUG, "Port match failed (%d)", this->GetServerPort()); + continue; } - else - return &(*i); } + + /* we stop at the first class that meets ALL critera. */ + found = c; + break; + } + } + + /* + * Okay, assuming we found a class that matches.. switch us into that class, keeping refcounts up to date. + */ + if (found) + { + /* 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->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->Logs->Log("USERS", DEBUG, "User tied to new class -- connect refcount now: %lu", this->MyClass->RefCount); } - return NULL; + + return this->MyClass; +} + +/* looks up a users password for their connection class (/ tags) + * NOTE: If the or tag specifies an ip, and this user resolves, + * then their ip will be taken as 'priority' anyway, so for example, + * will match joe!bloggs@localhost + */ +ConnectClass* User::GetClass() +{ + return this->MyClass; } void User::PurgeEmptyChannels() @@ -1927,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()"); } } } @@ -1938,8 +1856,12 @@ 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); + delete i2->second; ServerInstance->chanlist->erase(i2); this->chans.erase(*n); } @@ -1952,80 +1874,90 @@ 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) { - /* 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 (this->quitting) // drop everything, user is due to be quit + return; - /* 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; } } void User::SetOperQuit(const std::string &oquit) { - if (operquit) - return; + operquitmsg = oquit; +} + +const std::string& User::GetOperQuit() +{ + return operquitmsg; +} + +void User::IncreasePenalty(int increase) +{ + this->Penalty += increase; +} - operquit = strdup(oquit.c_str()); +void User::DecreasePenalty(int decrease) +{ + this->Penalty -= decrease; +} + +void FakeUser::SetFakeServer(std::string name) +{ + this->nick = name; + this->server = nick.c_str(); } -const char* User::GetOperQuit() +const std::string FakeUser::GetFullHost() { - return operquit ? operquit : ""; + 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() @@ -2041,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; +}