#include "xline.h"
#include "cull_list.h"
-extern InspIRCd* ServerInstance;
-extern int WHOWAS_STALE;
-extern int WHOWAS_MAX;
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
-extern std::vector<InspSocket*> module_sockets;
extern int MODCOUNT;
-extern InspSocket* socket_ref[MAX_DESCRIPTORS];
extern time_t TIME;
-extern userrec* fd_ref_table[MAX_DESCRIPTORS];
-extern ServerConfig *Config;
-extern user_hash clientlist;
extern Server* MyServer;
-extern std::vector<userrec*> local_users;
irc::whowas::whowas_users whowas;
static unsigned long already_sent[MAX_DESCRIPTORS] = {0};
/* XXX: Used for speeding up WriteCommon operations */
unsigned long uniq_id = 0;
-bool InitTypes(const char* tag)
+bool InitTypes(ServerConfig* conf, const char* tag)
{
for (opertype_t::iterator n = opertypes.begin(); n != opertypes.end(); n++)
{
return true;
}
-bool InitClasses(const char* tag)
+bool InitClasses(ServerConfig* conf, const char* tag)
{
for (operclass_t::iterator n = operclass.begin(); n != operclass.end(); n++)
{
return true;
}
-bool DoType(const char* tag, char** entries, void** values, int* types)
+bool DoType(ServerConfig* conf, const char* tag, char** entries, void** values, int* types)
{
char* TypeName = (char*)values[0];
char* Classes = (char*)values[1];
return true;
}
-bool DoClass(const char* tag, char** entries, void** values, int* types)
+bool DoClass(ServerConfig* conf, const char* tag, char** entries, void** values, int* types)
{
char* ClassName = (char*)values[0];
char* CommandList = (char*)values[1];
return true;
}
-bool DoneClassesAndTypes(const char* tag)
+bool DoneClassesAndTypes(ServerConfig* conf, const char* tag)
{
return true;
}
log(DEBUG,"Commencing reverse lookup");
try
{
- res_reverse = new UserResolver(this, this->GetIPString(), false);
+ log(DEBUG,"Passing instance: %08x",this->ServerInstance);
+ res_reverse = new UserResolver(this->ServerInstance, this, this->GetIPString(), false);
MyServer->AddResolver(res_reverse);
}
catch (ModuleException& e)
}
}
-UserResolver::UserResolver(userrec* user, std::string to_resolve, bool forward) : Resolver(to_resolve, forward ? DNS_QUERY_FORWARD : DNS_QUERY_REVERSE), bound_user(user)
+UserResolver::UserResolver(InspIRCd* Instance, userrec* user, std::string to_resolve, bool forward) :
+ Resolver(Instance, to_resolve, forward ? DNS_QUERY_FORWARD : DNS_QUERY_REVERSE), bound_user(user)
{
this->fwd = forward;
this->bound_fd = user->fd;
void UserResolver::OnLookupComplete(const std::string &result)
{
- if ((!this->fwd) && (fd_ref_table[this->bound_fd] == this->bound_user))
+ if ((!this->fwd) && (ServerInstance->fd_ref_table[this->bound_fd] == this->bound_user))
{
log(DEBUG,"Commencing forward lookup");
this->bound_user->stored_host = result;
try
{
- bound_user->res_forward = new UserResolver(this->bound_user, result, true);
+ bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, true);
MyServer->AddResolver(bound_user->res_forward);
}
catch (ModuleException& e)
log(DEBUG,"Error in resolver: %s",e.GetReason());
}
}
- else if ((this->fwd) && (fd_ref_table[this->bound_fd] == this->bound_user))
+ else if ((this->fwd) && (ServerInstance->fd_ref_table[this->bound_fd] == this->bound_user))
{
/* Both lookups completed */
if (this->bound_user->GetIPString() == result)
void UserResolver::OnError(ResolverError e, const std::string &errormessage)
{
- if (fd_ref_table[this->bound_fd] == this->bound_user)
+ if (ServerInstance->fd_ref_table[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());
return data;
}
-userrec::userrec()
+userrec::userrec(InspIRCd* Instance) : ServerInstance(Instance)
{
+ 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*)FindServerNamePtr(Config->ServerName);
+ server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName);
reset_due = TIME;
lines_in = fd = lastping = signon = idle_lastmsg = nping = registered = 0;
timeout = flood = bytes_in = bytes_out = cmds_in = cmds_out = 0;
if (recvq.length() > (unsigned)this->recvqmax)
{
this->SetWriteError("RecvQ exceeded");
- WriteOpers("*** User %s RecvQ of %d exceeds connect class maximum of %d",this->nick,recvq.length(),this->recvqmax);
+ ServerInstance->WriteOpers("*** User %s RecvQ of %d exceeds connect class maximum of %d",this->nick,recvq.length(),this->recvqmax);
return false;
}
* to repeatedly add the text to the sendq!
*/
this->SetWriteError("SendQ exceeded");
- WriteOpers("*** User %s SendQ of %d exceeds connect class maximum of %d",this->nick,sendq.length() + data.length(),this->sendqmax);
+ ServerInstance->WriteOpers("*** User %s SendQ of %d exceeds connect class maximum of %d",this->nick,sendq.length() + data.length(),this->sendqmax);
return;
}
}
}
-void userrec::QuitUser(userrec *user,const std::string &quitreason)
+void userrec::QuitUser(InspIRCd* Instance, userrec *user,const std::string &quitreason)
{
- user_hash::iterator iter = clientlist.find(user->nick);
+ user_hash::iterator iter = Instance->clientlist.find(user->nick);
/*
* I'm pretty sure returning here is causing a desync when part of the net thinks a user is gone,
if (user->registered == REG_ALL)
{
- purge_empty_chans(user);
- FOREACH_MOD(I_OnUserQuit,OnUserQuit(user,reason));
+ 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_OnUserDisconnect,OnUserDisconnect(user));
+ FOREACH_MOD_I(Instance,I_OnUserDisconnect,OnUserDisconnect(user));
if (IS_LOCAL(user))
{
- if (Config->GetIOHook(user->GetPort()))
+ if (Instance->Config->GetIOHook(user->GetPort()))
{
try
{
- Config->GetIOHook(user->GetPort())->OnRawSocketClose(user->fd);
+ Instance->Config->GetIOHook(user->GetPort())->OnRawSocketClose(user->fd);
}
catch (ModuleException& modexcept)
{
}
}
- ServerInstance->SE->DelFd(user->fd);
+ Instance->SE->DelFd(user->fd);
user->CloseSocket();
}
/*
- * this must come before the WriteOpers so that it doesnt try to fill their buffer with anything
+ * this must come before the ServerInstance->WriteOpers so that it doesnt try to fill their buffer with anything
* if they were an oper with +s.
*
* XXX -
if (user->registered == REG_ALL)
{
if (IS_LOCAL(user))
- WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason.c_str());
+ Instance->WriteOpers("*** Client exiting: %s!%s@%s [%s]",user->nick,user->ident,user->host,reason.c_str());
user->AddToWhoWas();
}
- if (iter != clientlist.end())
+ if (iter != Instance->clientlist.end())
{
log(DEBUG,"deleting user hash value %lx",(unsigned long)user);
if (IS_LOCAL(user))
{
- fd_ref_table[user->fd] = NULL;
- if (find(local_users.begin(),local_users.end(),user) != local_users.end())
- local_users.erase(find(local_users.begin(),local_users.end(),user));
+ Instance->fd_ref_table[user->fd] = NULL;
+ 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));
}
- clientlist.erase(iter);
+ Instance->clientlist.erase(iter);
DELETE(user);
}
}
}
/* add a client connection to the sockets list */
-void userrec::AddClient(int socket, int port, bool iscached, insp_inaddr ip)
+void userrec::AddClient(InspIRCd* Instance, int socket, int port, bool iscached, insp_inaddr ip)
{
std::string tempnick = ConvToStr(socket) + "-unknown";
- user_hash::iterator iter = clientlist.find(tempnick);
+ user_hash::iterator iter = Instance->clientlist.find(tempnick);
const char *ipaddr = insp_ntoa(ip);
userrec* _new;
int j = 0;
* this was probably the cause of 'server ignores me when i hammer it with reconnects'
* issue in earlier alphas/betas
*/
- if (iter != clientlist.end())
+ if (iter != Instance->clientlist.end())
{
userrec* goner = iter->second;
DELETE(goner);
- clientlist.erase(iter);
+ Instance->clientlist.erase(iter);
}
log(DEBUG,"AddClient: %d %d %s",socket,port,ipaddr);
- _new = new userrec();
- clientlist[tempnick] = _new;
+ _new = new userrec(Instance);
+ Instance->clientlist[tempnick] = _new;
_new->fd = socket;
strlcpy(_new->nick,tempnick.c_str(),NICKMAX-1);
- _new->server = FindServerNamePtr(Config->ServerName);
+ _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 = TIME + Config->dns_timeout;
+ _new->signon = TIME + Instance->Config->dns_timeout;
_new->lastping = 1;
log(DEBUG,"Setting socket addresses");
long class_sqmax = 262144; // 256kb
long class_rqmax = 4096; // 4k
- for (ClassVector::iterator i = Config->Classes.begin(); i != Config->Classes.end(); i++)
+ 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)))
{
}
}
- _new->nping = TIME + _new->pingmax + Config->dns_timeout;
+ _new->nping = TIME + _new->pingmax + Instance->Config->dns_timeout;
_new->timeout = TIME+class_regtimeout;
_new->flood = class_flood;
_new->threshold = class_threshold;
_new->sendqmax = class_sqmax;
_new->recvqmax = class_rqmax;
- fd_ref_table[socket] = _new;
- local_users.push_back(_new);
+ Instance->fd_ref_table[socket] = _new;
+ Instance->local_users.push_back(_new);
- if (local_users.size() > Config->SoftLimit)
+ if (Instance->local_users.size() > Instance->Config->SoftLimit)
{
- userrec::QuitUser(_new,"No more connections allowed");
+ userrec::QuitUser(Instance, _new,"No more connections allowed");
return;
}
- if (local_users.size() >= MAXCLIENTS)
+ if (Instance->local_users.size() >= MAXCLIENTS)
{
- userrec::QuitUser(_new,"No more connections allowed");
+ userrec::QuitUser(Instance, _new,"No more connections allowed");
return;
}
*/
if ((unsigned)socket >= MAX_DESCRIPTORS)
{
- userrec::QuitUser(_new,"Server is full");
+ userrec::QuitUser(Instance, _new,"Server is full");
return;
}
char* e = matches_exception(ipaddr);
{
char reason[MAXBUF];
snprintf(reason,MAXBUF,"Z-Lined: %s",r);
- userrec::QuitUser(_new,reason);
+ userrec::QuitUser(Instance, _new,reason);
return;
}
}
if (socket > -1)
{
- if (!ServerInstance->SE->AddFd(socket,true,X_ESTAB_CLIENT))
+ if (!Instance->SE->AddFd(socket,true,X_ESTAB_CLIENT))
{
- userrec::QuitUser(_new, "Internal error handling connection");
+ userrec::QuitUser(Instance, _new, "Internal error handling connection");
return;
}
}
char u1[1024];
char u2[1024];
long x = 0;
- for (user_hash::const_iterator a = clientlist.begin(); a != clientlist.end(); a++)
+ 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
long userrec::LocalCloneCount()
{
long x = 0;
- for (std::vector<userrec*>::const_iterator a = local_users.begin(); a != local_users.end(); a++)
+ for (std::vector<userrec*>::const_iterator a = ServerInstance->local_users.begin(); a != ServerInstance->local_users.end(); a++)
{
userrec* comp = *a;
#ifdef IPV6
ServerInstance->stats->statsConnects++;
this->idle_lastmsg = TIME;
- ConnectClass a = GetClass(this);
+ ConnectClass a = this->GetClass();
if (a.type == CC_DENY)
{
if (this->LocalCloneCount() > a.maxlocal)
{
Goners->AddItem(this, "No more connections allowed from your host via this connect class (local)");
- WriteOpers("*** WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a.maxlocal, this->GetIPString());
+ ServerInstance->WriteOpers("*** WARNING: maximum LOCAL connections (%ld) exceeded for IP %s", a.maxlocal, this->GetIPString());
return;
}
else if (this->GlobalCloneCount() > a.maxglobal)
{
Goners->AddItem(this, "No more connections allowed from your host via this connect class (global)");
- WriteOpers("*** WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s",a.maxglobal, this->GetIPString());
+ ServerInstance->WriteOpers("*** WARNING: maximum GLOBAL connections (%ld) exceeded for IP %s",a.maxglobal, this->GetIPString());
return;
}
}
- this->WriteServ("NOTICE Auth :Welcome to \002%s\002!",Config->Network);
- this->WriteServ("001 %s :Welcome to the %s IRC Network %s!%s@%s",this->nick, Config->Network, this->nick, this->ident, this->host);
- this->WriteServ("002 %s :Your host is %s, running version %s",this->nick,Config->ServerName,VERSION);
+ 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, Config->ServerName, VERSION, ServerInstance->ModeGrok->UserModeList().c_str(), ServerInstance->ModeGrok->ChannelModeList().c_str(), ServerInstance->ModeGrok->ParaModeList().c_str());
+ this->WriteServ("004 %s %s %s %s %s %s", this->nick, ServerInstance->Config->ServerName, VERSION, ServerInstance->ModeGrok->UserModeList().c_str(), ServerInstance->ModeGrok->ChannelModeList().c_str(), ServerInstance->ModeGrok->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(Config->data005);
+ std::stringstream out(ServerInstance->Config->data005);
std::string token = "";
std::string line5 = "";
int token_counter = 0;
FOREACH_MOD(I_OnUserConnect,OnUserConnect(this));
FOREACH_MOD(I_OnGlobalConnect,OnGlobalConnect(this));
this->registered = REG_ALL;
- WriteOpers("*** Client connecting on port %d: %s!%s@%s [%s]", this->GetPort(), this->nick, this->ident, this->host, this->GetIPString());
+ ServerInstance->WriteOpers("*** Client connecting on port %d: %s!%s@%s [%s]", this->GetPort(), this->nick, this->ident, this->host, this->GetIPString());
}
/** userrec::UpdateNick()
userrec* userrec::UpdateNickHash(const char* New)
{
//user_hash::iterator newnick;
- user_hash::iterator oldnick = clientlist.find(this->nick);
+ user_hash::iterator oldnick = ServerInstance->clientlist.find(this->nick);
if (!strcasecmp(this->nick,New))
return oldnick->second;
- if (oldnick == clientlist.end())
+ if (oldnick == ServerInstance->clientlist.end())
return NULL; /* doesnt exist */
userrec* olduser = oldnick->second;
- clientlist[New] = olduser;
- clientlist.erase(oldnick);
- return clientlist[New];
+ ServerInstance->clientlist[New] = olduser;
+ ServerInstance->clientlist.erase(oldnick);
+ return ServerInstance->clientlist[New];
}
bool userrec::ForceNickChange(const char* newnick)
std::string crlf = text;
crlf.append("\r\n");
- if (Config->GetIOHook(this->GetPort()))
+ if (ServerInstance->Config->GetIOHook(this->GetPort()))
{
try
{
- Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, crlf.data(), crlf.length());
+ ServerInstance->Config->GetIOHook(this->GetPort())->OnRawSocketWrite(this->fd, crlf.data(), crlf.length());
}
catch (ModuleException& modexcept)
{
{
char textbuffer[MAXBUF];
- snprintf(textbuffer,MAXBUF,":%s %s",Config->ServerName,text.c_str());
+ snprintf(textbuffer,MAXBUF,":%s %s",ServerInstance->Config->ServerName,text.c_str());
this->Write(std::string(textbuffer));
}
* opers and the other line to non-opers, then all this hidebans and hidesplits gunk
* can go byebye.
*/
- if (Config->HideSplits)
+ if (ServerInstance->Config->HideSplits)
{
char* check = textbuffer + 6;
split >> server_one;
split >> server_two;
- if ((FindServerName(server_one)) && (FindServerName(server_two)))
+ if ((ServerInstance->FindServerName(server_one)) && (ServerInstance->FindServerName(server_two)))
{
strlcpy(oper_quit,textbuffer,MAXQUIT);
strlcpy(check,"*.net *.split",MAXQUIT);
}
}
- if ((Config->HideBans) && (!quit_munge))
+ 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)))
std::string wallop = "WALLOPS :";
wallop.append(text);
- for (std::vector<userrec*>::const_iterator i = local_users.begin(); i != local_users.end(); i++)
+ for (std::vector<userrec*>::const_iterator i = ServerInstance->local_users.begin(); i != ServerInstance->local_users.end(); i++)
{
userrec* t = *i;
if ((IS_LOCAL(t)) && (t->modes[UM_WALLOPS]))
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)
+ *
+ * The old algorithm in 1.0 for this was relatively inefficient, iterating over
+ * the first users channels then the second users channels within the outer loop,
+ * therefore it was a maximum of x*y iterations (upon returning 0 and checking
+ * all possible iterations). However this new function instead checks against the
+ * channel's userlist in the inner loop which is a std::map<userrec*,userrec*>
+ * and saves us time as we already know what pointer value we are after.
+ * Don't quote me on the maths as i am not a mathematician or computer scientist,
+ * but i believe this algorithm is now x+(log y) maximum iterations instead.
+ */
+bool userrec::SharesChannelWith(userrec *other)
+{
+ if ((!other) || (this->registered != REG_ALL) || (other->registered != REG_ALL))
+ return false;
+
+ /* Outer loop */
+ for (std::vector<ucrec*>::const_iterator 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;
+ }
+ }
+ return false;
+}
+
+int userrec::CountChannels()
+{
+ int z = 0;
+ for (std::vector<ucrec*>::const_iterator i = this->chans.begin(); i != this->chans.end(); i++)
+ if ((*i)->channel)
+ z++;
+ return z;
+}
+
+bool userrec::ChangeName(const char* gecos)
+{
+ if (IS_LOCAL(this))
+ {
+ int MOD_RESULT = 0;
+ FOREACH_RESULT(I_OnChangeLocalUserGECOS,OnChangeLocalUserGECOS(this,gecos));
+ if (MOD_RESULT)
+ return false;
+ FOREACH_MOD(I_OnChangeName,OnChangeName(this,gecos));
+ }
+ strlcpy(this->fullname,gecos,MAXGECOS+1);
+ return true;
+}
+
+bool userrec::ChangeDisplayedHost(const char* host)
+{
+ if (IS_LOCAL(this))
+ {
+ int MOD_RESULT = 0;
+ FOREACH_RESULT(I_OnChangeLocalUserHost,OnChangeLocalUserHost(this,host));
+ if (MOD_RESULT)
+ return false;
+ FOREACH_MOD(I_OnChangeHost,OnChangeHost(this,host));
+ }
+ strlcpy(this->dhost,host,63);
+
+ if (IS_LOCAL(this))
+ this->WriteServ("396 %s %s :is now your hidden host",this->nick,this->dhost);
+
+ return true;
+}
+
+void userrec::NoticeAll(char* text, ...)
+{
+ char textbuffer[MAXBUF];
+ char formatbuffer[MAXBUF];
+ va_list argsPtr;
+
+ va_start(argsPtr, text);
+ vsnprintf(textbuffer, MAXBUF, text, argsPtr);
+ va_end(argsPtr);
+
+ snprintf(formatbuffer,MAXBUF,"NOTICE $* :%s",textbuffer);
+
+ 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));
+ }
+}
+
+
+std::string userrec::ChannelList(userrec* source)
+{
+ std::string list;
+ for (std::vector<ucrec*>::const_iterator 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 <options:operspywhois> 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->GetStatusChar(this)).append(rec->channel->name).append(" ");
+ }
+ }
+ }
+ return list;
+}
+
+void userrec::SplitChanList(userrec* dest, const std::string &cl)
+{
+ std::string line;
+ std::ostringstream prefix;
+ std::string::size_type start, pos, length;
+
+ prefix << ":" << ServerInstance->Config->ServerName << " 319 " << this->nick << " " << dest->nick << " :";
+ line = prefix.str();
+
+ for (start = 0; (pos = cl.find(' ', start)) != std::string::npos; start = pos+1)
+ {
+ length = (pos == std::string::npos) ? cl.length() : pos;
+
+ if (line.length() + length - start > 510)
+ {
+ this->Write(line);
+ line = prefix.str();
+ }
+
+ if(pos == std::string::npos)
+ {
+ line += cl.substr(start, length - start);
+ break;
+ }
+ else
+ {
+ line += cl.substr(start, length - start + 1);
+ }
+ }
+
+ if (line.length())
+ {
+ this->Write(line);
+ }
+}
+
+
+/* looks up a users password for their connection class (<ALLOW>/<DENY> tags)
+ * NOTE: If the <ALLOW> or <DENY> tag specifies an ip, and this user resolves,
+ * then their ip will be taken as 'priority' anyway, so for example,
+ * <connect allow="127.0.0.1"> will match joe!bloggs@localhost
+ */
+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;
+ }
+
+ return *(ServerInstance->Config->Classes.begin());
+}
+
+void userrec::PurgeEmptyChannels()
+{
+ std::vector<chanrec*> to_delete;
+
+ // firstly decrement the count on each channel
+ for (std::vector<ucrec*>::iterator f = this->chans.begin(); f != this->chans.end(); f++)
+ {
+ ucrec* uc = *f;
+ if (uc->channel)
+ {
+ if (uc->channel->DelUser(this) == 0)
+ {
+ /* No users left in here, mark it for deletion */
+ to_delete.push_back(uc->channel);
+ uc->channel = NULL;
+ }
+ }
+ }
+
+ for (std::vector<chanrec*>::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())
+ {
+ FOREACH_MOD(I_OnChannelDelete,OnChannelDelete(i2->second));
+ DELETE(i2->second);
+ ServerInstance->chanlist.erase(i2);
+ }
+ }
+
+ this->UnOper();
+}
+
projects / user / henk / code / inspircd.git / blobdiff