X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fusers.cpp;h=e79d27c8b74cfc70290235b97c4fd70bd538a2ec;hb=9cf56d917d92959701694477f7944d45ad2c38ed;hp=31264570fec1c5ce7aed504b4031e7d539fc92ed;hpb=d8877eb74fc436cfd9c89445b4e2da3c7188e840;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/users.cpp b/src/users.cpp index 31264570f..e79d27c8b 100644 --- a/src/users.cpp +++ b/src/users.cpp @@ -2,14 +2,11 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * - * - * Written by Craig Edwards, Craig McLure, and others. + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits + * * This program is free but copyrighted software; see - * the file COPYING for details. + * the file COPYING for details. * * --------------------------------------------------- */ @@ -22,7 +19,7 @@ #include "socketengine.h" #include "wildcard.h" #include "xline.h" -#include "cull_list.h" +#include "commands/cmd_whowas.h" static unsigned long already_sent[MAX_DESCRIPTORS] = {0}; @@ -33,15 +30,13 @@ bool InitTypes(ServerConfig* conf, const char* tag) { if (conf->opertypes.size()) { - conf->GetInstance()->Log(DEBUG,"Currently %d items to clear",conf->opertypes.size()); for (opertype_t::iterator n = conf->opertypes.begin(); n != conf->opertypes.end(); n++) { - conf->GetInstance()->Log(DEBUG,"Clear item"); if (n->second) delete[] n->second; } } - + conf->opertypes.clear(); return true; } @@ -56,28 +51,26 @@ bool InitClasses(ServerConfig* conf, const char* tag) delete[] n->second; } } - + conf->operclass.clear(); return true; } -bool DoType(ServerConfig* conf, const char* tag, char** entries, void** values, int* types) +bool DoType(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types) { - char* TypeName = (char*)values[0]; - char* Classes = (char*)values[1]; - - conf->opertypes[TypeName] = strdup(Classes); - conf->GetInstance()->Log(DEBUG,"Read oper TYPE '%s' with classes '%s'",TypeName,Classes); + const char* TypeName = values[0].GetString(); + const char* Classes = values[1].GetString(); + + conf->opertypes[TypeName] = strnewdup(Classes); return true; } -bool DoClass(ServerConfig* conf, const char* tag, char** entries, void** values, int* types) +bool DoClass(ServerConfig* conf, const char* tag, char** entries, ValueList &values, int* types) { - char* ClassName = (char*)values[0]; - char* CommandList = (char*)values[1]; - - conf->operclass[ClassName] = strdup(CommandList); - conf->GetInstance()->Log(DEBUG,"Read oper CLASS '%s' with commands '%s'",ClassName,CommandList); + const char* ClassName = values[0].GetString(); + const char* CommandList = values[1].GetString(); + + conf->operclass[ClassName] = strnewdup(CommandList); return true; } @@ -92,12 +85,8 @@ std::string userrec::ProcessNoticeMasks(const char *sm) const char *c = sm; std::string output; - ServerInstance->Log(DEBUG,"Process notice masks"); - while (c && *c) { - ServerInstance->Log(DEBUG,"Process notice mask %c",*c); - switch (*c) { case '+': @@ -149,47 +138,63 @@ std::string userrec::ProcessNoticeMasks(const char *sm) void userrec::StartDNSLookup() { - ServerInstance->Log(DEBUG,"Commencing reverse lookup"); try { - ServerInstance->Log(DEBUG,"Passing instance: %08x",this->ServerInstance); - res_reverse = new UserResolver(this->ServerInstance, this, this->GetIPString(), DNS_QUERY_REVERSE); - this->ServerInstance->AddResolver(res_reverse); + bool cached; + const char* ip = this->GetIPString(); + + /* 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); + + this->ServerInstance->AddResolver(res_reverse, cached); } - catch (ModuleException& e) + catch (CoreException& e) { ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason()); } } -UserResolver::UserResolver(InspIRCd* Instance, userrec* user, std::string to_resolve, QueryType qt) : - Resolver(Instance, to_resolve, qt), bound_user(user) +UserResolver::UserResolver(InspIRCd* Instance, userrec* 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) +void UserResolver::OnLookupComplete(const std::string &result, unsigned int ttl, bool cached) { if ((!this->fwd) && (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user)) { - ServerInstance->Log(DEBUG,"Commencing forward lookup"); this->bound_user->stored_host = result; try { /* Check we didnt time out */ if (this->bound_user->registered != REG_ALL) { + bool cached; #ifdef IPV6 - const char *ip = this->bound_user->GetIPString(); - bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, (strstr(ip,"0::ffff:") == ip ? DNS_QUERY_A : DNS_QUERY_AAAA)); + 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) */ + bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A, cached); + } #else - bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A); + /* IPV4 lookup (ipv4 only mode) */ + bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A, cached); #endif - this->ServerInstance->AddResolver(bound_user->res_forward); + this->ServerInstance->AddResolver(bound_user->res_forward, cached); } } - catch (ModuleException& e) + catch (CoreException& e) { ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason()); } @@ -205,26 +210,36 @@ void UserResolver::OnLookupComplete(const std::string &result) if (hostname.length() < 65) { /* Check we didnt time out */ - if (this->bound_user->registered != REG_ALL) + 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 = "0" + hostname; - this->bound_user->WriteServ("NOTICE Auth :*** Found your hostname (%s)", hostname.c_str()); + 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 { - 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()); + 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 { - 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()); + 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; + } } } } @@ -233,9 +248,14 @@ void UserResolver::OnError(ResolverError e, const std::string &errormessage) { if (ServerInstance->SE->GetRef(this->bound_fd) == this->bound_user) { - /* Error message here */ - this->bound_user->WriteServ("NOTICE Auth :*** Could not resolve your hostname, using your IP address (%s) instead.", this->bound_user->GetIPString()); - this->bound_user->dns_done = true; + /* 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; + } } } @@ -290,9 +310,21 @@ const char* userrec::FormatModes() return data; } +void userrec::DecrementModes() +{ + for (int n = 0; n < 64; n++) + { + if (modes[n]) + { + ModeHandler* mh = ServerInstance->Modes->FindMode(n+65, MODETYPE_USER); + if (mh) + mh->ChangeCount(-1); + } + } +} + userrec::userrec(InspIRCd* Instance) : ServerInstance(Instance) { - ServerInstance->Log(DEBUG,"userrec::userrec(): Instance: %08x",ServerInstance); // the PROPER way to do it, AVOID bzero at *ALL* costs *password = *nick = *ident = *host = *dhost = *fullname = *awaymsg = *oper = 0; server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName); @@ -300,37 +332,50 @@ userrec::userrec(InspIRCd* Instance) : ServerInstance(Instance) 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; - haspassed = dns_done = false; + muted = exempt = haspassed = dns_done = false; fd = -1; recvq = ""; sendq = ""; WriteError = ""; res_forward = res_reverse = NULL; + Visibility = NULL; ip = NULL; chans.clear(); invites.clear(); - chans.resize(MAXCHANS); memset(modes,0,sizeof(modes)); memset(snomasks,0,sizeof(snomasks)); - - for (unsigned int n = 0; n < MAXCHANS; n++) - { - chans[n] = new ucrec(); - chans[n]->channel = NULL; - chans[n]->uc_modes = 0; - } + /* Invalidate cache */ + operquit = cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL; } userrec::~userrec() { - for (std::vector::iterator n = chans.begin(); n != chans.end(); n++) - { - ucrec* x = (ucrec*)*n; - delete x; - } - + this->InvalidateCache(); + this->DecrementModes(); + if (operquit) + free(operquit); if (ip) { + clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString()); + if (x != ServerInstance->local_clones.end()) + { + x->second--; + if (!x->second) + { + ServerInstance->local_clones.erase(x); + } + } + + clonemap::iterator y = ServerInstance->global_clones.find(this->GetIPString()); + if (y != ServerInstance->global_clones.end()) + { + y->second--; + if (!y->second) + { + ServerInstance->global_clones.erase(y); + } + } + if (this->GetProtocolFamily() == AF_INET) { delete (sockaddr_in*)ip; @@ -346,7 +391,10 @@ userrec::~userrec() char* userrec::MakeHost() { - static char nhost[MAXBUF]; + if (this->cached_makehost) + return this->cached_makehost; + + char nhost[MAXBUF]; /* This is much faster than snprintf */ char* t = nhost; for(char* n = ident; *n; n++) @@ -355,12 +403,18 @@ char* userrec::MakeHost() for(char* n = host; *n; n++) *t++ = *n; *t = 0; - return nhost; + + this->cached_makehost = strdup(nhost); + + return this->cached_makehost; } char* userrec::MakeHostIP() { - static char ihost[MAXBUF]; + if (this->cached_hostip) + return this->cached_hostip; + + char ihost[MAXBUF]; /* This is much faster than snprintf */ char* t = ihost; for(char* n = ident; *n; n++) @@ -369,7 +423,10 @@ char* userrec::MakeHostIP() for(const char* n = this->GetIPString(); *n; n++) *t++ = *n; *t = 0; - return ihost; + + this->cached_hostip = strdup(ihost); + + return this->cached_hostip; } void userrec::CloseSocket() @@ -377,10 +434,13 @@ void userrec::CloseSocket() shutdown(this->fd,2); close(this->fd); } - + char* userrec::GetFullHost() { - static char result[MAXBUF]; + if (this->cached_fullhost) + return this->cached_fullhost; + + char result[MAXBUF]; char* t = result; for(char* n = nick; *n; n++) *t++ = *n; @@ -391,7 +451,10 @@ char* userrec::GetFullHost() for(char* n = dhost; *n; n++) *t++ = *n; *t = 0; - return result; + + this->cached_fullhost = strdup(result); + + return this->cached_fullhost; } char* userrec::MakeWildHost() @@ -410,7 +473,11 @@ int userrec::ReadData(void* buffer, size_t size) { if (IS_LOCAL(this)) { +#ifndef WIN32 return read(this->fd, buffer, size); +#else + return recv(this->fd, (char*)buffer, size, 0); +#endif } else return 0; @@ -419,7 +486,10 @@ int userrec::ReadData(void* buffer, size_t size) char* userrec::GetFullRealHost() { - static char fresult[MAXBUF]; + if (this->cached_fullrealhost) + return this->cached_fullrealhost; + + char fresult[MAXBUF]; char* t = fresult; for(char* n = nick; *n; n++) *t++ = *n; @@ -430,16 +500,17 @@ char* userrec::GetFullRealHost() for(char* n = host; *n; n++) *t++ = *n; *t = 0; - return fresult; + + this->cached_fullrealhost = strdup(fresult); + + return this->cached_fullrealhost; } -bool userrec::IsInvited(irc::string &channel) +bool userrec::IsInvited(const irc::string &channel) { for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++) { - irc::string compare = i->channel; - - if (compare == channel) + if (channel == *i) { return true; } @@ -452,30 +523,21 @@ InvitedList* userrec::GetInviteList() return &invites; } -void userrec::InviteTo(irc::string &channel) +void userrec::InviteTo(const irc::string &channel) { - Invited i; - i.channel = channel; - invites.push_back(i); + invites.push_back(channel); } -void userrec::RemoveInvite(irc::string &channel) +void userrec::RemoveInvite(const irc::string &channel) { - ServerInstance->Log(DEBUG,"Removing invites"); - - if (invites.size()) + for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++) { - for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++) + if (channel == *i) { - irc::string compare = i->channel; - - if (compare == channel) - { - invites.erase(i); - return; - } - } - } + invites.erase(i); + return; + } + } } bool userrec::HasPermission(const std::string &command) @@ -483,7 +545,7 @@ bool userrec::HasPermission(const std::string &command) char* mycmd; char* savept; char* savept2; - + /* * users on remote servers can completely bypass all permissions based checks. * This prevents desyncs when one server has different type/class tags to another. @@ -493,9 +555,9 @@ bool userrec::HasPermission(const std::string &command) */ if (!IS_LOCAL(this)) return true; - + // are they even an oper at all? - if (*this->oper) + if (IS_OPER(this)) { opertype_t::iterator iter_opertype = ServerInstance->Config->opertypes.find(this->oper); if (iter_opertype != ServerInstance->Config->opertypes.end()) @@ -540,7 +602,7 @@ bool userrec::AddBuffer(std::string a) try { std::string::size_type i = a.rfind('\r'); - + while (i != std::string::npos) { a.erase(i, 1); @@ -549,14 +611,14 @@ bool userrec::AddBuffer(std::string a) if (a.length()) recvq.append(a); - + if (recvq.length() > (unsigned)this->recvqmax) { 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; } - + return true; } @@ -583,14 +645,14 @@ std::string userrec::GetBuffer() { if (!recvq.length()) return ""; - + /* Strip any leading \r or \n off the string. * Usually there are only one or two of these, * so its is computationally cheap to do. */ while ((*recvq.begin() == '\r') || (*recvq.begin() == '\n')) recvq.erase(recvq.begin()); - + for (std::string::iterator x = recvq.begin(); x != recvq.end(); x++) { /* Find the first complete line, return it as the @@ -617,7 +679,7 @@ void userrec::AddWriteBuf(const std::string &data) { if (*this->GetWriteError()) return; - + if (sendq.length() + data.length() > (unsigned)this->sendqmax) { /* @@ -630,19 +692,12 @@ void userrec::AddWriteBuf(const std::string &data) return; } - try + try { - if (data.length() > 512) - { - std::string newdata(data); - newdata.resize(510); - newdata.append("\r\n"); - sendq.append(newdata); - } + 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 (...) { @@ -663,32 +718,38 @@ void userrec::FlushWriteBuf() if ((sendq.length()) && (this->fd != FD_MAGIC_NUMBER)) { int old_sendq_length = sendq.length(); - const char* tb = this->sendq.c_str(); - int n_sent = write(this->fd,tb,this->sendq.length()); +#ifndef WIN32 + int n_sent = write(this->fd, this->sendq.data(), this->sendq.length()); +#else + int n_sent = send(this->fd, (const char*)this->sendq.data(), this->sendq.length(), 0); +#endif if (n_sent == -1) { if (errno == EAGAIN) { - ServerInstance->Log(DEBUG,"EAGAIN, want write"); + /* 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(strerror(errno)); + return; + } } else { - /*ServerInstance->Log(DEBUG,"Wrote: %d of %d: %s", n_sent, old_sendq_length, sendq.substr(0, n_sent).c_str());*/ - // advance the queue - tb += n_sent; - this->sendq = tb; - // update the user's stats counters + /* 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) - { - ServerInstance->Log(DEBUG,"Not all written, want write"); this->ServerInstance->SE->WantWrite(this); - } } } } @@ -697,19 +758,20 @@ void userrec::FlushWriteBuf() { ServerInstance->Log(DEBUG,"Exception in userrec::FlushWriteBuf()"); } + + if (this->sendq.empty()) + { + FOREACH_MOD(I_OnBufferFlushed,OnBufferFlushed(this)); + } } void userrec::SetWriteError(const std::string &error) { try { - ServerInstance->Log(DEBUG,"SetWriteError: %s",error.c_str()); // don't try to set the error twice, its already set take the first string. - if (!this->WriteError.length()) - { - ServerInstance->Log(DEBUG,"Setting error string for %s to '%s'",this->nick,error.c_str()); + if (this->WriteError.empty()) this->WriteError = error; - } } catch (...) @@ -746,15 +808,17 @@ void userrec::UnOper() { try { - if (*this->oper) + if (IS_OPER(this)) { + // unset their oper type (what IS_OPER checks), and remove +o *this->oper = 0; this->modes[UM_OPERATOR] = 0; + + // remove them from the opers list. for (std::vector::iterator a = ServerInstance->all_opers.begin(); a < ServerInstance->all_opers.end(); a++) { if (*a == this) { - ServerInstance->Log(DEBUG,"Oper removed from optimization list"); ServerInstance->all_opers.erase(a); return; } @@ -768,228 +832,43 @@ void userrec::UnOper() } } -void userrec::QuitUser(InspIRCd* Instance, userrec *user, const std::string &quitreason) +void userrec::QuitUser(InspIRCd* Instance, userrec *user, const std::string &quitreason, const char* operreason) { - user_hash::iterator iter = Instance->clientlist.find(user->nick); - std::string reason = quitreason; - - if (reason.length() > MAXQUIT - 1) - reason.resize(MAXQUIT - 1); - - if (IS_LOCAL(user)) - user->Write("ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,reason.c_str()); - - if (user->registered == REG_ALL) - { - user->PurgeEmptyChannels(); - FOREACH_MOD_I(Instance,I_OnUserQuit,OnUserQuit(user,reason)); - user->WriteCommonExcept("QUIT :%s",reason.c_str()); - } - - if (IS_LOCAL(user)) - user->FlushWriteBuf(); - - FOREACH_MOD_I(Instance,I_OnUserDisconnect,OnUserDisconnect(user)); - - if (IS_LOCAL(user)) - { - if (Instance->Config->GetIOHook(user->GetPort())) - { - try - { - Instance->Config->GetIOHook(user->GetPort())->OnRawSocketClose(user->fd); - } - catch (ModuleException& modexcept) - { - Instance->Log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); - } - } - - Instance->SE->DelFd(user); - user->CloseSocket(); - } - - /* - * this must come before the ServerInstance->SNO->WriteToSnoMaskso that it doesnt try to fill their buffer with anything - * if they were an oper with +sn +qQ. - */ - if (user->registered == REG_ALL) - { - if (IS_LOCAL(user)) - Instance->SNO->WriteToSnoMask('q',"Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason.c_str()); - else - Instance->SNO->WriteToSnoMask('Q',"Client exiting on server %s: %s!%s@%s [%s]",user->server,user->nick,user->ident,user->host,reason.c_str()); - user->AddToWhoWas(); - } - - if (iter != Instance->clientlist.end()) - { - Instance->Log(DEBUG,"deleting user hash value %lx",(unsigned long)user); - if (IS_LOCAL(user)) - { - if (find(Instance->local_users.begin(),Instance->local_users.end(),user) != Instance->local_users.end()) - Instance->local_users.erase(find(Instance->local_users.begin(),Instance->local_users.end(),user)); - } - Instance->clientlist.erase(iter); - DELETE(user); - } + user->muted = true; + Instance->GlobalCulls.AddItem(user, quitreason.c_str(), operreason); } -namespace irc -{ - namespace whowas - { - - WhoWasGroup::WhoWasGroup(userrec* user) : host(NULL), dhost(NULL), ident(NULL), server(NULL), gecos(NULL), signon(user->signon) - { - this->host = strdup(user->host); - this->dhost = strdup(user->dhost); - this->ident = strdup(user->ident); - this->server = user->server; - this->gecos = strdup(user->fullname); - } - - WhoWasGroup::~WhoWasGroup() - { - if (host) - free(host); - if (dhost) - free(dhost); - if (ident) - free(ident); - if (gecos) - free(gecos); - } - - /* every hour, run this function which removes all entries older than Config->WhoWasMaxKeep */ - void MaintainWhoWas(InspIRCd* ServerInstance, time_t t) - { - for (whowas_users::iterator iter = ServerInstance->whowas.begin(); iter != ServerInstance->whowas.end(); iter++) - { - whowas_set* n = (whowas_set*)iter->second; - if (n->size()) - { - while ((n->begin() != n->end()) && ((*n->begin())->signon < t - ServerInstance->Config->WhoWasMaxKeep)) - { - WhoWasGroup *a = *(n->begin()); - DELETE(a); - n->erase(n->begin()); - } - } - } - } - /* on rehash, refactor maps according to new conf values */ - void PruneWhoWas(InspIRCd* ServerInstance, time_t t) - { - /* config values */ - int groupsize = ServerInstance->Config->WhoWasGroupSize; - int maxgroups = ServerInstance->Config->WhoWasMaxGroups; - int maxkeep = ServerInstance->Config->WhoWasMaxKeep; - - int groupcount = ServerInstance->whowas.size(); - /* iterate whowas_fifo oldest first */ - whowas_users_fifo::iterator iter, safeiter; - for (iter = ServerInstance->whowas_fifo.begin(); iter != ServerInstance->whowas_fifo.end(); iter++) - { - /** prune all groups that has expired due to new maxkeep time and - * also any group number higher than new maxgroups. The oldest are - * removed first due to iteration over whowas_fifo - */ - if (groupcount > maxgroups || iter->first < t - maxkeep) - { - whowas_set* n = (whowas_set*)ServerInstance->whowas.find(iter->second)->second; - if (n->size()) - { - while (n->begin() != n->end()) - { - WhoWasGroup *a = *(n->begin()); - DELETE(a); - n->erase(n->begin()); - } - } - ServerInstance->whowas.erase(iter->second); - /* use a safe iter copy for erase and set the orig iter old valid ref by decrementing it */ - safeiter = iter; - --iter; - ServerInstance->whowas_fifo.erase(safeiter); - } - else { - /* also trim individual groupsizes in case groupsize should have been lowered */ - whowas_set* n = (whowas_set*)ServerInstance->whowas.find(iter->second)->second; - if (n->size()) - { - int nickcount = n->size(); - while (n->begin() != n->end() && nickcount > groupsize) - { - WhoWasGroup *a = *(n->begin()); - DELETE(a); - n->erase(n->begin()); - nickcount--; - } - } - } - groupcount--; - } - } - }; -}; - /* adds or updates an entry in the whowas list */ void userrec::AddToWhoWas() { - /* if whowas disabled */ - if (ServerInstance->Config->WhoWasGroupSize == 0 || ServerInstance->Config->WhoWasMaxGroups == 0) + command_t* whowas_command = ServerInstance->Parser->GetHandler("WHOWAS"); + if (whowas_command) { - return; - } - - irc::whowas::whowas_users::iterator iter = ServerInstance->whowas.find(this->nick); - - ServerInstance->Log(DEBUG,"Add to whowas lists"); - - if (iter == ServerInstance->whowas.end()) - { - ServerInstance->Log(DEBUG,"Adding new whowas set for %s",this->nick); - irc::whowas::whowas_set* n = new irc::whowas::whowas_set; - irc::whowas::WhoWasGroup *a = new irc::whowas::WhoWasGroup(this); - n->push_back(a); - ServerInstance->whowas[this->nick] = n; - ServerInstance->whowas_fifo[ServerInstance->Time()] = this->nick; - if ((int)(ServerInstance->whowas.size()) > ServerInstance->Config->WhoWasMaxGroups) - { - ServerInstance->Log(DEBUG,"Maxgroups of %d reached deleting oldest group '%s'",ServerInstance->Config->WhoWasMaxGroups, ServerInstance->whowas_fifo.begin()->second.c_str()); - ServerInstance->whowas.erase(ServerInstance->whowas_fifo.begin()->second); - ServerInstance->whowas_fifo.erase(ServerInstance->whowas_fifo.begin()); - } - } - else - { - irc::whowas::whowas_set* group = (irc::whowas::whowas_set*)iter->second; - - ServerInstance->Log(DEBUG,"Using existing whowas group for %s",this->nick); - - if ((int)(group->size()) >= ServerInstance->Config->WhoWasGroupSize) - { - ServerInstance->Log(DEBUG,"Trimming existing group '%s' to %d entries",this->nick, ServerInstance->Config->WhoWasGroupSize); - irc::whowas::WhoWasGroup *a = (irc::whowas::WhoWasGroup*)*(group->begin()); - DELETE(a); - group->pop_front(); - } - - irc::whowas::WhoWasGroup *a = new irc::whowas::WhoWasGroup(this); - group->push_back(a); + std::deque params; + params.push_back(this); + whowas_command->HandleInternal(WHOWAS_ADD, params); } } /* add a client connection to the sockets list */ -void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, insp_inaddr ip) +void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, int socketfamily, sockaddr* ip) { std::string tempnick = ConvToStr(socket) + "-unknown"; - user_hash::iterator iter = Instance->clientlist.find(tempnick); - const char *ipaddr = insp_ntoa(ip); + user_hash::iterator iter = Instance->clientlist->find(tempnick); + char ipaddr[MAXBUF]; +#ifdef IPV6 + if (socketfamily == AF_INET6) + inet_ntop(AF_INET6, &((const sockaddr_in6*)ip)->sin6_addr, ipaddr, sizeof(ipaddr)); + else + inet_ntop(AF_INET, &((const sockaddr_in*)ip)->sin_addr, ipaddr, sizeof(ipaddr)); +#else + inet_ntop(AF_INET, &((const sockaddr_in*)ip)->sin_addr, ipaddr, sizeof(ipaddr)); +#endif userrec* New; int j = 0; + Instance->unregistered_count++; + /* * fix by brain. * as these nicknames are 'RFC impossible', we can be sure nobody is going to be @@ -999,17 +878,15 @@ void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, * this was probably the cause of 'server ignores me when i hammer it with reconnects' * issue in earlier alphas/betas */ - if (iter != Instance->clientlist.end()) + if (iter != Instance->clientlist->end()) { userrec* goner = iter->second; DELETE(goner); - Instance->clientlist.erase(iter); + Instance->clientlist->erase(iter); } - Instance->Log(DEBUG,"AddClient: %d %d %s",socket,port,ipaddr); - New = new userrec(Instance); - Instance->clientlist[tempnick] = New; + (*(Instance->clientlist))[tempnick] = New; New->fd = socket; strlcpy(New->nick,tempnick.c_str(),NICKMAX-1); @@ -1021,63 +898,40 @@ void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, New->signon = Instance->Time() + Instance->Config->dns_timeout; New->lastping = 1; - Instance->Log(DEBUG,"Setting socket addresses"); - New->SetSockAddr(AF_FAMILY, ipaddr, port); - Instance->Log(DEBUG,"Socket addresses set."); + New->SetSockAddr(socketfamily, ipaddr, port); /* 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->Log(DEBUG,"Hosts set."); - - // set the registration timeout for this user - unsigned long class_regtimeout = 90; - int class_flood = 0; - long class_threshold = 5; - long class_sqmax = 262144; // 256kb - long class_rqmax = 4096; // 4k - Instance->Log(DEBUG,"Class stuff set."); + Instance->AddLocalClone(New); + Instance->AddGlobalClone(New); - for (ClassVector::iterator i = Instance->Config->Classes.begin(); i != Instance->Config->Classes.end(); i++) - { - if ((i->type == CC_ALLOW) && (match(ipaddr,i->host.c_str(),true))) - { - class_regtimeout = (unsigned long)i->registration_timeout; - class_flood = i->flood; - New->pingmax = i->pingtime; - class_threshold = i->threshold; - class_sqmax = i->sendqmax; - class_rqmax = i->recvqmax; - break; - } - } - - Instance->Log(DEBUG,"nping etc set."); + /* + * 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(); + New->CheckClass(); - New->nping = Instance->Time() + New->pingmax + Instance->Config->dns_timeout; - New->timeout = Instance->Time() + class_regtimeout; - New->flood = class_flood; - New->threshold = class_threshold; - New->sendqmax = class_sqmax; - New->recvqmax = class_rqmax; + New->pingmax = i->GetPingTime(); + New->nping = Instance->Time() + i->GetPingTime() + Instance->Config->dns_timeout; + New->timeout = Instance->Time() + i->GetRegTimeout(); + New->flood = i->GetFlood(); + New->threshold = i->GetThreshold(); + New->sendqmax = i->GetSendqMax(); + New->recvqmax = i->GetRecvqMax(); - Instance->Log(DEBUG,"Push back to local users."); Instance->local_users.push_back(New); - Instance->Log(DEBUG,"Check softlimit: %d %d %d",Instance->local_users.size(), Instance->Config->SoftLimit, MAXCLIENTS); if ((Instance->local_users.size() > Instance->Config->SoftLimit) || (Instance->local_users.size() >= MAXCLIENTS)) { - Instance->Log(DEBUG,"Check softlimit failed"); Instance->WriteOpers("*** Warning: softlimit value has been reached: %d clients", Instance->Config->SoftLimit); userrec::QuitUser(Instance, New,"No more connections allowed"); return; } - Instance->Log(DEBUG,"Softlimit passed."); - /* * XXX - * this is done as a safety check to keep the file descriptors within range of fd_ref_table. @@ -1088,143 +942,137 @@ void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, * 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) { userrec::QuitUser(Instance, New, "Server is full"); return; } +#endif - Instance->Log(DEBUG,"socket < MAX_DESCRIPTORS passed."); - - ELine* e = Instance->XLines->matches_exception(New); - if (!e) + New->exempt = (Instance->XLines->matches_exception(New) != NULL); + if (!New->exempt) { - Instance->Log(DEBUG,"Doesnt match eline."); ZLine* r = Instance->XLines->matches_zline(ipaddr); if (r) { - Instance->Log(DEBUG,"Matches zline."); char reason[MAXBUF]; snprintf(reason,MAXBUF,"Z-Lined: %s",r->reason); userrec::QuitUser(Instance, New, reason); return; } - Instance->Log(DEBUG,"Doesnt match zline."); } - Instance->Log(DEBUG,"Check before AddFd."); - if (socket > -1) { - Instance->Log(DEBUG,"Adding fd."); if (!Instance->SE->AddFd(New)) { - Instance->Log(DEBUG,"Oops, fd already exists"); userrec::QuitUser(Instance, New, "Internal error handling connection"); return; } } + /* 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..."); } -long userrec::GlobalCloneCount() +unsigned long userrec::GlobalCloneCount() { - char u2[128]; - long x = 0; - strlcpy(u2, this->GetIPString(), 64); - - for (user_hash::const_iterator a = ServerInstance->clientlist.begin(); a != ServerInstance->clientlist.end(); a++) - { - /* We have to match ip's as strings - we don't know what protocol - * a remote user may be using - */ - if (strcasecmp(a->second->GetIPString(), u2) == 0) - x++; - } - - return x; + clonemap::iterator x = ServerInstance->global_clones.find(this->GetIPString()); + if (x != ServerInstance->global_clones.end()) + return x->second; + else + return 0; } -long userrec::LocalCloneCount() +unsigned long userrec::LocalCloneCount() { - long x = 0; - for (std::vector::const_iterator a = ServerInstance->local_users.begin(); a != ServerInstance->local_users.end(); a++) - { - userrec* comp = *a; -#ifdef IPV6 - /* I dont think theres any faster way of matching two ipv6 addresses than memcmp */ - in6_addr* s1 = &(((sockaddr_in6*)comp->ip)->sin6_addr); - in6_addr* s2 = &(((sockaddr_in6*)this->ip)->sin6_addr); - if (!memcmp(s1->s6_addr, s2->s6_addr, sizeof(in6_addr))) - x++; -#else - in_addr* s1 = &((sockaddr_in*)comp->ip)->sin_addr; - in_addr* s2 = &((sockaddr_in*)this->ip)->sin_addr; - if (s1->s_addr == s2->s_addr) - x++; -#endif - } - return x; + clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString()); + if (x != ServerInstance->local_clones.end()) + return x->second; + else + return 0; } -void userrec::FullConnect(CullList* Goners) +/* + * Check class restrictions + */ +void userrec::CheckClass() { - ServerInstance->stats->statsConnects++; - this->idle_lastmsg = ServerInstance->Time(); + ConnectClass* a = this->GetClass(); - ConnectClass a = this->GetClass(); + if ((!a) || (a->GetType() == CC_DENY)) + { + userrec::QuitUser(ServerInstance, this, "Unauthorised connection"); + return; + } - if (a.type == CC_DENY) + if ((!a->GetPass().empty()) && (!this->haspassed)) { - Goners->AddItem(this,"Unauthorised connection"); + userrec::QuitUser(ServerInstance, this, "Invalid password"); return; } - - if ((*(a.pass.c_str())) && (!this->haspassed)) + + if ((!a) || (a->GetType() == CC_DENY)) { - Goners->AddItem(this,"Invalid password"); + userrec::QuitUser(ServerInstance, this,"Unauthorised connection"); return; } - - if (this->LocalCloneCount() > a.maxlocal) + + if ((a->GetMaxLocal()) && (this->LocalCloneCount() > a->GetMaxLocal())) { - Goners->AddItem(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.maxlocal, this->GetIPString()); + userrec::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()); return; } - else if (this->GlobalCloneCount() > a.maxglobal) + else if ((a->GetMaxGlobal()) && (this->GlobalCloneCount() > a->GetMaxGlobal())) { - Goners->AddItem(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.maxglobal, this->GetIPString()); + userrec::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()); return; } +} - ELine* e = ServerInstance->XLines->matches_exception(this); +void userrec::FullConnect() +{ + ServerInstance->stats->statsConnects++; + this->idle_lastmsg = ServerInstance->Time(); + + /* + * You may be thinking "wtf, we checked this in userrec::AddClient!" - and yes, we did, BUT. + * At the time AddClient is called, we don't have a resolved host, by here we probably do - which + * may put the user into a totally seperate class with different restrictions! so we *must* check again. + * Don't remove this! -- w00t + */ + this->CheckClass(); - if (!e) + if (!this->exempt) { GLine* r = ServerInstance->XLines->matches_gline(this); - + if (r) { + this->muted = true; char reason[MAXBUF]; snprintf(reason,MAXBUF,"G-Lined: %s",r->reason); - Goners->AddItem(this, reason); + ServerInstance->GlobalCulls.AddItem(this, reason); return; } - + KLine* n = ServerInstance->XLines->matches_kline(this); - + if (n) { + this->muted = true; char reason[MAXBUF]; snprintf(reason,MAXBUF,"K-Lined: %s",n->reason); - Goners->AddItem(this, reason); + ServerInstance->GlobalCulls.AddItem(this, reason); 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); @@ -1232,29 +1080,20 @@ void userrec::FullConnect(CullList* Goners) 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()); - // anfl @ #ratbox, efnet reminded me that according to the RFC this cant contain more than 13 tokens per line... - // so i'd better split it :) - std::stringstream out(ServerInstance->Config->data005); - std::string token = ""; - std::string line5 = ""; - int token_counter = 0; - - while (!out.eof()) - { - out >> token; - line5 = line5 + token + " "; - token_counter++; - - if ((token_counter >= 13) || (out.eof() == true)) - { - this->WriteServ("005 %s %s:are supported by this server", this->nick, line5.c_str()); - line5 = ""; - token_counter = 0; - } - } - + ServerInstance->Config->Send005(this); + this->ShowMOTD(); + /* Now registered */ + if (ServerInstance->unregistered_count) + ServerInstance->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")); + if (!MOD_RESULT) + ServerInstance->CallCommandHandler("LUSERS", NULL, 0, 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'. @@ -1265,7 +1104,7 @@ void userrec::FullConnect(CullList* Goners) FOREACH_MOD(I_OnPostConnect,OnPostConnect(this)); - ServerInstance->SNO->WriteToSnoMask('c',"Client connecting on port %d: %s!%s@%s [%s]", this->GetPort(), this->nick, this->ident, this->host, this->GetIPString()); + 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); } /** userrec::UpdateNick() @@ -1277,18 +1116,18 @@ userrec* userrec::UpdateNickHash(const char* New) try { //user_hash::iterator newnick; - user_hash::iterator oldnick = ServerInstance->clientlist.find(this->nick); + user_hash::iterator oldnick = ServerInstance->clientlist->find(this->nick); if (!strcasecmp(this->nick,New)) return oldnick->second; - if (oldnick == ServerInstance->clientlist.end()) + if (oldnick == ServerInstance->clientlist->end()) return NULL; /* doesnt exist */ userrec* olduser = oldnick->second; - ServerInstance->clientlist[New] = olduser; - ServerInstance->clientlist.erase(oldnick); - return ServerInstance->clientlist[New]; + (*(ServerInstance->clientlist))[New] = olduser; + ServerInstance->clientlist->erase(oldnick); + return olduser; } catch (...) @@ -1298,12 +1137,28 @@ userrec* userrec::UpdateNickHash(const char* New) } } +void userrec::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; +} + bool userrec::ForceNickChange(const char* newnick) { try { int MOD_RESULT = 0; - + + this->InvalidateCache(); + FOREACH_RESULT(I_OnUserPreNick,OnUserPreNick(this, newnick)); if (MOD_RESULT) @@ -1311,7 +1166,7 @@ bool userrec::ForceNickChange(const char* newnick) ServerInstance->stats->statsCollisions++; return false; } - + if (ServerInstance->XLines->matches_qline(newnick)) { ServerInstance->stats->statsCollisions++; @@ -1342,7 +1197,6 @@ void userrec::SetSockAddr(int protocol_family, const char* ip, int port) #ifdef SUPPORT_IP6LINKS case AF_INET6: { - ServerInstance->Log(DEBUG,"Set inet6 protocol address"); sockaddr_in6* sin = new sockaddr_in6; sin->sin6_family = AF_INET6; sin->sin6_port = port; @@ -1353,7 +1207,6 @@ void userrec::SetSockAddr(int protocol_family, const char* ip, int port) #endif case AF_INET: { - ServerInstance->Log(DEBUG,"Set inet4 protocol address"); sockaddr_in* sin = new sockaddr_in; sin->sin_family = AF_INET; sin->sin_port = port; @@ -1389,7 +1242,6 @@ int userrec::GetPort() } break; default: - ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick); break; } return 0; @@ -1417,7 +1269,7 @@ const char* userrec::GetIPString() 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) */ @@ -1439,7 +1291,6 @@ const char* userrec::GetIPString() } break; default: - ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick); break; } return ""; @@ -1459,7 +1310,7 @@ const char* userrec::GetIPString(char* buf) 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) */ @@ -1482,7 +1333,6 @@ const char* userrec::GetIPString(char* buf) break; default: - ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick); break; } return ""; @@ -1496,11 +1346,20 @@ const char* userrec::GetIPString(char* buf) */ void userrec::Write(std::string text) { +#ifdef WINDOWS + if ((this->fd < 0) || (this->m_internalFd > MAX_DESCRIPTORS)) +#else if ((this->fd < 0) || (this->fd > MAX_DESCRIPTORS)) +#endif return; try { + /* ServerInstance->Log(DEBUG,"C[%d] <- %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). + */ text.append("\r\n"); } catch (...) @@ -1515,9 +1374,9 @@ void userrec::Write(std::string text) { ServerInstance->Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, text.data(), text.length()); } - catch (ModuleException& modexcept) + catch (CoreException& modexcept) { - ServerInstance->Log(DEBUG,"Module exception caught: %s",modexcept.GetReason()); + ServerInstance->Log(DEBUG, "%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason()); } } else @@ -1571,7 +1430,7 @@ void userrec::WriteFrom(userrec *user, const std::string &text) char tb[MAXBUF]; snprintf(tb,MAXBUF,":%s %s",user->GetFullHost(),text.c_str()); - + this->Write(std::string(tb)); } @@ -1631,38 +1490,38 @@ void userrec::WriteCommon(const std::string &text) try { bool sent_to_at_least_one = false; - + char tb[MAXBUF]; + if (this->registered != REG_ALL) return; - + uniq_id++; - - for (std::vector::const_iterator v = this->chans.begin(); v != this->chans.end(); v++) + + /* 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; + + for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) { - ucrec *n = *v; - if (n->channel) + CUList* ulist = v->first->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - CUList *ulist= n->channel->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->second)) && (already_sent[i->second->fd] != uniq_id)) - { - already_sent[i->second->fd] = uniq_id; - i->second->WriteFrom(this, std::string(text)); - 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->WriteFrom(this,std::string(text)); + this->Write(std::string(tb)); } } @@ -1689,76 +1548,60 @@ void userrec::WriteCommonExcept(const char* text, ...) this->WriteCommonExcept(std::string(textbuffer)); } -void userrec::WriteCommonExcept(const std::string &text) +void userrec::WriteCommonQuit(const std::string &normal_text, const std::string &oper_text) { - bool quit_munge = false; - char oper_quit[MAXBUF]; - char textbuffer[MAXBUF]; - - strlcpy(textbuffer, text.c_str(), MAXBUF); + char tb1[MAXBUF]; + char tb2[MAXBUF]; if (this->registered != REG_ALL) 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()); + std::string out1 = tb1; + std::string out2 = tb2; - /* TODO: We need some form of WriteCommonExcept that will send two lines, one line to - * opers and the other line to non-opers, then all this hidebans and hidesplits gunk - * can go byebye. - */ - if (ServerInstance->Config->HideSplits) + for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) { - char* check = textbuffer + 6; - - if (!strncasecmp(textbuffer, "QUIT :",6)) + CUList *ulist = v->first->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - std::stringstream split(check); - std::string server_one; - std::string server_two; - - split >> server_one; - split >> server_two; - - if ((ServerInstance->FindServerName(server_one)) && (ServerInstance->FindServerName(server_two))) + if (this != i->first) { - strlcpy(oper_quit,textbuffer,MAXQUIT); - strlcpy(check,"*.net *.split",MAXQUIT); - quit_munge = true; + if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id)) + { + already_sent[i->first->fd] = uniq_id; + i->first->Write(IS_OPER(i->first) ? out2 : out1); + } } } } +} - if ((ServerInstance->Config->HideBans) && (!quit_munge)) - { - if ((!strncasecmp(textbuffer, "QUIT :G-Lined:",14)) || (!strncasecmp(textbuffer, "QUIT :K-Lined:",14)) - || (!strncasecmp(textbuffer, "QUIT :Q-Lined:",14)) || (!strncasecmp(textbuffer, "QUIT :Z-Lined:",14))) - { - char* check = textbuffer + 13; - strlcpy(oper_quit,textbuffer,MAXQUIT); - *check = 0; // We don't need to strlcpy, we just chop it from the : - quit_munge = true; - } - } +void userrec::WriteCommonExcept(const std::string &text) +{ + char tb1[MAXBUF]; + std::string out1; + + if (this->registered != REG_ALL) + return; + + uniq_id++; + snprintf(tb1,MAXBUF,":%s %s",this->GetFullHost(),text.c_str()); + out1 = tb1; - for (std::vector::const_iterator v = this->chans.begin(); v != this->chans.end(); v++) + for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++) { - ucrec* n = *v; - if (n->channel) + CUList *ulist = v->first->GetUsers(); + for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) { - CUList *ulist= n->channel->GetUsers(); - - for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++) + if (this != i->first) { - if (this != i->second) + if ((IS_LOCAL(i->first)) && (already_sent[i->first->fd] != uniq_id)) { - if ((IS_LOCAL(i->second)) && (already_sent[i->second->fd] != uniq_id)) - { - already_sent[i->second->fd] = uniq_id; - if (quit_munge) - i->second->WriteFrom(this, *i->second->oper ? std::string(oper_quit) : std::string(textbuffer)); - else - i->second->WriteFrom(this, std::string(textbuffer)); - } + already_sent[i->first->fd] = uniq_id; + i->first->Write(out1); } } } @@ -1768,21 +1611,10 @@ void userrec::WriteCommonExcept(const std::string &text) void userrec::WriteWallOps(const std::string &text) { - /* Does nothing if theyre not opered */ - if ((!*this->oper) && (IS_LOCAL(this))) + if (!IS_OPER(this) && IS_LOCAL(this)) return; - std::string wallop = "WALLOPS :"; - - try - { - wallop.append(text); - } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in userrec::Write() std::string::append"); - return; - } + std::string wallop = "WALLOPS :" + text; for (std::vector::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++) { @@ -1793,16 +1625,16 @@ void userrec::WriteWallOps(const std::string &text) } void userrec::WriteWallOps(const char* text, ...) -{ +{ char textbuffer[MAXBUF]; va_list argsPtr; va_start(argsPtr, text); vsnprintf(textbuffer, MAXBUF, text, argsPtr); - va_end(argsPtr); - + va_end(argsPtr); + this->WriteWallOps(std::string(textbuffer)); -} +} /* return 0 or 1 depending if users u and u2 share one or more common channels * (used by QUIT, NICK etc which arent channel specific notices) @@ -1822,33 +1654,17 @@ bool userrec::SharesChannelWith(userrec *other) return false; /* Outer loop */ - for (std::vector::const_iterator i = this->chans.begin(); i != this->chans.end(); i++) + for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - /* Fetch the channel from the user */ - ucrec* user_channel = *i; - - if (user_channel->channel) - { - /* Eliminate the inner loop (which used to be ~equal in size to the outer loop) - * by replacing it with a map::find which *should* be more efficient - */ - if (user_channel->channel->HasUser(other)) - return true; - } + /* Eliminate the inner loop (which used to be ~equal in size to the outer loop) + * by replacing it with a map::find which *should* be more efficient + */ + if (i->first->HasUser(other)) + return true; } return false; } -int userrec::CountChannels() -{ - return ChannelCount; -} - -void userrec::ModChannelCount(int n) -{ - ChannelCount += n; -} - bool userrec::ChangeName(const char* gecos) { if (!strcmp(gecos, this->fullname)) @@ -1863,6 +1679,7 @@ bool userrec::ChangeName(const char* gecos) FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos)); } strlcpy(this->fullname,gecos,MAXGECOS+1); + return true; } @@ -1880,27 +1697,26 @@ bool userrec::ChangeDisplayedHost(const char* host) FOREACH_MOD(I_OnChangeHost,OnChangeHost(this,host)); } if (this->ServerInstance->Config->CycleHosts) - this->WriteCommonExcept("%s","QUIT :Changing hosts"); + this->WriteCommonExcept("QUIT :Changing hosts"); /* Fix by Om: userrec::dhost is 65 long, this was truncating some long hosts */ strlcpy(this->dhost,host,64); + this->InvalidateCache(); + if (this->ServerInstance->Config->CycleHosts) { - for (std::vector::const_iterator i = this->chans.begin(); i != this->chans.end(); i++) + for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - if ((*i)->channel) - { - (*i)->channel->WriteAllExceptSender(this, false, 0, "JOIN %s", (*i)->channel->name); - std::string n = this->ServerInstance->Modes->ModeString(this, (*i)->channel); - if (n.length() > 0) - (*i)->channel->WriteAllExceptSender(this, true, 0, "MODE %s +%s", (*i)->channel->name, n.c_str()); - } + i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name); + 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()); } } if (IS_LOCAL(this)) - this->WriteServ("396 %s %s :is now your hidden host",this->nick,this->dhost); + this->WriteServ("396 %s %s :is now your displayed host",this->nick,this->dhost); return true; } @@ -1915,24 +1731,23 @@ bool userrec::ChangeIdent(const char* newident) strlcpy(this->ident, newident, IDENTMAX+2); + this->InvalidateCache(); + if (this->ServerInstance->Config->CycleHosts) { - for (std::vector::const_iterator i = this->chans.begin(); i != this->chans.end(); i++) + for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - if ((*i)->channel) - { - (*i)->channel->WriteAllExceptSender(this, false, 0, "JOIN %s", (*i)->channel->name); - std::string n = this->ServerInstance->Modes->ModeString(this, (*i)->channel); - if (n.length() > 0) - (*i)->channel->WriteAllExceptSender(this, true, 0, "MODE %s +%s", (*i)->channel->name, n.c_str()); - } + i->first->WriteAllExceptSender(this, false, 0, "JOIN %s", i->first->name); + 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()); } } return true; } -void userrec::NoticeAll(char* text, ...) +void userrec::SendAll(const char* command, char* text, ...) { char textbuffer[MAXBUF]; char formatbuffer[MAXBUF]; @@ -1942,12 +1757,12 @@ void userrec::NoticeAll(char* text, ...) vsnprintf(textbuffer, MAXBUF, text, argsPtr); va_end(argsPtr); - snprintf(formatbuffer,MAXBUF,"NOTICE $* :%s",textbuffer); + snprintf(formatbuffer,MAXBUF,":%s %s $* :%s", this->GetFullHost(), command, textbuffer); + std::string fmt = formatbuffer; for (std::vector::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++) { - userrec* t = *i; - t->WriteFrom(this, std::string(formatbuffer)); + (*i)->Write(fmt); } } @@ -1957,20 +1772,15 @@ std::string userrec::ChannelList(userrec* source) try { std::string list; - for (std::vector::const_iterator i = this->chans.begin(); i != this->chans.end(); i++) + for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++) { - ucrec* rec = *i; - - if(rec->channel && rec->channel->name) + /* 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->modes[CM_PRIVATE]) && (!i->first->modes[CM_SECRET])) || (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) || (*source->oper && ServerInstance->Config->OperSpyWhois) || (((!rec->channel->modes[CM_PRIVATE]) && (!rec->channel->modes[CM_SECRET])) || (rec->channel->HasUser(source)))) - { - list.append(rec->channel->GetPrefixChar(this)).append(rec->channel->name).append(" "); - } + list.append(i->first->GetPrefixChar(this)).append(i->first->name).append(" "); } } return list; @@ -1993,17 +1803,17 @@ void userrec::SplitChanList(userrec* dest, const std::string &cl) 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) { length = (pos == std::string::npos) ? cl.length() : pos; - + if (line.length() + namelen + length - start > 510) { - this->Write(line); + ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); line = prefix.str(); } - + if(pos == std::string::npos) { line.append(cl.substr(start, length - start)); @@ -2014,7 +1824,7 @@ void userrec::SplitChanList(userrec* dest, const std::string &cl) line.append(cl.substr(start, length - start + 1)); } } - + if (line.length()) { ServerInstance->SendWhoisLine(this, dest, 319, "%s", line.c_str()); @@ -2033,15 +1843,24 @@ void userrec::SplitChanList(userrec* dest, const std::string &cl) * then their ip will be taken as 'priority' anyway, so for example, * will match joe!bloggs@localhost */ -ConnectClass& userrec::GetClass() +ConnectClass* userrec::GetClass() { for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++) { - if ((match(this->GetIPString(),i->host.c_str(),true)) || (match(this->host,i->host.c_str()))) - return *i; + if (((match(this->GetIPString(),i->GetHost().c_str(),true)) || (match(this->host,i->GetHost().c_str())))) + { + if (i->GetPort()) + { + if (this->GetPort() == i->GetPort()) + return &(*i); + else + continue; + } + else + return &(*i); + } } - - return *(ServerInstance->Config->Classes.begin()); + return NULL; } void userrec::PurgeEmptyChannels() @@ -2049,24 +1868,19 @@ void userrec::PurgeEmptyChannels() std::vector to_delete; // firstly decrement the count on each channel - for (std::vector::iterator f = this->chans.begin(); f != this->chans.end(); f++) + for (UCListIter f = this->chans.begin(); f != this->chans.end(); f++) { - ucrec* uc = *f; - if (uc->channel) + f->first->RemoveAllPrefixes(this); + if (f->first->DelUser(this) == 0) { - uc->channel->RemoveAllPrefixes(this); - if (uc->channel->DelUser(this) == 0) + /* No users left in here, mark it for deletion */ + try { - /* No users left in here, mark it for deletion */ - try - { - to_delete.push_back(uc->channel); - } - catch (...) - { - ServerInstance->Log(DEBUG,"Exception in userrec::PurgeEmptyChannels to_delete.push_back()"); - } - uc->channel = NULL; + to_delete.push_back(f->first); + } + catch (...) + { + ServerInstance->Log(DEBUG,"Exception in userrec::PurgeEmptyChannels to_delete.push_back()"); } } } @@ -2074,12 +1888,13 @@ void userrec::PurgeEmptyChannels() for (std::vector::iterator n = to_delete.begin(); n != to_delete.end(); n++) { chanrec* thischan = *n; - chan_hash::iterator i2 = ServerInstance->chanlist.find(thischan->name); - if (i2 != ServerInstance->chanlist.end()) + chan_hash::iterator i2 = ServerInstance->chanlist->find(thischan->name); + if (i2 != ServerInstance->chanlist->end()) { FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second)); DELETE(i2->second); - ServerInstance->chanlist.erase(i2); + ServerInstance->chanlist->erase(i2); + this->chans.erase(*n); } } @@ -2095,8 +1910,8 @@ void userrec::ShowMOTD() } this->WriteServ("375 %s :%s message of the day", this->nick, ServerInstance->Config->ServerName); - for (unsigned int i = 0; i < ServerInstance->Config->MOTD.size(); i++) - this->WriteServ("372 %s :- %s",this->nick,ServerInstance->Config->MOTD[i].c_str()); + 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->WriteServ("376 %s :End of message of the day.", this->nick); } @@ -2110,8 +1925,8 @@ void userrec::ShowRULES() } this->WriteServ("NOTICE %s :%s rules",this->nick,ServerInstance->Config->ServerName); - for (unsigned int i = 0; i < ServerInstance->Config->RULES.size(); i++) - this->WriteServ("NOTICE %s :%s",this->nick,ServerInstance->Config->RULES[i].c_str()); + for (file_cache::iterator i = ServerInstance->Config->RULES.begin(); i != ServerInstance->Config->RULES.end(); i++) + this->WriteServ("NOTICE %s :%s",this->nick,i->c_str()); this->WriteServ("NOTICE %s :End of %s rules.",this->nick,ServerInstance->Config->ServerName); } @@ -2119,6 +1934,8 @@ void userrec::ShowRULES() void userrec::HandleEvent(EventType et, int errornum) { /* WARNING: May delete this user! */ + int thisfd = this->GetFd(); + try { switch (et) @@ -2130,6 +1947,7 @@ void userrec::HandleEvent(EventType et, int errornum) 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; } @@ -2138,4 +1956,40 @@ void userrec::HandleEvent(EventType et, int errornum) { ServerInstance->Log(DEBUG,"Exception in userrec::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)) + { + if (!WriteError.empty()) + { + userrec::QuitUser(ServerInstance, this, GetWriteError()); + } + } } + +void userrec::SetOperQuit(const std::string &oquit) +{ + if (operquit) + return; + + operquit = strdup(oquit.c_str()); +} + +const char* userrec::GetOperQuit() +{ + return operquit ? operquit : ""; +} + +VisData::VisData() +{ +} + +VisData::~VisData() +{ +} + +bool VisData::VisibleTo(userrec* user) +{ + return true; +} +