#include "wildcard.h"
#include "xline.h"
#include "cull_list.h"
+#include "commands/cmd_whowas.h"
static unsigned long already_sent[MAX_DESCRIPTORS] = {0};
{
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;
}
const char* Classes = values[1].GetString();
conf->opertypes[TypeName] = strdup(Classes);
- conf->GetInstance()->Log(DEBUG,"Read oper TYPE '%s' with classes '%s'",TypeName,Classes);
return true;
}
const char* CommandList = values[1].GetString();
conf->operclass[ClassName] = strdup(CommandList);
- conf->GetInstance()->Log(DEBUG,"Read oper CLASS '%s' with commands '%s'",ClassName,CommandList);
return true;
}
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 '+':
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;
+ res_reverse = new UserResolver(this->ServerInstance, this, this->GetIPString(), DNS_QUERY_REVERSE, cached);
+ this->ServerInstance->AddResolver(res_reverse, cached);
}
catch (CoreException& e)
{
}
}
-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));
+ bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, (strstr(ip,"0::ffff:") == ip ? DNS_QUERY_A : DNS_QUERY_AAAA), cached);
#else
- bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, DNS_QUERY_A);
+ 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 (CoreException& e)
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
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->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;
}
}
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);
invites.clear();
memset(modes,0,sizeof(modes));
memset(snomasks,0,sizeof(snomasks));
+ /* Invalidate cache */
+ cached_fullhost = cached_hostip = cached_makehost = cached_fullrealhost = NULL;
}
userrec::~userrec()
{
+ this->InvalidateCache();
+ this->DecrementModes();
if (ip)
{
clonemap::iterator x = ServerInstance->local_clones.find(this->GetIPString());
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++)
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++)
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()
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;
for(char* n = dhost; *n; n++)
*t++ = *n;
*t = 0;
- return result;
+
+ this->cached_fullhost = strdup(result);
+
+ return this->cached_fullhost;
}
char* userrec::MakeWildHost()
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;
for(char* n = host; *n; n++)
*t++ = *n;
*t = 0;
- return fresult;
+
+ this->cached_fullrealhost = strdup(fresult);
+
+ return this->cached_fullrealhost;
}
bool userrec::IsInvited(const irc::string &channel)
void userrec::RemoveInvite(const irc::string &channel)
{
- ServerInstance->Log(DEBUG,"Removing invites");
for (InvitedList::iterator i = invites.begin(); i != invites.end(); i++)
{
if (channel == *i)
/* The socket buffer is full. This isnt fatal,
* try again later.
*/
- ServerInstance->Log(DEBUG,"EAGAIN, want write");
this->ServerInstance->SE->WantWrite(this);
}
else
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);
- }
}
}
}
{
// don't try to set the error twice, its already set take the first string.
if (this->WriteError.empty())
- {
- ServerInstance->Log(DEBUG,"Setting error string for %s to '%s'",this->nick,error.c_str());
this->WriteError = error;
- }
}
catch (...)
{
if (*a == this)
{
- ServerInstance->Log(DEBUG,"Oper removed from optimization list");
ServerInstance->all_opers.erase(a);
return;
}
if (iter != Instance->clientlist->end())
{
- Instance->Log(DEBUG,"deleting user hash value %lx",(unsigned long)user);
if (IS_LOCAL(user))
{
std::vector<userrec*>::iterator x = find(Instance->local_users.begin(),Instance->local_users.end(),user);
}
}
-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)
- {
- 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.push_back(std::make_pair(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.pop_front();
- }
- }
- else
+ command_t* whowas_command = ServerInstance->Parser->GetHandler("WHOWAS");
+ if (whowas_command)
{
- 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<classbase*> params;
+ params.push_back(this);
+ whowas_command->HandleInternal(WHOWAS_ADD, params);
}
}
Instance->clientlist->erase(iter);
}
- Instance->Log(DEBUG,"AddClient: %d %d %s",socket,port,ipaddr);
-
New = new userrec(Instance);
(*(Instance->clientlist))[tempnick] = New;
New->fd = socket;
Goners->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);
}
}
+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));
#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;
#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;
try
{
+ /* ServerInstance->Log(DEBUG,"<- %s", 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 (...)
/* 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++)
{
if ((IS_LOCAL(i->second)) && (already_sent[i->second->fd] != uniq_id))
{
already_sent[i->second->fd] = uniq_id;
- i->second->Write(std::string(tb));
+ i->second->Write(out);
sent_to_at_least_one = true;
}
}
*/
if (!sent_to_at_least_one)
{
- this->WriteFrom(this,std::string(tb));
+ this->Write(std::string(tb));
}
}
char textbuffer[MAXBUF];
char tb1[MAXBUF];
char tb2[MAXBUF];
+ std::string out1;
+ std::string out2;
strlcpy(textbuffer, text.c_str(), MAXBUF);
strlcpy(check,"*.net *.split",MAXQUIT);
quit_munge = true;
snprintf(tb2,MAXBUF,":%s %s",this->GetFullHost(),oper_quit);
+ out2 = tb2;
}
}
}
*check = 0; // We don't need to strlcpy, we just chop it from the :
quit_munge = true;
snprintf(tb2,MAXBUF,":%s %s",this->GetFullHost(),oper_quit);
+ out2 = tb2;
}
}
+ out1 = tb1;
+
for (UCListIter v = this->chans.begin(); v != this->chans.end(); v++)
{
CUList *ulist = v->first->GetUsers();
{
already_sent[i->second->fd] = uniq_id;
if (quit_munge)
- i->second->Write(*i->second->oper ? std::string(tb2) : std::string(tb1));
+ i->second->Write(*i->second->oper ? out2 : out1);
else
- i->second->Write(std::string(tb1));
+ i->second->Write(out1);
}
}
}
FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos));
}
strlcpy(this->fullname,gecos,MAXGECOS+1);
+
return true;
}
/* 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 (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
strlcpy(this->ident, newident, IDENTMAX+2);
+ this->InvalidateCache();
+
if (this->ServerInstance->Config->CycleHosts)
{
for (UCListIter i = this->chans.begin(); i != this->chans.end(); i++)
vsnprintf(textbuffer, MAXBUF, text, argsPtr);
va_end(argsPtr);
- snprintf(formatbuffer,MAXBUF,"NOTICE $* :%s",textbuffer);
+ snprintf(formatbuffer,MAXBUF,":%s NOTICE $* :%s", this->GetFullHost(), textbuffer);
+ std::string fmt = formatbuffer;
for (std::vector<userrec*>::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);
}
}
projects / user / henk / code / inspircd.git / blobdiff