#include <stdarg.h>
#include "inspstring.h"
#include "commands.h"
-#include "helperfuncs.h"
+
#include "typedefs.h"
#include "socketengine.h"
#include "hashcomp.h"
-#include "message.h"
#include "wildcard.h"
#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};
-std::vector<userrec*> all_opers;
typedef std::map<irc::string,char*> opertype_t;
typedef opertype_t operclass_t;
/* 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];
opertypes[TypeName] = strdup(Classes);
- log(DEBUG,"Read oper TYPE '%s' with classes '%s'",TypeName,Classes);
+ conf->GetInstance()->Log(DEBUG,"Read oper TYPE '%s' with classes '%s'",TypeName,Classes);
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];
operclass[ClassName] = strdup(CommandList);
- log(DEBUG,"Read oper CLASS '%s' with commands '%s'",ClassName,CommandList);
+ conf->GetInstance()->Log(DEBUG,"Read oper CLASS '%s' with commands '%s'",ClassName,CommandList);
return true;
}
-bool DoneClassesAndTypes(const char* tag)
+bool DoneClassesAndTypes(ServerConfig* conf, const char* tag)
{
return true;
}
void userrec::StartDNSLookup()
{
- log(DEBUG,"Commencing reverse lookup");
+ ServerInstance->Log(DEBUG,"Commencing reverse lookup");
try
{
- res_reverse = new UserResolver(this, this->GetIPString(), false);
- MyServer->AddResolver(res_reverse);
+ ServerInstance->Log(DEBUG,"Passing instance: %08x",this->ServerInstance);
+ res_reverse = new UserResolver(this->ServerInstance, this, this->GetIPString(), false);
+ this->ServerInstance->AddResolver(res_reverse);
}
catch (ModuleException& e)
{
- log(DEBUG,"Error in resolver: %s",e.GetReason());
+ ServerInstance->Log(DEBUG,"Error in resolver: %s",e.GetReason());
}
}
-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");
+ ServerInstance->Log(DEBUG,"Commencing forward lookup");
this->bound_user->stored_host = result;
try
{
- bound_user->res_forward = new UserResolver(this->bound_user, result, true);
- MyServer->AddResolver(bound_user->res_forward);
+ bound_user->res_forward = new UserResolver(this->ServerInstance, this->bound_user, result, true);
+ this->ServerInstance->AddResolver(bound_user->res_forward);
}
catch (ModuleException& e)
{
- log(DEBUG,"Error in resolver: %s",e.GetReason());
+ ServerInstance->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)
{
+ 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*)FindServerNamePtr(Config->ServerName);
- reset_due = TIME;
+ server = (char*)Instance->FindServerNamePtr(Instance->Config->ServerName);
+ reset_due = ServerInstance->Time();
lines_in = fd = lastping = signon = idle_lastmsg = nping = registered = 0;
timeout = flood = bytes_in = bytes_out = cmds_in = cmds_out = 0;
haspassed = dns_done = false;
void userrec::RemoveInvite(irc::string &channel)
{
- log(DEBUG,"Removing invites");
+ ServerInstance->Log(DEBUG,"Removing invites");
if (invites.size())
{
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::SetWriteError(const std::string &error)
{
- log(DEBUG,"SetWriteError: %s",error.c_str());
+ 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())
{
- log(DEBUG,"Setting error string for %s to '%s'",this->nick,error.c_str());
+ ServerInstance->Log(DEBUG,"Setting error string for %s to '%s'",this->nick,error.c_str());
this->WriteError = error;
}
}
this->modes[UM_OPERATOR] = 1;
this->WriteServ("MODE %s :+o", this->nick);
FOREACH_MOD(I_OnOper, OnOper(this, opertype));
- log(DEFAULT,"OPER: %s!%s@%s opered as type: %s", this->nick, this->ident, this->host, opertype.c_str());
+ ServerInstance->Log(DEFAULT,"OPER: %s!%s@%s opered as type: %s", this->nick, this->ident, this->host, opertype.c_str());
strlcpy(this->oper, opertype.c_str(), NICKMAX - 1);
- all_opers.push_back(this);
+ ServerInstance->all_opers.push_back(this);
FOREACH_MOD(I_OnPostOper,OnPostOper(this, opertype));
}
{
*this->oper = 0;
this->modes[UM_OPERATOR] = 0;
- for (std::vector<userrec*>::iterator a = all_opers.begin(); a < all_opers.end(); a++)
+ for (std::vector<userrec*>::iterator a = ServerInstance->all_opers.begin(); a < ServerInstance->all_opers.end(); a++)
{
if (*a == this)
{
- log(DEBUG,"Oper removed from optimization list");
- all_opers.erase(a);
+ ServerInstance->Log(DEBUG,"Oper removed from optimization list");
+ ServerInstance->all_opers.erase(a);
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)
{
- log(DEBUG,"Module exception cought: %s",modexcept.GetReason());
+ Instance->Log(DEBUG,"Module exception cought: %s",modexcept.GetReason());
}
}
- 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);
+ Instance->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);
}
}
}
/* every hour, run this function which removes all entries over 3 days */
- void MaintainWhoWas(time_t TIME)
+ void MaintainWhoWas(time_t t)
{
for (whowas_users::iterator iter = ::whowas.begin(); iter != ::whowas.end(); iter++)
{
whowas_set* n = (whowas_set*)iter->second;
if (n->size())
{
- while ((n->begin() != n->end()) && ((*n->begin())->signon < TIME - 259200)) // 3 days
+ while ((n->begin() != n->end()) && ((*n->begin())->signon < t - 259200)) // 3 days
{
WhoWasGroup *a = *(n->begin());
DELETE(a);
}
/* 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);
+ Instance->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 = Instance->Time() + Instance->Config->dns_timeout;
_new->lastping = 1;
- log(DEBUG,"Setting socket addresses");
+ Instance->Log(DEBUG,"Setting socket addresses");
_new->SetSockAddr(AF_FAMILY, ipaddr, port);
- log(DEBUG,"Socket addresses set.");
+ Instance->Log(DEBUG,"Socket addresses set.");
/* Smarter than your average bear^H^H^H^Hset of strlcpys. */
for (const char* temp = _new->GetIPString(); *temp && j < 64; temp++, j++)
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->timeout = TIME+class_regtimeout;
+ _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;
- 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* e = Instance->XLines->matches_exception(ipaddr);
if (!e)
{
- char* r = matches_zline(ipaddr);
+ char* r = Instance->XLines->matches_zline(ipaddr);
if (r)
{
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
void userrec::FullConnect(CullList* Goners)
{
ServerInstance->stats->statsConnects++;
- this->idle_lastmsg = TIME;
+ this->idle_lastmsg = ServerInstance->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;
}
char match_against[MAXBUF];
snprintf(match_against,MAXBUF,"%s@%s", this->ident, this->host);
- char* e = matches_exception(match_against);
+ char* e = ServerInstance->XLines->matches_exception(match_against);
if (!e)
{
- char* r = matches_gline(match_against);
+ char* r = ServerInstance->XLines->matches_gline(match_against);
if (r)
{
return;
}
- r = matches_kline(match_against);
+ r = ServerInstance->XLines->matches_kline(match_against);
if (r)
{
}
- 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->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(Config->data005);
+ std::stringstream out(ServerInstance->Config->data005);
std::string token = "";
std::string line5 = "";
int token_counter = 0;
}
}
- ShowMOTD(this);
+ this->ShowMOTD();
/*
* fix 3 by brain, move registered = 7 below these so that spurious modes and host
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)
return false;
}
- if (matches_qline(newnick))
+ if (ServerInstance->XLines->matches_qline(newnick))
{
ServerInstance->stats->statsCollisions++;
return false;
#ifdef SUPPORT_IP6LINKS
case AF_INET6:
{
- log(DEBUG,"Set inet6 protocol address");
+ 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:
{
- log(DEBUG,"Set inet4 protocol address");
+ ServerInstance->Log(DEBUG,"Set inet4 protocol address");
sockaddr_in* sin = new sockaddr_in;
sin->sin_family = AF_INET;
sin->sin_port = port;
}
break;
default:
- log(DEBUG,"Ut oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick);
+ ServerInstance->Log(DEBUG,"Ut oh, I dont know protocol %d to be set on '%s'!", protocol_family, this->nick);
break;
}
}
}
break;
default:
- log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
+ ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
break;
}
return 0;
}
break;
default:
- log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
+ ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
break;
}
return "";
break;
default:
- log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
+ ServerInstance->Log(DEBUG,"Ut oh, '%s' has an unknown protocol family!",this->nick);
break;
}
return "";
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)
{
- log(DEBUG,"Module exception caught: %s",modexcept.GetReason());
+ ServerInstance->Log(DEBUG,"Module exception caught: %s",modexcept.GetReason());
}
}
else
{
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]))
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();
+}
+
+void userrec::ShowMOTD()
+{
+ if (!ServerInstance->Config->MOTD.size())
+ {
+ this->WriteServ("422 %s :Message of the day file is missing.",this->nick);
+ return;
+ }
+ 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());
+
+ this->WriteServ("376 %s :End of message of the day.", this->nick);
+}
+
+void userrec::ShowRULES()
+{
+ if (!ServerInstance->Config->RULES.size())
+ {
+ this->WriteServ("NOTICE %s :Rules file is missing.",this->nick);
+ return;
+ }
+ 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());
+
+ this->WriteServ("NOTICE %s :End of %s rules.",this->nick,ServerInstance->Config->ServerName);
+}
+
projects / user / henk / code / inspircd.git / blobdiff