*/
void WriteAllExceptSender(userrec* user, char status, const std::string& text);
+ long GetMaxBans();
+
+ char* ChanModes(bool showkey);
+
+ void UserList(userrec *user);
+
+ int CountInvisible();
+
/** Destructor for chanrec
*/
virtual ~chanrec() { /* stub */ }
#include "modules.h"
class ServerConfig;
+class InspIRCd;
typedef bool (*Validator)(ServerConfig* conf, const char*, const char*, void*);
typedef bool (*MultiValidator)(ServerConfig* conf, const char*, char**, void**, int*);
class ServerConfig : public Extensible
{
private:
+ InspIRCd* ServerInstance;
+
/** This variable holds the names of all
* files included from the main one. This
* is used to make sure that no files are
*/
bool SyntaxHints;
- ServerConfig();
+ ServerConfig(InspIRCd* Instance);
/** Clears the include stack in preperation for
* a Read() call.
typedef std::vector< KeyVal > KeyValList;
typedef std::multimap< std::string, KeyValList > ConfigDataHash;
-void WriteOpers(char* text, ...);
int isnick(const char *n);
-chanrec* FindChan(const char* chan);
#endif
#define STRINGIFY(x) STRINGIFY2(x)
#define log(l, x, args...) InspIRCd::Log(l, __FILE__ ":" STRINGIFY(__LINE__) ": " x, ##args)
-void WriteOpers(const char* text, ...);
-void WriteOpers_NoFormat(const char* text);
-
-std::string GetServerDescription(const char* servername);
void strlower(char *n);
-userrec* Find(const std::string &nick);
-userrec* Find(const char* nick);
-chanrec* FindChan(const char* chan);
-int usercount_i(chanrec *c);
-long GetMaxBans(char* name);
-void purge_empty_chans(userrec* u);
-char* chanmodes(chanrec *chan, bool showkey);
-void userlist(userrec *user,chanrec *c);
-ConnectClass GetClass(userrec *user);
void Error(int status);
void ShowMOTD(userrec *user);
void ShowRULES(userrec *user);
int InsertMode(std::string &output, const char* modes, unsigned short section);
bool IsValidChannelName(const char *);
-int charlcat(char* x,char y,int z);
-bool charremove(char* mp, char remove);
-
#endif
const char* FindServerNamePtr(const std::string &servername);
bool FindServerName(const std::string &servername);
+ std::string GetServerDescription(const char* servername);
+
+ void WriteOpers(const char* text, ...);
+ void WriteOpers(const std::string &text);
+
+ userrec* FindNick(const std::string &nick);
+ userrec* FindNick(const char* nick);
+
+ chanrec* FindChan(const std::string &chan);
+ chanrec* FindChan(const char* chan);
+
bool UserToPseudo(userrec* user, const std::string &message);
bool PseudoToUser(userrec* alive, userrec* zombie, const std::string &message);
size_t strlcat(char *dst, const char *src, size_t siz);
#endif
+int charlcat(char* x,char y,int z);
+bool charremove(char* mp, char remove);
+
#endif
* @returns a priority ID which the core uses to relocate the module in the list
*/
long PriorityAfter(const std::string &modulename);
-
- /** Sends text to all opers.
- * This method sends a server notice to all opers with the usermode +s.
- */
- virtual void SendOpers(const std::string &s);
/** Returns the version string of this server
*/
*/
virtual bool IsNick(const std::string &nick);
- /** Attempts to look up a nick and return a pointer to it.
- * This function will return NULL if the nick does not exist.
- */
- virtual userrec* FindNick(const std::string &nick);
-
/** Attempts to look up a nick using the file descriptor associated with that nick.
* This function will return NULL if the file descriptor is not associated with a valid user.
*/
virtual userrec* FindDescriptor(int socket);
- /** Attempts to look up a channel and return a pointer to it.
- * This function will return NULL if the channel does not exist.
- */
- virtual chanrec* FindChannel(const std::string &channel);
-
/** Attempts to look up a user's privilages on a channel.
* This function will return a string containing either @, %, +, or an empty string,
* representing the user's privilages upon the channel you specify.
void SplitChanList(userrec* dest, const std::string &cl);
+ void PurgeEmptyChannels();
+
+ ConnectClass& GetClass();
+
/** Default destructor
*/
virtual ~userrec();
int MOD_RESULT = 0;
strlcpy(cname,cn,CHANMAX);
- chanrec* Ptr = FindChan(cname);
+ chanrec* Ptr = Instance->FindChan(cname);
if (!Ptr)
{
user->WriteServ("332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
user->WriteServ("333 %s %s %s %lu", user->nick, Ptr->name, Ptr->setby, (unsigned long)Ptr->topicset);
}
- userlist(user,Ptr);
+ Ptr->UserList(user);
user->WriteServ("366 %s %s :End of /NAMES list.", user->nick, Ptr->name);
}
FOREACH_MOD_I(Instance,I_OnUserJoin,OnUserJoin(user,Ptr));
}
}
+/*
+ * return a count of the users on a specific channel accounting for
+ * invisible users who won't increase the count. e.g. for /LIST
+ */
+int chanrec::CountInvisible()
+{
+ int count = 0;
+ CUList *ulist= this->GetUsers();
+ for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
+ {
+ if (!(i->second->modes[UM_INVISIBLE]))
+ count++;
+ }
+
+ return count;
+}
+
+char* chanrec::ChanModes(bool showkey)
+{
+ static char scratch[MAXBUF];
+ static char sparam[MAXBUF];
+ char* offset = scratch;
+ std::string extparam = "";
+
+ *scratch = '\0';
+ *sparam = '\0';
+
+ /* This was still iterating up to 190, chanrec::custom_modes is only 64 elements -- Om */
+ for(int n = 0; n < 64; n++)
+ {
+ if(this->modes[n])
+ {
+ *offset++ = n + 65;
+ extparam = "";
+ switch (n)
+ {
+ case CM_KEY:
+ extparam = (showkey ? this->key : "<key>");
+ break;
+ case CM_LIMIT:
+ extparam = ConvToStr(this->limit);
+ break;
+ case CM_NOEXTERNAL:
+ case CM_TOPICLOCK:
+ case CM_INVITEONLY:
+ case CM_MODERATED:
+ case CM_SECRET:
+ case CM_PRIVATE:
+ /* We know these have no parameters */
+ break;
+ default:
+ extparam = this->GetModeParameter(n + 65);
+ break;
+ }
+ if (extparam != "")
+ {
+ charlcat(sparam,' ',MAXBUF);
+ strlcat(sparam,extparam.c_str(),MAXBUF);
+ }
+ }
+ }
+
+ /* Null terminate scratch */
+ *offset = '\0';
+ strlcat(scratch,sparam,MAXBUF);
+ return scratch;
+}
+
+/* compile a userlist of a channel into a string, each nick seperated by
+ * spaces and op, voice etc status shown as @ and +, and send it to 'user'
+ */
+void chanrec::UserList(userrec *user)
+{
+ char list[MAXBUF];
+ size_t dlen, curlen;
+
+ dlen = curlen = snprintf(list,MAXBUF,"353 %s = %s :", user->nick, this->name);
+
+ int numusers = 0;
+ char* ptr = list + dlen;
+
+ CUList *ulist= this->GetUsers();
+
+ /* Improvement by Brain - this doesnt change in value, so why was it inside
+ * the loop?
+ */
+ bool has_user = this->HasUser(user);
+
+ for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
+ {
+ if ((!has_user) && (i->second->modes[UM_INVISIBLE]))
+ {
+ /*
+ * user is +i, and source not on the channel, does not show
+ * nick in NAMES list
+ */
+ continue;
+ }
+
+ size_t ptrlen = snprintf(ptr, MAXBUF, "%s%s ", cmode(i->second, this), i->second->nick);
+
+ curlen += ptrlen;
+ ptr += ptrlen;
+
+ numusers++;
+
+ if (curlen > (480-NICKMAX))
+ {
+ /* list overflowed into multiple numerics */
+ user->WriteServ(list);
+
+ /* reset our lengths */
+ dlen = curlen = snprintf(list,MAXBUF,"353 %s = %s :", user->nick, this->name);
+ ptr = list + dlen;
+
+ ptrlen = 0;
+ numusers = 0;
+ }
+ }
+
+ /* if whats left in the list isnt empty, send it */
+ if (numusers)
+ {
+ user->WriteServ(list);
+ }
+}
+
+long chanrec::GetMaxBans()
+{
+ std::string x;
+ for (std::map<std::string,int>::iterator n = ServerInstance->Config->maxbans.begin(); n != ServerInstance->Config->maxbans.end(); n++)
+ {
+ x = n->first;
+ if (match(this->name,x.c_str()))
+ {
+ return n->second;
+ }
+ }
+ return 64;
+}
+
+
else
{
log(SPARSE, "Failed /DIE command from %s!%s@%s", user->nick, user->ident, user->host);
- WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** Failed DIE Command from %s!%s@%s.",user->nick,user->ident,user->host);
}
}
if (!duration(parameters[1]))
{
- WriteOpers("*** %s added permanent E-line for %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s added permanent E-line for %s.",user->nick,parameters[0]);
}
else
{
- WriteOpers("*** %s added timed E-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
+ ServerInstance->WriteOpers("*** %s added timed E-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
}
}
else
if (del_eline(parameters[0]))
{
FOREACH_MOD(I_OnDelELine,OnDelELine(user, parameters[0]));
- WriteOpers("*** %s Removed E-line on %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s Removed E-line on %s.",user->nick,parameters[0]);
}
else
{
if (!duration(parameters[1]))
{
- WriteOpers("*** %s added permanent G-line for %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s added permanent G-line for %s.",user->nick,parameters[0]);
}
else
{
- WriteOpers("*** %s added timed G-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
+ ServerInstance->WriteOpers("*** %s added timed G-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
}
apply_lines(APPLY_GLINES);
if (del_gline(parameters[0]))
{
FOREACH_MOD(I_OnDelGLine,OnDelGLine(user, parameters[0]));
- WriteOpers("*** %s Removed G-line on %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s Removed G-line on %s.",user->nick,parameters[0]);
}
else
{
if (pcnt == 2)
{
- userrec* u = Find(parameters[0]);
- chanrec* c = FindChan(parameters[1]);
+ userrec* u = ServerInstance->FindNick(parameters[0]);
+ chanrec* c = ServerInstance->FindChan(parameters[1]);
if ((!c) || (!u))
{
#include "users.h"
#include "commands.h"
#include "helperfuncs.h"
+#include "inspircd.h"
#include "commands/cmd_ison.h"
+extern InspIRCd* ServerInstance;
+
void cmd_ison::Handle (const char** parameters, int pcnt, userrec *user)
{
char retbuf[MAXBUF];
for (int i = 0; i < pcnt; i++)
{
- u = Find(parameters[i]);
+ u = ServerInstance->FindNick(parameters[i]);
if (u)
{
#include "users.h"
#include "commands.h"
#include "helperfuncs.h"
+#include "inspircd.h"
#include "commands/cmd_kick.h"
+extern InspIRCd* ServerInstance;
+
void cmd_kick::Handle (const char** parameters, int pcnt, userrec *user)
{
char reason[MAXKICK];
- chanrec* c = FindChan(parameters[0]);
- userrec* u = Find(parameters[1]);
+ chanrec* c = ServerInstance->FindChan(parameters[0]);
+ userrec* u = ServerInstance->FindNick(parameters[1]);
if (!u || !c)
{
void cmd_kill::Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec *u = Find(parameters[0]);
+ userrec *u = ServerInstance->FindNick(parameters[0]);
char killreason[MAXBUF];
int MOD_RESULT = 0;
if (!IS_LOCAL(u))
{
// remote kill
- WriteOpers("*** Remote kill by %s: %s!%s@%s (%s)", user->nick, u->nick, u->ident, u->host, parameters[1]);
+ ServerInstance->WriteOpers("*** Remote kill by %s: %s!%s@%s (%s)", user->nick, u->nick, u->ident, u->host, parameters[1]);
snprintf(killreason, MAXQUIT,"[%s] Killed (%s (%s))", ServerInstance->Config->ServerName, user->nick, parameters[1]);
u->WriteCommonExcept("QUIT :%s", killreason);
FOREACH_MOD(I_OnRemoteKill, OnRemoteKill(user, u, killreason));
if (u->registered == REG_ALL)
{
- purge_empty_chans(u);
+ u->PurgeEmptyChannels();
}
DELETE(u);
// local kill
log(DEFAULT,"LOCAL KILL: %s :%s!%s!%s (%s)", u->nick, ServerInstance->Config->ServerName, user->dhost, user->nick, parameters[1]);
user->WriteTo(u, "KILL %s :%s!%s!%s (%s)", u->nick, ServerInstance->Config->ServerName, user->dhost, user->nick, parameters[1]);
- WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)", user->nick, u->nick, u->ident, u->host, parameters[1]);
+ ServerInstance->WriteOpers("*** Local Kill by %s: %s!%s@%s (%s)", user->nick, u->nick, u->ident, u->host, parameters[1]);
snprintf(killreason,MAXQUIT,"Killed (%s (%s))", user->nick, parameters[1]);
userrec::QuitUser(ServerInstance, u, killreason);
}
if (!duration(parameters[1]))
{
- WriteOpers("*** %s added permanent K-line for %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s added permanent K-line for %s.",user->nick,parameters[0]);
}
else
{
- WriteOpers("*** %s added timed K-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
+ ServerInstance->WriteOpers("*** %s added timed K-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
}
apply_lines(APPLY_KLINES);
if (del_kline(parameters[0]))
{
FOREACH_MOD(I_OnDelKLine,OnDelKLine(user, parameters[0]));
- WriteOpers("*** %s Removed K-line on %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s Removed K-line on %s.",user->nick,parameters[0]);
}
else
{
{
long users = i->second->GetUserCounter();
if (users)
- user->WriteServ("322 %s %s %d :[+%s] %s",user->nick,i->second->name,users,chanmodes(i->second,n),i->second->topic);
+ user->WriteServ("322 %s %s %d :[+%s] %s",user->nick,i->second->name,users,i->second->ChanModes(n),i->second->topic);
}
}
user->WriteServ("323 %s :End of channel list.",user->nick);
{
if (ServerInstance->LoadModule(parameters[0]))
{
- WriteOpers("*** NEW MODULE: %s",parameters[0]);
+ ServerInstance->WriteOpers("*** NEW MODULE: %s",parameters[0]);
user->WriteServ("975 %s %s :Module successfully loaded.",user->nick, parameters[0]);
}
else
if (ServerInstance->Parser->LoopCall(user, this, parameters, pcnt, 0))
return;
- c = FindChan(parameters[0]);
+ c = ServerInstance->FindChan(parameters[0]);
if (c)
{
if ((c->modes[CM_SECRET]) && (!c->HasUser(user)))
user->WriteServ("401 %s %s :No such nick/channel",user->nick, c->name);
return;
}
- userlist(user,c);
+ c->UserList(user);
user->WriteServ("366 %s %s :End of /NAMES list.", user->nick, c->name);
}
else
}
if (matches_qline(parameters[0]))
{
- WriteOpers("*** Q-Lined nickname %s from %s!%s@%s: %s",parameters[0],user->nick,user->ident,user->host,matches_qline(parameters[0]));
+ ServerInstance->WriteOpers("*** Q-Lined nickname %s from %s!%s@%s: %s",parameters[0],user->nick,user->ident,user->host,matches_qline(parameters[0]));
user->WriteServ("432 %s %s :Invalid nickname: %s",user->nick,parameters[0],matches_qline(parameters[0]));
return;
}
- if ((Find(parameters[0])) && (Find(parameters[0]) != user))
+ if ((ServerInstance->FindNick(parameters[0])) && (ServerInstance->FindNick(parameters[0]) != user))
{
user->WriteServ("433 %s %s :Nickname is already in use.",user->nick,parameters[0]);
return;
}
if (*parameters[0] == '#')
{
- chan = FindChan(parameters[0]);
+ chan = ServerInstance->FindChan(parameters[0]);
if (chan)
{
if (IS_LOCAL(user))
return;
}
- dest = Find(parameters[0]);
+ dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
int MOD_RESULT = 0;
if (!isnick(TypeName))
{
user->WriteServ("491 %s :Invalid oper type (oper types must follow the same syntax as nicknames)",user->nick);
- WriteOpers("*** CONFIGURATION ERROR! Oper type invalid for OperType '%s'",OperType);
+ ServerInstance->WriteOpers("*** CONFIGURATION ERROR! Oper type invalid for OperType '%s'",OperType);
log(DEFAULT,"OPER: Failed oper attempt by %s!%s@%s: credentials valid, but oper type erroneous.",user->nick,user->ident,user->host);
return;
}
if (found)
{
/* correct oper credentials */
- WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
+ ServerInstance->WriteOpers("*** %s (%s@%s) is now an IRC operator of type %s",user->nick,user->ident,user->host,OperType);
user->WriteServ("381 %s :You are now an IRC operator of type %s",user->nick,OperType);
if (!user->modes[UM_OPERATOR])
user->Oper(OperType);
if (!fail2)
{
user->WriteServ("491 %s :Invalid oper credentials",user->nick);
- WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** WARNING! Failed oper attempt by %s!%s@%s!",user->nick,user->ident,user->host);
log(DEFAULT,"OPER: Failed oper attempt by %s!%s@%s: user, host or password did not match.",user->nick,user->ident,user->host);
}
else
{
user->WriteServ("491 %s :Your oper block does not have a valid opertype associated with it",user->nick);
- WriteOpers("*** CONFIGURATION ERROR! Oper block mismatch for OperType %s",OperType);
+ ServerInstance->WriteOpers("*** CONFIGURATION ERROR! Oper block mismatch for OperType %s",OperType);
log(DEFAULT,"OPER: Failed oper attempt by %s!%s@%s: credentials valid, but oper type nonexistent.",user->nick,user->ident,user->host);
}
}
if (ServerInstance->Parser->LoopCall(user, this, parameters, pcnt, 0))
return;
- chanrec* c = FindChan(parameters[0]);
+ chanrec* c = ServerInstance->FindChan(parameters[0]);
if (c)
{
user->WriteServ("462 %s :You may not reregister",user->nick);
return;
}
- ConnectClass a = GetClass(user);
+ ConnectClass a = user->GetClass();
strlcpy(user->password,parameters[0],63);
if (!strcmp(parameters[0],a.pass.c_str()))
{
}
if (parameters[0][0] == '#')
{
- chan = FindChan(parameters[0]);
+ chan = ServerInstance->FindChan(parameters[0]);
if (chan)
{
if (IS_LOCAL(user))
return;
}
- dest = Find(parameters[0]);
+ dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
if ((IS_LOCAL(user)) && (*dest->awaymsg))
FOREACH_MOD(I_OnAddQLine,OnAddQLine(duration(parameters[1]), user, parameters[2], parameters[0]));
if (!duration(parameters[1]))
{
- WriteOpers("*** %s added permanent Q-line for %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s added permanent Q-line for %s.",user->nick,parameters[0]);
}
else
{
- WriteOpers("*** %s added timed Q-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
+ ServerInstance->WriteOpers("*** %s added timed Q-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
}
apply_lines(APPLY_QLINES);
}
if (del_qline(parameters[0]))
{
FOREACH_MOD(I_OnDelQLine,OnDelQLine(user, parameters[0]));
- WriteOpers("*** %s Removed Q-line on %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s Removed Q-line on %s.",user->nick,parameters[0]);
}
else
{
if (user->fd > -1)
{
user->Write("ERROR :Closing link (%s@%s) [%s%s]",user->ident,user->host,ServerInstance->Config->PrefixQuit,parameters[0]);
- WriteOpers("*** Client exiting: %s!%s@%s [%s%s]",user->nick,user->ident,user->host,ServerInstance->Config->PrefixQuit,parameters[0]);
+ ServerInstance->WriteOpers("*** Client exiting: %s!%s@%s [%s%s]",user->nick,user->ident,user->host,ServerInstance->Config->PrefixQuit,parameters[0]);
user->WriteCommonExcept("QUIT :%s%s",ServerInstance->Config->PrefixQuit,parameters[0]);
}
else
{
- WriteOpers("*** Client exiting at %s: %s!%s@%s [%s]",user->server,user->nick,user->ident,user->host,parameters[0]);
+ ServerInstance->WriteOpers("*** Client exiting at %s: %s!%s@%s [%s]",user->server,user->nick,user->ident,user->host,parameters[0]);
user->WriteCommonExcept("QUIT :%s",parameters[0]);
}
FOREACH_MOD(I_OnUserQuit,OnUserQuit(user,std::string(ServerInstance->Config->PrefixQuit)+std::string(parameters[0])));
else
{
user->Write("ERROR :Closing link (%s@%s) [QUIT]",user->ident,user->host);
- WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** Client exiting: %s!%s@%s [Client exited]",user->nick,user->ident,user->host);
user->WriteCommonExcept("QUIT :Client exited");
FOREACH_MOD(I_OnUserQuit,OnUserQuit(user,"Client exited"));
}
if (user->registered == REG_ALL) {
- purge_empty_chans(user);
+ user->PurgeEmptyChannels();
}
if (user->fd > -1)
ServerInstance->fd_ref_table[user->fd] = NULL;
}
else
{
- WriteOpers("%s is rehashing config file %s",user->nick,CleanFilename(CONFIG_FILE));
+ ServerInstance->WriteOpers("%s is rehashing config file %s",user->nick,CleanFilename(CONFIG_FILE));
ServerInstance->Config->Read(false,user);
}
FOREACH_MOD(I_OnRehash,OnRehash(parameter));
log(DEFAULT,"Restart: %s",user->nick);
if (!strcmp(parameters[0],ServerInstance->Config->restartpass))
{
- WriteOpers("*** RESTART command from %s!%s@%s, restarting server.",user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** RESTART command from %s!%s@%s, restarting server.",user->nick,user->ident,user->host);
argv[0] = ServerInstance->Config->MyExecutable;
argv[1] = "-wait";
}
else
{
- WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** Failed RESTART Command from %s!%s@%s.",user->nick,user->ident,user->host);
}
}
#include "users.h"
#include "commands.h"
#include "helperfuncs.h"
+#include "inspircd.h"
#include "commands/cmd_server.h"
+extern InspIRCd* ServerInstance;
+
void cmd_server::Handle (const char** parameters, int pcnt, userrec *user)
{
user->WriteServ("666 %s :You cannot identify as a server, you are a USER. IRC Operators informed.",user->nick);
- WriteOpers("*** WARNING: %s attempted to issue a SERVER command and is registered as a user!",user->nick);
+ ServerInstance->WriteOpers("*** WARNING: %s attempted to issue a SERVER command and is registered as a user!",user->nick);
}
}
results.push_back(sn+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
- WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
return;
}
if (pcnt == 1)
{
- Ptr = FindChan(parameters[0]);
+ Ptr = ServerInstance->FindChan(parameters[0]);
if (Ptr)
{
if ((Ptr->modes[CM_SECRET]) && (!Ptr->HasUser(user)))
}
else if (pcnt>1)
{
- Ptr = FindChan(parameters[0]);
+ Ptr = ServerInstance->FindChan(parameters[0]);
if (Ptr)
{
if (IS_LOCAL(user))
{
if (ServerInstance->UnloadModule(parameters[0]))
{
- WriteOpers("*** MODULE UNLOADED: %s",parameters[0]);
+ ServerInstance->WriteOpers("*** MODULE UNLOADED: %s",parameters[0]);
user->WriteServ("973 %s %s :Module successfully unloaded.",user->nick, parameters[0]);
}
else
#include "users.h"
#include "commands.h"
#include "helperfuncs.h"
+#include "inspircd.h"
#include "commands/cmd_userhost.h"
+extern InspIRCd* ServerInstance;
+
void cmd_userhost::Handle (const char** parameters, int pcnt, userrec *user)
{
char Return[MAXBUF],junk[MAXBUF];
for (int i = 0; i < pcnt; i++)
{
- userrec *u = Find(parameters[i]);
+ userrec *u = ServerInstance->FindNick(parameters[i]);
if(u)
{
if(*u->oper)
/* who on a channel? */
- ch = FindChan(matchtext);
+ ch = ServerInstance->FindChan(matchtext);
if (ch)
{
#include "commands/cmd_whois.h"
extern InspIRCd* ServerInstance;
-extern InspIRCd* ServerInstance;
+
extern int MODCOUNT;
extern ModuleList modules;
extern FactoryList factory;
}
else
{
- user->WriteServ("312 %s %s %s :%s",user->nick, dest->nick, dest->server, GetServerDescription(dest->server).c_str());
+ user->WriteServ("312 %s %s %s :%s",user->nick, dest->nick, dest->server, ServerInstance->GetServerDescription(dest->server).c_str());
}
if (*dest->awaymsg)
{
if (ServerInstance->Parser->LoopCall(user, this, parameters, pcnt, 0))
return;
- dest = Find(parameters[0]);
+ dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
do_whois(user,dest,0,0,parameters[0]);
user->WriteServ("318 %s %s :End of /WHOIS list.",user->nick, parameters[0]);
}
}
+
FOREACH_MOD(I_OnAddZLine,OnAddZLine(duration(parameters[1]), user, parameters[2], parameters[0]));
if (!duration(parameters[1]))
{
- WriteOpers("*** %s added permanent Z-line for %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s added permanent Z-line for %s.",user->nick,parameters[0]);
}
else
{
- WriteOpers("*** %s added timed Z-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
+ ServerInstance->WriteOpers("*** %s added timed Z-line for %s, expires in %d seconds.",user->nick,parameters[0],duration(parameters[1]));
}
apply_lines(APPLY_ZLINES);
}
if (del_zline(parameters[0]))
{
FOREACH_MOD(I_OnDelZLine,OnDelZLine(user, parameters[0]));
- WriteOpers("*** %s Removed Z-line on %s.",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** %s Removed Z-line on %s.",user->nick,parameters[0]);
}
else
{
float percent = ((float)matches / (float)ServerInstance->clientlist.size()) * 100;
if (percent > (float)atof(itrigger))
{
- WriteOpers("*** \2WARNING\2: %s tried to set a G/K/E line mask of %s, which covers %.2f%% of the network!",user->nick,mask.c_str(),percent);
+ ServerInstance->WriteOpers("*** \2WARNING\2: %s tried to set a G/K/E line mask of %s, which covers %.2f%% of the network!",user->nick,mask.c_str(),percent);
return true;
}
return false;
float percent = ((float)matches / (float)ServerInstance->clientlist.size()) * 100;
if (percent > (float)atof(itrigger))
{
- WriteOpers("*** \2WARNING\2: %s tried to set a Z line mask of %s, which covers %.2f%% of the network!",user->nick,ip.c_str(),percent);
+ ServerInstance->WriteOpers("*** \2WARNING\2: %s tried to set a Z line mask of %s, which covers %.2f%% of the network!",user->nick,ip.c_str(),percent);
return true;
}
return false;
float percent = ((float)matches / (float)ServerInstance->clientlist.size()) * 100;
if (percent > (float)atof(itrigger))
{
- WriteOpers("*** \2WARNING\2: %s tried to set a Q line mask of %s, which covers %.2f%% of the network!",user->nick,nick.c_str(),percent);
+ ServerInstance->WriteOpers("*** \2WARNING\2: %s tried to set a Q line mask of %s, which covers %.2f%% of the network!",user->nick,nick.c_str(),percent);
return true;
}
return false;
#include "userprocess.h"
#include "xline.h"
-extern InspIRCd* ServerInstance;
extern time_t TIME;
extern int MODCOUNT;
std::vector<std::string> old_module_names, new_module_names, added_modules, removed_modules;
-ServerConfig::ServerConfig()
+ServerConfig::ServerConfig(InspIRCd* Instance) : ServerInstance(Instance)
{
this->ClearStack();
*TempDir = *ServerName = *Network = *ServerDesc = *AdminName = '\0';
}
else
{
- WriteOpers("There were errors in the configuration file:");
- WriteOpers("You have more than one <%s> tag, this is not permitted.\n",tag);
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("You have more than one <%s> tag, this is not permitted.\n",tag);
}
}
return false;
}
else
{
- WriteOpers("There were errors in the configuration file:");
- WriteOpers("You have not defined a <%s> tag, this is required.",tag);
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("You have not defined a <%s> tag, this is required.",tag);
}
}
return false;
bool ValidateNetBufferSize(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- if ((!ServerInstance->Config->NetBufferSize) || (ServerInstance->Config->NetBufferSize > 65535) || (ServerInstance->Config->NetBufferSize < 1024))
+ if ((!conf->NetBufferSize) || (conf->NetBufferSize > 65535) || (conf->NetBufferSize < 1024))
{
log(DEFAULT,"No NetBufferSize specified or size out of range, setting to default of 10240.");
- ServerInstance->Config->NetBufferSize = 10240;
+ conf->NetBufferSize = 10240;
}
return true;
}
bool ValidateMaxWho(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- if ((!ServerInstance->Config->MaxWhoResults) || (ServerInstance->Config->MaxWhoResults > 65535) || (ServerInstance->Config->MaxWhoResults < 1))
+ if ((!conf->MaxWhoResults) || (conf->MaxWhoResults > 65535) || (conf->MaxWhoResults < 1))
{
log(DEFAULT,"No MaxWhoResults specified or size out of range, setting to default of 128.");
- ServerInstance->Config->MaxWhoResults = 128;
+ conf->MaxWhoResults = 128;
}
return true;
}
bool ValidateLogLevel(ServerConfig* conf, const char* tag, const char* value, void* data)
{
const char* dbg = (const char*)data;
- ServerInstance->Config->LogLevel = DEFAULT;
+ conf->LogLevel = DEFAULT;
if (!strcmp(dbg,"debug"))
{
- ServerInstance->Config->LogLevel = DEBUG;
- ServerInstance->Config->debugging = 1;
+ conf->LogLevel = DEBUG;
+ conf->debugging = 1;
}
else if (!strcmp(dbg,"verbose"))
- ServerInstance->Config->LogLevel = VERBOSE;
+ conf->LogLevel = VERBOSE;
else if (!strcmp(dbg,"default"))
- ServerInstance->Config->LogLevel = DEFAULT;
+ conf->LogLevel = DEFAULT;
else if (!strcmp(dbg,"sparse"))
- ServerInstance->Config->LogLevel = SPARSE;
+ conf->LogLevel = SPARSE;
else if (!strcmp(dbg,"none"))
- ServerInstance->Config->LogLevel = NONE;
+ conf->LogLevel = NONE;
return true;
}
bool ValidateMotd(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- conf->ReadFile(ServerInstance->Config->MOTD,ServerInstance->Config->motd);
+ conf->ReadFile(conf->MOTD,conf->motd);
return true;
}
bool ValidateRules(ServerConfig* conf, const char* tag, const char* value, void* data)
{
- conf->ReadFile(ServerInstance->Config->RULES,ServerInstance->Config->rules);
+ conf->ReadFile(conf->RULES,conf->rules);
return true;
}
bool InitConnect(ServerConfig* conf, const char* tag)
{
log(DEFAULT,"Reading connect classes...");
- ServerInstance->Config->Classes.clear();
+ conf->Classes.clear();
return true;
}
c.registration_timeout = 90;
if (c.pingtime == 0)
c.pingtime = 120;
- ServerInstance->Config->Classes.push_back(c);
+ conf->Classes.push_back(c);
}
else
{
c.host = deny;
c.type = CC_DENY;
- ServerInstance->Config->Classes.push_back(c);
+ conf->Classes.push_back(c);
log(DEBUG,"Read connect class type DENY, host=%s",deny);
}
*/
bool InitULine(ServerConfig* conf, const char* tag)
{
- ServerInstance->Config->ulines.clear();
+ conf->ulines.clear();
return true;
}
{
char* server = (char*)values[0];
log(DEBUG,"Read ULINE '%s'",server);
- ServerInstance->Config->ulines.push_back(server);
+ conf->ulines.push_back(server);
return true;
}
new_module_names.clear();
added_modules.clear();
removed_modules.clear();
- for (std::vector<std::string>::iterator t = ServerInstance->Config->module_names.begin(); t != ServerInstance->Config->module_names.end(); t++)
+ for (std::vector<std::string>::iterator t = conf->module_names.begin(); t != conf->module_names.end(); t++)
{
old_module_names.push_back(*t);
}
*/
bool InitMaxBans(ServerConfig* conf, const char* tag)
{
- ServerInstance->Config->maxbans.clear();
+ conf->maxbans.clear();
return true;
}
{
char* channel = (char*)values[0];
int* limit = (int*)values[1];
- ServerInstance->Config->maxbans[channel] = *limit;
+ conf->maxbans[channel] = *limit;
return true;
}
}
else
{
- WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
while(start < errors.length())
{
- WriteOpers(errors.substr(start, 360).c_str());
+ ServerInstance->WriteOpers(errors.substr(start, 360).c_str());
start += 360;
}
}
{
if (ServerInstance->UnloadModule(removing->c_str()))
{
- WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
+ ServerInstance->WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
if (user)
user->WriteServ("973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
{
if (ServerInstance->LoadModule(adding->c_str()))
{
- WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
+ ServerInstance->WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
if (user)
user->WriteServ("975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
}
}
-std::string GetServerDescription(const char* servername)
+std::string InspIRCd::GetServerDescription(const char* servername)
{
std::string description = "";
else
{
// not a remote server that can be found, it must be me.
- return ServerInstance->Config->ServerDesc;
+ return Config->ServerDesc;
}
}
* uses the oper list, which means if you have 2000 users but only 5 opers,
* it iterates 5 times.
*/
-void WriteOpers(const char* text, ...)
+void InspIRCd::WriteOpers(const char* text, ...)
{
char textbuffer[MAXBUF];
va_list argsPtr;
- if (!text)
- {
- log(DEFAULT,"*** BUG *** WriteOpers was given an invalid parameter");
- return;
- }
-
va_start(argsPtr, text);
vsnprintf(textbuffer, MAXBUF, text, argsPtr);
va_end(argsPtr);
- WriteOpers_NoFormat(textbuffer);
+ this->WriteOpers(std::string(textbuffer));
}
-void WriteOpers_NoFormat(const char* text)
+void InspIRCd::WriteOpers(const std::string &text)
{
- if (!text)
- {
- log(DEFAULT,"*** BUG *** WriteOpers_NoFormat was given an invalid parameter");
- return;
- }
-
for (std::vector<userrec*>::iterator i = all_opers.begin(); i != all_opers.end(); i++)
{
userrec* a = *i;
-
- if (IS_LOCAL(a))
+ if (IS_LOCAL(a) && a->modes[UM_SERVERNOTICE])
{
- if (a->modes[UM_SERVERNOTICE])
- {
- // send server notices to all with +s
- a->WriteServ("NOTICE %s :%s",a->nick,text);
- }
+ // send server notices to all with +s
+ a->WriteServ("NOTICE %s :%s",a->nick,text.c_str());
}
}
}
/* Find a user record by nickname and return a pointer to it */
-userrec* Find(const std::string &nick)
+userrec* InspIRCd::FindNick(const std::string &nick)
{
- user_hash::iterator iter = ServerInstance->clientlist.find(nick);
+ user_hash::iterator iter = clientlist.find(nick);
- if (iter == ServerInstance->clientlist.end())
+ if (iter == clientlist.end())
/* Couldn't find it */
return NULL;
return iter->second;
}
-userrec* Find(const char* nick)
+userrec* InspIRCd::FindNick(const char* nick)
{
user_hash::iterator iter;
if (!nick)
return NULL;
- iter = ServerInstance->clientlist.find(nick);
+ iter = clientlist.find(nick);
- if (iter == ServerInstance->clientlist.end())
+ if (iter == clientlist.end())
return NULL;
return iter->second;
/* find a channel record by channel name and return a pointer to it */
-chanrec* FindChan(const char* chan)
+chanrec* InspIRCd::FindChan(const char* chan)
{
chan_hash::iterator iter;
if (!chan)
- {
- log(DEFAULT,"*** BUG *** Findchan was given an invalid parameter");
return NULL;
- }
- iter = ServerInstance->chanlist.find(chan);
+ iter = chanlist.find(chan);
- if (iter == ServerInstance->chanlist.end())
+ if (iter == chanlist.end())
/* Couldn't find it */
return NULL;
return iter->second;
}
-
-long GetMaxBans(char* name)
-{
- std::string x;
- for (std::map<std::string,int>::iterator n = ServerInstance->Config->maxbans.begin(); n != ServerInstance->Config->maxbans.end(); n++)
- {
- x = n->first;
- if (match(name,x.c_str()))
- {
- return n->second;
- }
- }
- return 64;
-}
-
-void purge_empty_chans(userrec* u)
-{
- std::vector<chanrec*> to_delete;
-
- // firstly decrement the count on each channel
- for (std::vector<ucrec*>::iterator f = u->chans.begin(); f != u->chans.end(); f++)
- {
- ucrec* uc = (ucrec*)(*f);
- if (uc->channel)
- {
- if (uc->channel->DelUser(u) == 0)
- {
- /* No users left in here, mark it for deletion */
- to_delete.push_back(uc->channel);
- uc->channel = NULL;
- }
- }
- }
-
- log(DEBUG,"purge_empty_chans: %d channels to delete",to_delete.size());
-
- for (std::vector<chanrec*>::iterator n = to_delete.begin(); n != to_delete.end(); n++)
- {
- chanrec* thischan = (chanrec*)*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);
- }
- }
-
- u->UnOper();
-}
-
-
-char* chanmodes(chanrec *chan, bool showkey)
-{
- static char scratch[MAXBUF];
- static char sparam[MAXBUF];
- char* offset = scratch;
- std::string extparam = "";
-
- if (!chan)
- {
- log(DEFAULT,"*** BUG *** chanmodes was given an invalid parameter");
- *scratch = '\0';
- return scratch;
- }
-
- *scratch = '\0';
- *sparam = '\0';
-
- /* This was still iterating up to 190, chanrec::custom_modes is only 64 elements -- Om */
- for(int n = 0; n < 64; n++)
- {
- if(chan->modes[n])
- {
- *offset++ = n+65;
- extparam = "";
- switch (n)
- {
- case CM_KEY:
- extparam = (showkey ? chan->key : "<key>");
- break;
- case CM_LIMIT:
- extparam = ConvToStr(chan->limit);
- break;
- case CM_NOEXTERNAL:
- case CM_TOPICLOCK:
- case CM_INVITEONLY:
- case CM_MODERATED:
- case CM_SECRET:
- case CM_PRIVATE:
- /* We know these have no parameters */
- break;
- default:
- extparam = chan->GetModeParameter(n+65);
- break;
- }
- if (extparam != "")
- {
- charlcat(sparam,' ',MAXBUF);
- strlcat(sparam,extparam.c_str(),MAXBUF);
- }
- }
- }
-
- /* Null terminate scratch */
- *offset = '\0';
- strlcat(scratch,sparam,MAXBUF);
- return scratch;
-}
-
-
-/* compile a userlist of a channel into a string, each nick seperated by
- * spaces and op, voice etc status shown as @ and + */
-
-void userlist(userrec *user,chanrec *c)
-{
- if ((!c) || (!user))
- {
- log(DEFAULT,"*** BUG *** userlist was given an invalid parameter");
- return;
- }
-
- char list[MAXBUF];
- size_t dlen, curlen;
-
- dlen = curlen = snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
-
- int numusers = 0;
- char* ptr = list + dlen;
-
- CUList *ulist= c->GetUsers();
-
- /* Improvement by Brain - this doesnt change in value, so why was it inside
- * the loop?
- */
- bool has_user = c->HasUser(user);
-
- for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
- {
- if ((!has_user) && (i->second->modes[UM_INVISIBLE]))
- {
- /*
- * user is +i, and source not on the channel, does not show
- * nick in NAMES list
- */
- continue;
- }
-
- size_t ptrlen = snprintf(ptr, MAXBUF, "%s%s ", cmode(i->second, c), i->second->nick);
-
- curlen += ptrlen;
- ptr += ptrlen;
-
- numusers++;
-
- if (curlen > (480-NICKMAX))
- {
- /* list overflowed into multiple numerics */
- user->WriteServ(list);
-
- /* reset our lengths */
- dlen = curlen = snprintf(list,MAXBUF,"353 %s = %s :", user->nick, c->name);
- ptr = list + dlen;
-
- ptrlen = 0;
- numusers = 0;
- }
- }
-
- /* if whats left in the list isnt empty, send it */
- if (numusers)
- {
- user->WriteServ(list);
- }
-}
-
-/*
- * return a count of the users on a specific channel accounting for
- * invisible users who won't increase the count. e.g. for /LIST
- */
-int usercount_i(chanrec *c)
+chanrec* InspIRCd::FindChan(const std::string &chan)
{
- int count = 0;
-
- if (!c)
- return 0;
+ chan_hash::iterator iter = chanlist.find(chan);
- CUList *ulist= c->GetUsers();
- for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
- {
- if (!(i->second->modes[UM_INVISIBLE]))
- count++;
- }
+ if (iter == chanlist.end())
+ /* Couldn't find it */
+ return NULL;
- return count;
+ return iter->second;
}
-/* 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 GetClass(userrec *user)
-{
- for (ClassVector::iterator i = ServerInstance->Config->Classes.begin(); i != ServerInstance->Config->Classes.end(); i++)
- {
- if ((match(user->GetIPString(),i->host.c_str(),true)) || (match(user->host,i->host.c_str())))
- {
- return *i;
- }
- }
-
- return *(ServerInstance->Config->Classes.begin());
-}
/*
* sends out an error notice to all connected clients (not to be used
log(DEFAULT,"[%d] %s", i, strings[i]);
}
free(strings);
- WriteOpers("*** SIGSEGV: Please see the ircd.log for backtrace and report the error to http://www.inspircd.org/bugtrack/");
+ ServerInstance->WriteOpers("*** SIGSEGV: Please see the ircd.log for backtrace and report the error to http://www.inspircd.org/bugtrack/");
#else
log(DEFAULT,"You do not have execinfo.h so i could not backtrace -- on FreeBSD, please install the libexecinfo port.");
#endif
return true;
}
-inline int charlcat(char* x,char y,int z)
-{
- char* x__n = x;
- int v = 0;
-
- while(*x__n++)
- v++;
-
- if (v < z - 1)
- {
- *--x__n = y;
- *++x__n = 0;
- }
-
- return v;
-}
-
-bool charremove(char* mp, char remove)
-{
- char* mptr = mp;
- bool shift_down = false;
-
- while (*mptr)
- {
- if (*mptr == remove)
- shift_down = true;
-
- if (shift_down)
- *mptr = *(mptr+1);
-
- mptr++;
- }
-
- return shift_down;
-}
-
void OpenLog(char** argv, int argc)
{
if (!*LOG_FILE)
void Rehash(int status)
{
- WriteOpers("Rehashing config file %s due to SIGHUP",CleanFilename(CONFIG_FILE));
+ ServerInstance->WriteOpers("Rehashing config file %s due to SIGHUP",CleanFilename(CONFIG_FILE));
fclose(ServerInstance->Config->log_file);
OpenLog(NULL,0);
ServerInstance->Config->Read(false,NULL);
InspIRCd::InspIRCd(int argc, char** argv)
{
bool SEGVHandler = false;
- this->Config = new ServerConfig;
ServerInstance = this;
+ this->Config = new ServerConfig(this);
this->Start();
this->module_sockets.clear();
this->startup_time = time(NULL);
Config->Read(true, NULL);
CheckRoot();
this->ModeGrok = new ModeParser();
- AddServerName(Config->ServerName);
+ this->AddServerName(Config->ServerName);
CheckDie();
InitializeDisabledCommands(Config->DisabledCommands, this);
stats->BoundPortCount = BindPorts(true);
do
{
if ((*d++ = *s++) == 0)
- break;
+ break;
} while (--n != 0);
}
return(s - src - 1); /* count does not include NUL */
}
#endif
+
+int charlcat(char* x,char y,int z)
+{
+ char* x__n = x;
+ int v = 0;
+
+ while(*x__n++)
+ v++;
+
+ if (v < z - 1)
+ {
+ *--x__n = y;
+ *++x__n = 0;
+ }
+
+ return v;
+}
+
+bool charremove(char* mp, char remove)
+{
+ char* mptr = mp;
+ bool shift_down = false;
+
+ while (*mptr)
+ {
+ if (*mptr == remove)
+ shift_down = true;
+
+ if (shift_down)
+ *mptr = *(mptr+1);
+
+ mptr++;
+ }
+
+ return shift_down;
+}
+
{
return NULL;
}
- d = Find(dest);
+ d = ServerInstance->FindNick(dest);
if (!d)
{
user->WriteServ("401 %s %s :No such nick/channel",user->nick, dest);
if (targetchannel)
{
/* Display channel's current mode string */
- user->WriteServ("324 %s %s +%s",user->nick, targetchannel->name, chanmodes(targetchannel, targetchannel->HasUser(user)));
+ user->WriteServ("324 %s %s +%s",user->nick, targetchannel->name, targetchannel->ChanModes(targetchannel->HasUser(user)));
user->WriteServ("329 %s %s %d", user->nick, targetchannel->name, targetchannel->created);
return;
}
std::string target = parameters[0];
ModeType type = MODETYPE_USER;
unsigned char mask = 0;
- chanrec* targetchannel = FindChan(parameters[0]);
- userrec* targetuser = Find(parameters[0]);
+ chanrec* targetchannel = ServerInstance->FindChan(parameters[0]);
+ userrec* targetuser = ServerInstance->FindNick(parameters[0]);
log(DEBUG,"ModeParser::Process start");
if (dest == "")
return dest;
- long maxbans = GetMaxBans(chan->name);
+ long maxbans = chan->GetMaxBans();
if ((unsigned)chan->bans.size() > (unsigned)maxbans)
{
user->WriteServ("478 %s %s :Channel ban list for %s is full (maximum entries for this channel is %d)",user->nick, chan->name,chan->name,maxbans);
#include "modes/cmode_h.h"
extern InspIRCd* ServerInstance;
-extern InspIRCd* ServerInstance;
+
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
ModePair ModeChannelHalfOp::ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter)
{
- userrec* x = Find(parameter);
+ userrec* x = ServerInstance->FindNick(parameter);
if (x)
{
- if (cstatus(x, channel) == STATUS_HOP)
- {
- return std::make_pair(true, x->nick);
- }
- else
- {
- return std::make_pair(false, parameter);
- }
+ if (cstatus(x, channel) == STATUS_HOP)
+ {
+ return std::make_pair(true, x->nick);
+ }
+ else
+ {
+ return std::make_pair(false, parameter);
+ }
}
return std::make_pair(false, parameter);
}
#include "modes/cmode_o.h"
extern InspIRCd* ServerInstance;
-extern InspIRCd* ServerInstance;
+
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
ModePair ModeChannelOp::ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter)
{
- userrec* x = Find(parameter);
- if (x)
- {
- if (cstatus(x, channel) == STATUS_OP)
- {
- return std::make_pair(true, x->nick);
- }
- else
- {
- return std::make_pair(false, parameter);
- }
- }
+ userrec* x = ServerInstance->FindNick(parameter);
+ if (x)
+ {
+ if (cstatus(x, channel) == STATUS_OP)
+ {
+ return std::make_pair(true, x->nick);
+ }
+ else
+ {
+ return std::make_pair(false, parameter);
+ }
+ }
return std::make_pair(false, parameter);
}
#include "modes/cmode_v.h"
extern InspIRCd* ServerInstance;
-extern InspIRCd* ServerInstance;
+
extern std::vector<Module*> modules;
extern std::vector<ircd_module*> factory;
extern int MODCOUNT;
ModePair ModeChannelVoice::ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter)
{
- userrec* x = Find(parameter);
- if (x)
- {
- if (cstatus(x, channel) == STATUS_VOICE)
- {
- return std::make_pair(true, x->nick);
- }
- else
- {
- return std::make_pair(false, parameter);
- }
- }
+ userrec* x = ServerInstance->FindNick(parameter);
+ if (x)
+ {
+ if (cstatus(x, channel) == STATUS_VOICE)
+ {
+ return std::make_pair(true, x->nick);
+ }
+ else
+ {
+ return std::make_pair(false, parameter);
+ }
+ }
return std::make_pair(false, parameter);
}
void Server::RehashServer()
{
- WriteOpers("*** Rehashing config file");
+ ServerInstance->WriteOpers("*** Rehashing config file");
ServerInstance->Config->Read(false,NULL);
}
return NULL;
}
-void Server::SendOpers(const std::string &s)
-{
- WriteOpers("%s",s.c_str());
-}
-
bool Server::MatchText(const std::string &sliteral, const std::string &spattern)
{
return match(sliteral.c_str(),spattern.c_str());
return (isnick(nick.c_str()) != 0);
}
-userrec* Server::FindNick(const std::string &nick)
-{
- return Find(nick);
-}
-
userrec* Server::FindDescriptor(int socket)
{
return (socket < 65536 ? ServerInstance->fd_ref_table[socket] : NULL);
}
-chanrec* Server::FindChannel(const std::string &channel)
-{
- return FindChan(channel.c_str());
-}
-
std::string Server::ChanMode(userrec* User, chanrec* Chan)
{
return cmode(User,Chan);
zombie->WriteServ("332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
zombie->WriteServ("333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
}
- userlist(zombie,Ptr);
+ Ptr->UserList(zombie);
zombie->WriteServ("366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
}
}
}
else
{
- WriteOpers("There were errors in the configuration file:");
+ ServerInstance->WriteOpers("There were errors in the configuration file:");
while(start < errors.length())
{
- WriteOpers(errors.substr(start, 360).c_str());
+ ServerInstance->WriteOpers(errors.substr(start, 360).c_str());
start += 360;
}
}
log(DEBUG, "SQLrequest failed: %s", req.error.Str());
if (verbose)
- WriteOpers("Forbidden connection from %s!%s@%s (SQL query failed: %s)", user->nick, user->ident, user->host, req.error.Str());
+ ServerInstance->WriteOpers("Forbidden connection from %s!%s@%s (SQL query failed: %s)", user->nick, user->ident, user->host, req.error.Str());
return false;
}
else if (verbose)
{
/* No rows in result, this means there was no record matching the user */
- WriteOpers("Forbidden connection from %s!%s@%s (SQL query returned no matches)", user->nick, user->ident, user->host);
+ ServerInstance->WriteOpers("Forbidden connection from %s!%s@%s (SQL query returned no matches)", user->nick, user->ident, user->host);
user->Extend("sqlauth_failed");
}
}
else if (verbose)
{
log(DEBUG, "Query failed: %s", res->error.Str());
- WriteOpers("Forbidden connection from %s!%s@%s (SQL query failed: %s)", user->nick, user->ident, user->host, res->error.Str());
+ ServerInstance->WriteOpers("Forbidden connection from %s!%s@%s (SQL query failed: %s)", user->nick, user->ident, user->host, res->error.Str());
user->Extend("sqlauth_failed");
}
}
/* $ModDesc: Provides aliases of commands. */
+extern InspIRCd* ServerInstance;
+
class Alias : public classbase
{
public:
{
if (Aliases[i].requires != "")
{
- u = Srv->FindNick(Aliases[i].requires);
+ u = ServerInstance->FindNick(Aliases[i].requires);
if (!u)
{
user->WriteServ("401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is currently unavailable. Please try again later.");
{
if (!Srv->IsUlined(u->server))
{
- Srv->SendOpers("*** NOTICE -- Service "+Aliases[i].requires+" required by alias "+std::string(Aliases[i].text.c_str())+" is not on a u-lined server, possibly underhanded antics detected!");
+ ServerInstance->WriteOpers("*** NOTICE -- Service "+Aliases[i].requires+" required by alias "+std::string(Aliases[i].text.c_str())+" is not on a u-lined server, possibly underhanded antics detected!");
user->WriteServ("401 "+std::string(user->nick)+" "+Aliases[i].requires+" :is an imposter! Please inform an IRC operator as soon as possible.");
return 1;
}
{
// Block it...
if(action == IBLOCK_KILLOPERS || action == IBLOCK_NOTICEOPERS)
- WriteOpers("*** %s had an /amsg or /ame denied", user->nick);
+ ServerInstance->WriteOpers("*** %s had an /amsg or /ame denied", user->nick);
if(action == IBLOCK_KILL || action == IBLOCK_KILLOPERS)
userrec::QuitUser(ServerInstance, user, "Global message (/amsg or /ame) detected");
/* $ModDesc: Gives /cban, aka C:lines. Think Q:lines, for channels. */
+extern InspIRCd* ServerInstance;
+
class CBan : public classbase
{
public:
if(length > 0)
{
user->WriteServ( "385 %s %s :Added %lu second channel ban (%s)", user->nick, parameters[0], length, reason.c_str());
- WriteOpers("*** %s added %lu second channel ban on %s (%s)", user->nick, length, parameters[0], reason.c_str());
+ ServerInstance->WriteOpers("*** %s added %lu second channel ban on %s (%s)", user->nick, length, parameters[0], reason.c_str());
}
else
{
user->WriteServ( "385 %s %s :Added permenant channel ban (%s)", user->nick, parameters[0], reason.c_str());
- WriteOpers("*** %s added permenant channel ban on %s (%s)", user->nick, parameters[0], reason.c_str());
+ ServerInstance->WriteOpers("*** %s added permenant channel ban on %s (%s)", user->nick, parameters[0], reason.c_str());
}
}
else
{
// Channel is banned.
user->WriteServ( "384 %s %s :Cannot join channel, CBANed (%s)", user->nick, cname, iter->reason.c_str());
- WriteOpers("*** %s tried to join %s which is CBANed (%s)", user->nick, cname, iter->reason.c_str());
+ ServerInstance->WriteOpers("*** %s tried to join %s which is CBANed (%s)", user->nick, cname, iter->reason.c_str());
return 1;
}
}
if (iter->set_on + iter->length <= TIME)
{
log(DEBUG, "m_cban.so: Ban on %s expired, removing...", iter->chname.c_str());
- WriteOpers("*** %li second CBAN on %s (%s) set %u seconds ago expired", iter->length, iter->chname.c_str(), iter->reason.c_str(), TIME - iter->set_on);
+ ServerInstance->WriteOpers("*** %li second CBAN on %s (%s) set %u seconds ago expired", iter->length, iter->chname.c_str(), iter->reason.c_str(), TIME - iter->set_on);
cbans.erase(iter);
go_again = true;
}
if ((them) && (them == ServerInstance->fd_ref_table[theirfd]))
{
if (notify)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from %s", them->nick, them->host, result.c_str(), typ.c_str());
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from %s", them->nick, them->host, result.c_str(), typ.c_str());
strlcpy(them->host, result.c_str(), 63);
strlcpy(them->dhost, result.c_str(), 63);
if ((them) && (them == ServerInstance->fd_ref_table[theirfd]))
{
if (notify)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but their host can't be resolved from their %s!", them->nick, them->host,typ.c_str());
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but their host can't be resolved from their %s!", them->nick, them->host,typ.c_str());
}
}
log(DEBUG, "m_cgiirc.so: Got an IP in the user's password");
if(NotifyOpers)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from PASS", user->nick, user->host, user->password);
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from PASS", user->nick, user->host, user->password);
}
else
{
catch (ModuleException& e)
{
if (NotifyOpers)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but i could not resolve their hostname!", user->nick, user->host);
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but i could not resolve their hostname!", user->nick, user->host);
}
}
*user->password = 0;
/*if(NotifyOpers)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from PASS", user->nick, user->host, user->password);*/
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), changing real host to %s from PASS", user->nick, user->host, user->password);*/
return true;
}
strlcpy(user->ident, "~cgiirc", 8);
if(NotifyOpers)
- WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but i could not resolve their hostname!", user->nick, user->host);
+ ServerInstance->WriteOpers("*** Connecting user %s detected as using CGI:IRC (%s), but i could not resolve their hostname!", user->nick, user->host);
}
/*strlcpy(user->host, newip, 16);
strlcpy(user->dhost, newip, 16);
/* $ModDesc: Provides channel modes +a and +q */
+extern InspIRCd* ServerInstance;
+
const char* fakevalue = "on";
class ChanFounder : public ModeHandler
ModePair ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter)
{
- userrec* x = Find(parameter);
+ userrec* x = ServerInstance->FindNick(parameter);
if (x)
{
if (!channel->HasUser(x))
ModeAction OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string ¶meter, bool adding)
{
- userrec* theuser = Srv->FindNick(parameter);
+ userrec* theuser = ServerInstance->FindNick(parameter);
log(DEBUG,"ChanFounder::OnModeChange");
ModePair ModeSet(userrec* source, userrec* dest, chanrec* channel, const std::string ¶meter)
{
- userrec* x = Find(parameter);
+ userrec* x = ServerInstance->FindNick(parameter);
if (x)
{
if (!channel->HasUser(x))
ModeAction OnModeChange(userrec* source, userrec* dest, chanrec* channel, std::string ¶meter, bool adding)
{
- userrec* theuser = Srv->FindNick(parameter);
+ userrec* theuser = ServerInstance->FindNick(parameter);
// cant find the user given as the parameter, eat the mode change.
if (!theuser)
checkstr = "304 " + std::string(user->nick) + " :CHECK";
- targuser = Srv->FindNick(std::string(parameters[0]));
- targchan = Srv->FindChannel(std::string(parameters[0]));
+ targuser = ServerInstance->FindNick(parameters[0]);
+ targchan = ServerInstance->FindChan(parameters[0]);
/*
* Syntax of a /check reply:
user->WriteServ(checkstr + " topic_setat " + timebuf);
}
- user->WriteServ(checkstr + " modes " + chanmodes(targchan, true));
+ user->WriteServ(checkstr + " modes " + targchan->ChanModes(true));
user->WriteServ(checkstr + " membercount " + ConvToStr(targchan->GetUserCounter()));
/* now the ugly bit, spool current members of a channel. :| */
#include "channels.h"
#include "modules.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Provides support for the CHGHOST command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_chghost : public command_t
{
user->WriteServ("NOTICE %s :*** CHGHOST: Host too long",user->nick);
return;
}
- userrec* dest = Srv->FindNick(std::string(parameters[0]));
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
if ((dest->ChangeDisplayedHost(parameters[1])) && (!Srv->IsUlined(user->server)))
{
// fix by brain - ulines set hosts silently
- Srv->SendOpers(std::string(user->nick)+" used CHGHOST to make the displayed host of "+std::string(dest->nick)+" become "+std::string(parameters[1]));
+ ServerInstance->WriteOpers(std::string(user->nick)+" used CHGHOST to make the displayed host of "+dest->nick+" become "+parameters[1]);
}
}
}
#include "modules.h"
#include "message.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Provides support for the CHGIDENT command */
+extern InspIRCd* ServerInstance;
+
class cmd_chgident : public command_t
{
Server* Srv;
void Handle(const char** parameters, int pcnt, userrec *user)
{
- userrec* dest = Srv->FindNick(std::string(parameters[0]));
-
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
+
if(dest)
{
if(!isident(parameters[1]))
return;
}
- WriteOpers("%s used CHGIDENT to change %s's ident from '%s' to '%s'", user->nick, dest->nick, dest->ident, parameters[1]);
+ ServerInstance->WriteOpers("%s used CHGIDENT to change %s's ident from '%s' to '%s'", user->nick, dest->nick, dest->ident, parameters[1]);
strlcpy(dest->ident, parameters[1], IDENTMAX+2);
}
else
{
/* expire throttle */
throttled = 0;
- Srv->SendOpers("*** Connection throttle deactivated");
+ ServerInstance->WriteOpers("*** Connection throttle deactivated");
return;
}
userrec::QuitUser(ServerInstance, user, quitmsg);
if (conns >= maxconns)
{
throttled = 1;
- Srv->SendOpers("*** Connection throttle activated");
+ ServerInstance->WriteOpers("*** Connection throttle activated");
userrec::QuitUser(ServerInstance, user, quitmsg);
return;
}
if (f->action == "block")
{
- Srv->SendOpers(std::string("FILTER: ")+std::string(user->nick)+
- std::string(" had their notice filtered, target was ")+
- target+": "+f->reason);
- user->WriteServ("NOTICE "+std::string(user->nick)+
- " :Your notice has been filtered and opers notified: "+f->reason);
+ ServerInstance->WriteOpers(std::string("FILTER: ")+user->nick+" had their notice filtered, target was "+target+": "+f->reason);
+ user->WriteServ("NOTICE "+std::string(user->nick)+" :Your notice has been filtered and opers notified: "+f->reason);
}
Srv->Log(DEFAULT,std::string("FILTER: ")+std::string(user->nick)+
std::string(" had their notice filtered, target was ")+
{
if (ServerInstance->LoadModule(parameters[0]))
{
- WriteOpers("*** NEW MODULE '%s' GLOBALLY LOADED BY '%s'",parameters[0],user->nick);
+ ServerInstance->WriteOpers("*** NEW MODULE '%s' GLOBALLY LOADED BY '%s'",parameters[0],user->nick);
user->WriteServ("975 %s %s :Module successfully loaded.",user->nick, parameters[0]);
}
else
{
if (ServerInstance->UnloadModule(parameters[0]))
{
- WriteOpers("*** MODULE '%s' GLOBALLY UNLOADED BY '%s'",parameters[0],user->nick);
+ ServerInstance->WriteOpers("*** MODULE '%s' GLOBALLY UNLOADED BY '%s'",parameters[0],user->nick);
user->WriteServ("973 %s %s :Module successfully unloaded.",user->nick, parameters[0]);
}
else
int n = 0;
for (SortedIter a = so->begin(); ((a != so->end()) && (n < 25)); a++, n++)
{
- chanrec* c = Srv->FindChannel(a->second.c_str());
+ chanrec* c = ServerInstance->FindChan(a->second.c_str());
if (c)
{
data << "<tr><td>" << a->first << "</td><td>" << a->second << "</td>";
/* $ModDesc: Provides support for /KNOCK and mode +K */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_knock : public command_t
{
void Handle (const char** parameters, int pcnt, userrec *user)
{
- chanrec* c = Srv->FindChannel(parameters[0]);
+ chanrec* c = ServerInstance->FindChan(parameters[0]);
if (!c)
{
#include "modules.h"
#include "helperfuncs.h"
#include "hashcomp.h"
+#include "inspircd.h"
/* $ModDesc: Provides the NICKLOCK command, allows an oper to chage a users nick and lock them to it until they quit */
void Handle(const char** parameters, int pcnt, userrec *user)
{
- userrec* source = Srv->FindNick(std::string(parameters[0]));
+ userrec* source = ServerInstance->FindNick(parameters[0]);
irc::string server;
irc::string me;
if (Srv->IsNick(std::string(parameters[1])))
{
// give them a lock flag
- Srv->SendOpers(std::string(user->nick)+" used NICKLOCK to change and hold "+std::string(parameters[0])+" to "+parameters[1]);
+ ServerInstance->WriteOpers(std::string(user->nick)+" used NICKLOCK to change and hold "+parameters[0]+" to "+parameters[1]);
if (!source->ForceNickChange(parameters[1]))
{
userrec::QuitUser(ServerInstance, source, "Nickname collision");
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* source = Srv->FindNick(std::string(parameters[0]));
+ userrec* source = ServerInstance->FindNick(parameters[0]);
if (source)
{
source->Shrink("nick_locked");
user->WriteServ("945 %s %s :Nickname now unlocked.",user->nick,source->nick);
- Srv->SendOpers(std::string(user->nick)+" used NICKUNLOCK on "+std::string(parameters[0]));
+ ServerInstance->WriteOpers(std::string(user->nick)+" used NICKUNLOCK on "+parameters[0]);
}
}
};
/* $ModDesc: Gives each oper type a 'level', cannot kill opers 'above' your level. */
+extern InspIRCd* ServerInstance;
+
class ModuleOperLevels : public Module
{
}
if (dest_level > source_level)
{
- WriteOpers("Oper %s (level %d) attempted to /kill a higher oper: %s (level %d): Reason: %s",source->nick,source_level,dest->nick,dest_level,reason.c_str());
+ ServerInstance->WriteOpers("Oper %s (level %d) attempted to /kill a higher oper: %s (level %d): Reason: %s",source->nick,source_level,dest->nick,dest_level,reason.c_str());
dest->WriteServ("NOTICE %s :Oper %s attempted to /kill you!",dest->nick,source->nick);
source->WriteServ("481 %s :Permission Denied- Oper %s is a higher level than you",source->nick,dest->nick);
return 1;
/* $ModDesc: Provides support for unreal-style oper-override */
+extern InspIRCd* ServerInstance;
+
typedef std::map<std::string,std::string> override_t;
class ModuleOverride : public Module
{
if (((Srv->ChanMode(source,chan) == "%") && (Srv->ChanMode(user,chan) == "@")) || (Srv->ChanMode(source,chan) == ""))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Kicked "+std::string(user->nick)+" on "+std::string(chan->name)+" ("+reason+")");
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Kicked "+std::string(user->nick)+" on "+std::string(chan->name)+" ("+reason+")");
}
/* Returning -1 explicitly allows the kick */
return -1;
case AC_DEOP:
if (CanOverride(source,"MODEDEOP"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Deopped "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Deopped "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
case AC_OP:
if (CanOverride(source,"MODEOP"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Opped "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Opped "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
case AC_VOICE:
if (CanOverride(source,"MODEVOICE"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Voiced "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Voiced "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
case AC_DEVOICE:
if (CanOverride(source,"MODEDEVOICE"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Devoiced "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Devoiced "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
case AC_HALFOP:
if (CanOverride(source,"MODEHALFOP"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Halfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Halfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
case AC_DEHALFOP:
if (CanOverride(source,"MODEDEHALFOP"))
{
- Srv->SendOpers("*** NOTICE: "+std::string(source->nick)+" Override-Dehalfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
+ ServerInstance->WriteOpers("*** NOTICE: "+std::string(source->nick)+" Override-Dehalfopped "+std::string(dest->nick)+" on "+std::string(channel->name));
return ACR_ALLOW;
}
else
chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s invited himself into the channel", cname, user->nick);
}
}
- Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +i on "+std::string(cname));
+ ServerInstance->WriteOpers("*** "+std::string(user->nick)+" used operoverride to bypass +i on "+std::string(cname));
return -1;
}
{
if (NoisyOverride)
chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s bypassed the channel key", cname, user->nick);
- Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +k on "+std::string(cname));
+ ServerInstance->WriteOpers("*** "+std::string(user->nick)+" used operoverride to bypass +k on "+std::string(cname));
return -1;
}
{
if (NoisyOverride)
chan->WriteChannelWithServ(Srv->GetServerName().c_str(), "NOTICE %s :%s passed through your channel limit", cname, user->nick);
- Srv->SendOpers("*** "+std::string(user->nick)+" used operoverride to bypass +l on "+std::string(cname));
+ ServerInstance->WriteOpers("*** "+std::string(user->nick)+" used operoverride to bypass +l on "+std::string(cname));
return -1;
}
*
* And there you have it, easy huh (NOT)...
*/
- userrec* unpark = Srv->FindNick(std::string(parameters[0]));
+ userrec* unpark = ServerInstance->FindNick(parameters[0]);
if (!unpark)
{
user->WriteServ("942 %s %s :Invalid user specified.",user->nick, parameters[0]);
{
if (time(NULL) >= (j->parktime+ParkMaxTime))
{
- userrec* thisnick = Srv->FindNick(j->nick);
+ userrec* thisnick = ServerInstance->FindNick(j->nick);
// THIS MUST COME BEFORE THE QuitUser - QuitUser can
// create a recursive call to OnUserQuit in this module
// and then corrupt the pointer!
return MODEACTION_DENY;
}
- c = Srv->FindChannel(parameter);
+ c = ServerInstance->FindChan(parameter);
if (c)
{
/* Fix by brain: Dont let a channel be linked to *itself* either */
* eg: +h can remove +hv and users with no modes. +a can remove +aohv and users with no modes.
*/
+extern InspIRCd* ServerInstance;
+
class RemoveBase
{
private:
username = parameters[ neworder ? 1 : 0];
/* Look up the user we're meant to be removing from the channel */
- target = Srv->FindNick(username);
+ target = ServerInstance->FindNick(username);
/* And the channel we're meant to be removing them from */
- channel = Srv->FindChannel(channame);
+ channel = ServerInstance->FindChan(channame);
/* Fix by brain - someone needs to learn to validate their input! */
if (!target || !channel)
long users = chan->GetUserCounter();
if (users)
{
- int counter = snprintf(buffer,MAXBUF,"322 %s %s %ld :[+%s] %s",u->nick,chan->name,users,chanmodes(chan,has_user),chan->topic);
+ int counter = snprintf(buffer,MAXBUF,"322 %s %s %ld :[+%s] %s",u->nick,chan->name,users,chan->ChanModes(has_user),chan->topic);
/* Increment total plus linefeed */
amount_sent += counter + 4 + Srv->GetServerName().length();
log(DEBUG,"m_safelist.so: Sent %ld of safe %ld / 4",amount_sent,u->sendqmax);
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* dest = Srv->FindNick(std::string(parameters[0]));
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
if (Srv->IsUlined(dest->server))
return;
}
- Srv->SendOpers(std::string(user->nick)+" used SAJOIN to make "+std::string(dest->nick)+" join "+parameters[1]);
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SAJOIN to make "+std::string(dest->nick)+" join "+parameters[1]);
chanrec::JoinUser(ServerInstance, dest, parameters[1], true);
}
}
result.append(" ");
result.append(parameters[n]);
}
- Srv->SendOpers(result);
+ ServerInstance->WriteOpers(result);
}
};
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* source = Srv->FindNick(std::string(parameters[0]));
+ userrec* source = ServerInstance->FindNick(parameters[0]);
if (source)
{
if (Srv->IsUlined(source->server))
{
// FIX by brain: Cant use source->nick here because if it traverses a server link then
// source->nick becomes invalid as the object data moves in memory.
- Srv->SendOpers(std::string(user->nick)+" used SANICK to change "+std::string(parameters[0])+" to "+parameters[1]);
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SANICK to change "+std::string(parameters[0])+" to "+parameters[1]);
if (!source->ForceNickChange(parameters[1]))
{
/* We couldnt change the nick */
/* $ModDesc: Provides support for unreal-style SAPART command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_sapart : public command_t
{
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* dest = Srv->FindNick(parameters[0]);
- chanrec* channel = Srv->FindChannel(parameters[1]);
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
+ chanrec* channel = ServerInstance->FindChan(parameters[1]);
if (dest && channel)
{
if (Srv->IsUlined(dest->server))
user->WriteServ("990 %s :Cannot use an SA command on a u-lined client",user->nick);
return;
}
- Srv->SendOpers(std::string(user->nick)+" used SAPART to make "+dest->nick+" part "+parameters[1]);
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SAPART to make "+dest->nick+" part "+parameters[1]);
if (!channel->PartUser(dest, dest->nick))
delete channel;
}
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* dest = Srv->FindNick(std::string(parameters[0]));
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
{
if (Srv->IsUlined(dest->server))
}
line = line + std::string(parameters[pcnt-1]);
- Srv->SendOpers(std::string(user->nick)+" used SAQUIT to make "+std::string(dest->nick)+" quit with a reason of "+line);
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SAQUIT to make "+std::string(dest->nick)+" quit with a reason of "+line);
userrec::QuitUser(ServerInstance, dest, line);
}
}
#include "channels.h"
#include "modules.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Provides support for the SETHOST command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_sethost : public command_t
{
}
}
if (user->ChangeDisplayedHost(parameters[0]))
- Srv->SendOpers(std::string(user->nick)+" used SETHOST to change their displayed host to "+std::string(parameters[0]));
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SETHOST to change their displayed host to "+std::string(parameters[0]));
}
};
#include "users.h"
#include "modules.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Provides support for the SETIDENT command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_setident : public command_t
{
return;
}
- WriteOpers("%s used SETIDENT to change their ident from '%s' to '%s'", user->nick, user->ident, parameters[0]);
+ ServerInstance->WriteOpers("%s used SETIDENT to change their ident from '%s' to '%s'", user->nick, user->ident, parameters[0]);
strlcpy(user->ident, parameters[0], IDENTMAX+2);
}
};
#include "channels.h"
#include "modules.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Allows opers to set their idle time */
static Server *Srv = NULL;
+extern InspIRCd* ServerInstance;
class cmd_setidle : public command_t
{
// minor tweak - we cant have signon time shorter than our idle time!
if (user->signon > user->idle_lastmsg)
user->signon = user->idle_lastmsg;
- Srv->SendOpers(std::string(user->nick)+" used SETIDLE to set their idle time to "+std::string(parameters[0])+" seconds");
+ ServerInstance->WriteOpers(std::string(user->nick)+" used SETIDLE to set their idle time to "+std::string(parameters[0])+" seconds");
user->WriteServ("944 %s :Idle time set.",user->nick);
}
};
if (Srv->MatchText(Srv->GetServerName(),parameters[0]))
{
/* Yes, initiate the given connect */
- WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]);
+ ServerInstance->WriteOpers("*** Remote CONNECT from %s matching \002%s\002, connecting server \002%s\002",user->nick,parameters[0],parameters[1]);
const char* para[1];
para[0] = parameters[1];
Creator->OnPreCommand("CONNECT", para, 1, user, true);
keylength = key.length();
if (!(keylength == 16 || keylength == 24 || keylength == 32))
{
- WriteOpers("*** \2ERROR\2: Key length for encryptionkey is not 16, 24 or 32 bytes in length!");
+ ServerInstance->WriteOpers("*** \2ERROR\2: Key length for encryptionkey is not 16, 24 or 32 bytes in length!");
log(DEBUG,"Key length not 16, 24 or 32 characters!");
}
else
{
- WriteOpers("*** \2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
+ ServerInstance->WriteOpers("*** \2AES\2: Initialized %d bit encryption to server %s",keylength*8,SName.c_str());
ctx_in->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", keylength, keylength);
ctx_out->MakeKey(key.c_str(), "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\
{
if (x->Name == this->myhost)
{
- Srv->SendOpers("*** Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] established.");
+ ServerInstance->WriteOpers("*** Connection to \2"+myhost+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] established.");
this->SendCapabilities();
if (x->EncryptionKey != "")
{
if (!(x->EncryptionKey.length() == 16 || x->EncryptionKey.length() == 24 || x->EncryptionKey.length() == 32))
{
- WriteOpers("\2WARNING\2: Your encryption key is NOT 16, 24 or 32 characters in length, encryption will \2NOT\2 be enabled.");
+ ServerInstance->WriteOpers("\2WARNING\2: Your encryption key is NOT 16, 24 or 32 characters in length, encryption will \2NOT\2 be enabled.");
}
else
{
* If that happens the connection hangs here until it's closed. Unlikely
* and rather harmless.
*/
- Srv->SendOpers("*** Connection to \2"+myhost+"\2 lost link tag(!)");
+ ServerInstance->WriteOpers("*** Connection to \2"+myhost+"\2 lost link tag(!)");
return true;
}
*/
if (e == I_ERR_CONNECT)
{
- Srv->SendOpers("*** Connection failed: Connection refused");
+ ServerInstance->WriteOpers("*** Connection failed: Connection refused");
}
}
quitserver = this->InboundServerName;
}
- WriteOpers("*** \2ERROR\2: Server '%s' does not have the same set of modules loaded, cannot link!",quitserver.c_str());
- WriteOpers("*** Our networked module set is: '%s'",this->MyCapabilities().c_str());
- WriteOpers("*** Other server's networked module set is: '%s'",params[0].c_str());
- WriteOpers("*** These lists must match exactly on both servers. Please correct these errors, and try again.");
+ ServerInstance->WriteOpers("*** \2ERROR\2: Server '%s' does not have the same set of modules loaded, cannot link!",quitserver.c_str());
+ ServerInstance->WriteOpers("*** Our networked module set is: '%s'",this->MyCapabilities().c_str());
+ ServerInstance->WriteOpers("*** Other server's networked module set is: '%s'",params[0].c_str());
+ ServerInstance->WriteOpers("*** These lists must match exactly on both servers. Please correct these errors, and try again.");
this->WriteLine("ERROR :CAPAB mismatch; My capabilities: '"+this->MyCapabilities()+"'");
return false;
}
DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
if (Current->GetParent() == TreeRoot)
{
- Srv->SendOpers("Server \002"+Current->GetName()+"\002 split: "+reason);
+ ServerInstance->WriteOpers("Server \002"+Current->GetName()+"\002 split: "+reason);
}
else
{
- Srv->SendOpers("Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
+ ServerInstance->WriteOpers("Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
}
num_lost_servers = 0;
num_lost_users = 0;
Current->Tidy();
Current->GetParent()->DelChild(Current);
DELETE(Current);
- WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
+ ServerInstance->WriteOpers("Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
}
else
{
std::string sourceserv;
/* Are we dealing with an FMODE from a user, or from a server? */
- userrec* who = Srv->FindNick(source);
+ userrec* who = ServerInstance->FindNick(source);
if (who)
{
/* FMODE from a user, set sourceserv to the users server name */
}
/* Extract the TS value of the object, either userrec or chanrec */
- userrec* dst = Srv->FindNick(params[0]);
+ userrec* dst = ServerInstance->FindNick(params[0]);
chanrec* chan = NULL;
time_t ourTS = 0;
if (dst)
}
else
{
- chan = Srv->FindChannel(params[0]);
+ chan = ServerInstance->FindChan(params[0]);
if (chan)
{
ourTS = chan->age;
*/
if ((Srv->IsUlined(sourceserv)) && (TS > ourTS))
{
- WriteOpers("\2WARNING!\2 U-Lined server '%s' has bad TS for '%s' (accepted change): \2SYNC YOUR CLOCKS\2 to avoid this notice",sourceserv.c_str(),params[0].c_str());
+ ServerInstance->WriteOpers("\2WARNING!\2 U-Lined server '%s' has bad TS for '%s' (accepted change): \2SYNC YOUR CLOCKS\2 to avoid this notice",sourceserv.c_str(),params[0].c_str());
}
/* Allow the mode, route it to either server or user command handling */
if (smode)
time_t ts = atoi(params[1].c_str());
std::string nsource = source;
- chanrec* c = Srv->FindChannel(params[0]);
+ chanrec* c = ServerInstance->FindChan(params[0]);
if (c)
{
if ((ts >= c->topicset) || (!*c->topic))
*/
if (oldtopic != params[3])
{
- userrec* user = Srv->FindNick(source);
+ userrec* user = ServerInstance->FindNick(source);
if (!user)
{
c->WriteChannelWithServ(source.c_str(), "TOPIC %s :%s", c->name, c->topic);
time_t TS = atoi(params[1].c_str());
char* key = "";
- chanrec* chan = Srv->FindChannel(channel);
+ chanrec* chan = ServerInstance->FindChan(channel);
if (chan)
{
key = chan->key;
* channel will let the other side apply their modes.
*/
time_t ourTS = time(NULL)+600;
- chanrec* us = Srv->FindChannel(channel);
+ chanrec* us = ServerInstance->FindChan(channel);
if (us)
{
ourTS = us->age;
strlcat(modestring,"v",MAXBUF);
break;
}
- who = Srv->FindNick(usr);
+ who = ServerInstance->FindNick(usr);
if (who)
{
chanrec::JoinUser(this->Instance, who, channel.c_str(), true, key);
{
if (params.size() >= 2)
{
- chanrec* c = Srv->FindChannel(params[0]);
+ chanrec* c = ServerInstance->FindChan(params[0]);
if (c)
{
time_t theirTS = atoi(params[1].c_str());
else
_new->SetSockAddr(AF_INET, params[6].c_str(), 0);
- WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString());
+ ServerInstance->WriteOpers("*** Client connecting at %s: %s!%s@%s [%s]",_new->server,_new->nick,_new->ident,_new->host, _new->GetIPString());
params[7] = ":" + params[7];
DoOneToAllButSender(source,"NICK",params,source);
}
/* XXX: Send each channel mode and its params -- we'll need a method for this in ModeHandler? */
//FOREACH_MOD(I_OnSyncChannel,OnSyncChannel(c->second,(Module*)TreeProtocolModule,(void*)this));
- this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+chanmodes(c,true)+modes+" "+params);
+ this->WriteLine(":"+Srv->GetServerName()+" FMODE "+c->name+" "+ConvToStr(c->age)+" +"+c->ChanModes(true)+modes+" "+params);
}
/* Send G, Q, Z and E lines */
std::string endburst = "ENDBURST";
// Because by the end of the netburst, it could be gone!
std::string name = s->GetName();
- Srv->SendOpers("*** Bursting to \2"+name+"\2.");
+ ServerInstance->WriteOpers("*** Bursting to \2"+name+"\2.");
this->WriteLine(burst);
/* send our version string */
this->WriteLine(":"+Srv->GetServerName()+" VERSION :"+Srv->GetVersion());
this->SendXLines(s);
FOREACH_MOD(I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)TreeProtocolModule,(void*)this));
this->WriteLine(endburst);
- Srv->SendOpers("*** Finished bursting to \2"+name+"\2.");
+ ServerInstance->WriteOpers("*** Finished bursting to \2"+name+"\2.");
}
/* This function is called when we receive data from a remote
{
if (params.size() < 1)
return false;
- WriteOpers("*** ERROR from %s: %s",(InboundServerName != "" ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
+ ServerInstance->WriteOpers("*** ERROR from %s: %s",(InboundServerName != "" ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
/* we will return false to cause the socket to close. */
return false;
}
{
/* It's for our server */
string_list results;
- userrec* source = Srv->FindNick(prefix);
+ userrec* source = ServerInstance->FindNick(prefix);
if (source)
{
std::deque<std::string> par;
else
{
/* Pass it on */
- userrec* source = Srv->FindNick(prefix);
+ userrec* source = ServerInstance->FindNick(prefix);
if (source)
DoOneToOne(prefix, "STATS", params, params[1]);
}
return true;
}
std::string opertype = params[0];
- userrec* u = Srv->FindNick(prefix);
+ userrec* u = ServerInstance->FindNick(prefix);
if (u)
{
u->modes[UM_OPERATOR] = 1;
if (params.size() < 3)
return true;
- userrec* u = Srv->FindNick(params[0]);
+ userrec* u = ServerInstance->FindNick(params[0]);
if (u)
{
if (params.size() < 2)
return true;
- userrec* u = Srv->FindNick(params[0]);
+ userrec* u = ServerInstance->FindNick(params[0]);
if (u)
{
if (Srv->MatchText(Srv->GetServerName(),servermask))
{
- Srv->SendOpers("*** Remote rehash initiated from server \002"+prefix+"\002.");
+ ServerInstance->WriteOpers("*** Remote rehash initiated from server \002"+prefix+"\002.");
Srv->RehashServer();
ReadConfiguration(false);
}
return true;
std::string nick = params[0];
- userrec* u = Srv->FindNick(prefix);
- userrec* who = Srv->FindNick(nick);
+ userrec* u = ServerInstance->FindNick(prefix);
+ userrec* who = ServerInstance->FindNick(nick);
if (who)
{
* dump the PONG reply back to their fd. If its a server, do nowt.
* Services might want to send these s->s, but we dont need to yet.
*/
- userrec* u = Srv->FindNick(prefix);
+ userrec* u = ServerInstance->FindNick(prefix);
if (u)
{
}
else if (*(params[0].c_str()) == '#')
{
- chanrec* c = Srv->FindChannel(params[0]);
+ chanrec* c = ServerInstance->FindChan(params[0]);
if (c)
{
FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]));
}
else if (*(params[0].c_str()) != '#')
{
- userrec* u = Srv->FindNick(params[0]);
+ userrec* u = ServerInstance->FindNick(params[0]);
if (u)
{
FOREACH_MOD(I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2]));
if (params.size() < 1)
return true;
- userrec* u = Srv->FindNick(prefix);
+ userrec* u = ServerInstance->FindNick(prefix);
if (u)
{
break;
default:
/* Just in case... */
- Srv->SendOpers("*** \2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!");
+ ServerInstance->WriteOpers("*** \2WARNING\2: Invalid xline type '"+params[0]+"' sent by server "+prefix+", ignored!");
propogate = false;
break;
}
{
if (atoi(params[4].c_str()))
{
- WriteOpers("*** %s Added %cLINE on %s to expire in %lu seconds (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),atoi(params[4].c_str()),params[5].c_str());
+ ServerInstance->WriteOpers("*** %s Added %cLINE on %s to expire in %lu seconds (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),atoi(params[4].c_str()),params[5].c_str());
}
else
{
- WriteOpers("*** %s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str());
+ ServerInstance->WriteOpers("*** %s Added permenant %cLINE on %s (%s).",prefix.c_str(),*(params[0].c_str()),params[1].c_str(),params[5].c_str());
}
params[5] = ":" + params[5];
DoOneToAllButSender(prefix,"ADDLINE",params,prefix);
if (params.size() < 1)
return true;
- userrec* u = Srv->FindNick(prefix);
+ userrec* u = ServerInstance->FindNick(prefix);
if (u)
{
return true;
log(DEBUG,"In IDLE command");
- userrec* u = Srv->FindNick(prefix);
+ userrec* u = ServerInstance->FindNick(prefix);
if (u)
{
// an incoming request
if (params.size() == 1)
{
- userrec* x = Srv->FindNick(params[0]);
+ userrec* x = ServerInstance->FindNick(params[0]);
if ((x) && (IS_LOCAL(x)))
{
- userrec* x = Srv->FindNick(params[0]);
+ userrec* x = ServerInstance->FindNick(params[0]);
log(DEBUG,"Got IDLE");
char signon[MAXBUF];
char idle[MAXBUF];
else if (params.size() == 3)
{
std::string who_did_the_whois = params[0];
- userrec* who_to_send_to = Srv->FindNick(who_did_the_whois);
+ userrec* who_to_send_to = ServerInstance->FindNick(who_did_the_whois);
if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
{
log(DEBUG,"Got final IDLE");
if (params.size() < 2)
return true;
- userrec* u = Srv->FindNick(params[0]);
+ userrec* u = ServerInstance->FindNick(params[0]);
if (!u)
return true;
// someone querying our time?
if (Srv->GetServerName() == params[0])
{
- userrec* u = Srv->FindNick(params[1]);
+ userrec* u = ServerInstance->FindNick(params[1]);
if (u)
{
char curtime[256];
else
{
// not us, pass it on
- userrec* u = Srv->FindNick(params[1]);
+ userrec* u = ServerInstance->FindNick(params[1]);
if (u)
DoOneToOne(prefix,"TIME",params,params[0]);
}
else if (params.size() == 3)
{
// a response to a previous TIME
- userrec* u = Srv->FindNick(params[1]);
+ userrec* u = ServerInstance->FindNick(params[1]);
if ((u) && (IS_LOCAL(u)))
{
time_t rawtime = atol(params[2].c_str());
if (CheckDupe)
{
this->WriteLine("ERROR :Server "+servername+" already exists!");
- Srv->SendOpers("*** Server connection from \2"+servername+"\2 denied, already exists");
+ ServerInstance->WriteOpers("*** Server connection from \2"+servername+"\2 denied, already exists");
return false;
}
TreeServer* Node = new TreeServer(servername,description,ParentOfThis,NULL);
ParentOfThis->AddChild(Node);
params[3] = ":" + params[3];
DoOneToAllButSender(prefix,"SERVER",params,prefix);
- Srv->SendOpers("*** Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
+ ServerInstance->WriteOpers("*** Server \002"+prefix+"\002 introduced server \002"+servername+"\002 ("+description+")");
return true;
}
if (hops)
{
this->WriteLine("ERROR :Server too far away for authentication");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
std::string description = params[3];
if (CheckDupe)
{
this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
// Begin the sync here. this kickstarts the
}
}
this->WriteLine("ERROR :Invalid credentials");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
if (hops)
{
this->WriteLine("ERROR :Server too far away for authentication");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
std::string description = params[3];
if (CheckDupe)
{
this->WriteLine("ERROR :Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
/* If the config says this link is encrypted, but the remote side
if ((x->EncryptionKey != "") && (!this->ctx_in))
{
this->WriteLine("ERROR :This link requires AES encryption to be enabled. Plaintext connection refused.");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, remote server did not enable AES.");
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, remote server did not enable AES.");
return false;
}
- Srv->SendOpers("*** Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
+ ServerInstance->WriteOpers("*** Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
this->InboundServerName = sname;
this->InboundDescription = description;
// this is good. Send our details: Our server name and description and hopcount of 0,
}
}
this->WriteLine("ERROR :Invalid credentials");
- Srv->SendOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
+ ServerInstance->WriteOpers("*** Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
}
else if ((this->ctx_in) && (command == "AES"))
{
- WriteOpers("*** \2AES\2: Encryption already enabled on this connection yet %s is trying to enable it twice!",params[0].c_str());
+ ServerInstance->WriteOpers("*** \2AES\2: Encryption already enabled on this connection yet %s is trying to enable it twice!",params[0].c_str());
}
switch (this->LinkState)
long delta = THEM-time(NULL);
if ((delta < -600) || (delta > 600))
{
- WriteOpers("*** \2ERROR\2: Your clocks are out by %d seconds (this is more than ten minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta));
+ ServerInstance->WriteOpers("*** \2ERROR\2: Your clocks are out by %d seconds (this is more than ten minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs(delta));
this->WriteLine("ERROR :Your clocks are out by "+ConvToStr(abs(delta))+" seconds (this is more than ten minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!");
return false;
}
else if ((delta < -60) || (delta > 60))
{
- WriteOpers("*** \2WARNING\2: Your clocks are out by %d seconds, please consider synching your clocks.",abs(delta));
+ ServerInstance->WriteOpers("*** \2WARNING\2: Your clocks are out by %d seconds, please consider synching your clocks.",abs(delta));
}
}
this->LinkState = CONNECTED;
if (prefix != "")
{
std::string direction = prefix;
- userrec* t = Srv->FindNick(prefix);
+ userrec* t = ServerInstance->FindNick(prefix);
if (t)
{
direction = t->server;
std::string sourceserv = this->myhost;
if (params.size() == 3)
{
- userrec* user = Srv->FindNick(params[1]);
- chanrec* chan = Srv->FindChannel(params[0]);
+ userrec* user = ServerInstance->FindNick(params[1]);
+ chanrec* chan = ServerInstance->FindChan(params[0]);
if (user && chan)
{
if (!chan->ServerKickUser(user, params[2].c_str(), false))
{
sourceserv = this->InboundServerName;
}
- WriteOpers("*** Received end of netburst from \2%s\2",sourceserv.c_str());
+ ServerInstance->WriteOpers("*** Received end of netburst from \2%s\2",sourceserv.c_str());
return true;
}
else
// not a special inter-server command.
// Emulate the actual user doing the command,
// this saves us having a huge ugly parser.
- userrec* who = Srv->FindNick(prefix);
+ userrec* who = ServerInstance->FindNick(prefix);
std::string sourceserv = this->myhost;
if (this->InboundServerName != "")
{
* already exist here. If it does, kill their copy,
* and our copy.
*/
- userrec* x = Srv->FindNick(params[0]);
+ userrec* x = ServerInstance->FindNick(params[0]);
if ((x) && (x != who))
{
std::deque<std::string> p;
p.push_back("Nickname collision");
DoOneToMany(Srv->GetServerName(),"KILL",p);
userrec::QuitUser(this->Instance,x,"Nickname collision ("+prefix+" -> "+params[0]+")");
- userrec* y = Srv->FindNick(prefix);
+ userrec* y = ServerInstance->FindNick(prefix);
if (y)
{
userrec::QuitUser(this->Instance,y,"Nickname collision");
{
if (this->LinkState == CONNECTING)
{
- Srv->SendOpers("*** CONNECT: Connection to \002"+myhost+"\002 timed out.");
+ ServerInstance->WriteOpers("*** CONNECT: Connection to \002"+myhost+"\002 timed out.");
}
}
{
Squit(s,"Remote host closed the connection");
}
- WriteOpers("Server '\2%s\2' closed the connection.",quitserver.c_str());
+ ServerInstance->WriteOpers("Server '\2%s\2' closed the connection.",quitserver.c_str());
}
virtual int OnIncomingConnection(int newsock, char* ip)
if (!found)
{
- WriteOpers("Server connection from %s denied (no link blocks with that IP address)", ip);
+ ServerInstance->WriteOpers("Server connection from %s denied (no link blocks with that IP address)", ip);
close(newsock);
return false;
}
else
{
/* Something barfed, show the opers */
- WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno));
+ ServerInstance->WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",MyLink.Name.c_str(),strerror(errno));
delete newsocket;
}
}
void OnError(ResolverError e, const std::string &errormessage)
{
/* Ooops! */
- WriteOpers("*** CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str());
+ ServerInstance->WriteOpers("*** CONNECT: Error connecting \002%s\002: Unable to resolve hostname - %s",MyLink.Name.c_str(),errormessage.c_str());
}
};
if ((*(params[0].c_str()) != '#') && (*(params[0].c_str()) != '$'))
{
// special routing for private messages/notices
- userrec* d = Srv->FindNick(params[0]);
+ userrec* d = ServerInstance->FindNick(params[0]);
if (d)
{
std::deque<std::string> par;
else
{
log(DEBUG,"Channel privmsg going to chan %s",params[0].c_str());
- chanrec* c = Srv->FindChannel(params[0]);
+ chanrec* c = ServerInstance->FindChan(params[0]);
if (c)
{
std::deque<TreeServer*> list;
if (sock)
{
log(DEBUG,"Splitting server %s",s->GetName().c_str());
- WriteOpers("*** SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
+ ServerInstance->WriteOpers("*** SQUIT: Server \002%s\002 removed from network by %s",parameters[0],user->nick);
sock->Squit(s,"Server quit by "+std::string(user->nick)+"!"+std::string(user->ident)+"@"+std::string(user->host));
Srv->RemoveSocket(sock);
}
{
if ((IS_LOCAL(user)) && (pcnt > 1))
{
- userrec* remote = Srv->FindNick(parameters[1]);
+ userrec* remote = ServerInstance->FindNick(parameters[1]);
if ((remote) && (remote->fd < 0))
{
std::deque<std::string> params;
else
{
// they didnt answer, boot them
- WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str());
+ ServerInstance->WriteOpers("*** Server \002%s\002 pinged out",serv->GetName().c_str());
sock->Squit(serv,"Ping timeout");
Srv->RemoveSocket(sock);
return;
if (!CheckDupe)
{
// an autoconnected server is not connected. Check if its time to connect it
- WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
+ ServerInstance->WriteOpers("*** AUTOCONNECT: Auto-connecting server \002%s\002 (%lu seconds until next attempt)",x->Name.c_str(),x->AutoConnect);
insp_inaddr binip;
}
else
{
- WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+ ServerInstance->WriteOpers("*** AUTOCONNECT: Error autoconnecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
delete newsocket;
}
}
}
else
{
- WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
+ ServerInstance->WriteOpers("*** CONNECT: Error connecting \002%s\002: %s.",x->Name.c_str(),strerror(errno));
delete newsocket;
}
}
results.push_back(Srv->GetServerName()+" 244 "+user->nick+" H * * "+LinkBlocks[i].Name.c_str());
}
results.push_back(Srv->GetServerName()+" 219 "+user->nick+" "+statschar+" :End of /STATS report");
- WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
+ ServerInstance->WriteOpers("*** Notice: %s '%c' requested by %s (%s@%s)",(!strcmp(user->server,ServerInstance->Config->ServerName) ? "Stats" : "Remote stats"),statschar,user->nick,user->ident,user->host);
return 1;
}
return 0;
// check for self
if (Srv->MatchText(Srv->GetServerName(),parameter))
{
- Srv->SendOpers("*** Remote rehash initiated from server \002"+Srv->GetServerName()+"\002.");
+ ServerInstance->WriteOpers("*** Remote rehash initiated from server \002"+Srv->GetServerName()+"\002.");
Srv->RehashServer();
}
}
return;
// Insert the TS value of the object, either userrec or chanrec
time_t ourTS = 0;
- userrec* a = Srv->FindNick((*params)[0]);
+ userrec* a = ServerInstance->FindNick((*params)[0]);
if (a)
{
ourTS = a->age;
}
else
{
- chanrec* a = Srv->FindChannel((*params)[0]);
+ chanrec* a = ServerInstance->FindChan((*params)[0]);
if (a)
{
ourTS = a->age;
void Handle (const char** parameters, int pcnt, userrec *user)
{
- WriteOpers("*** Oper %s used SPYLIST to list +s/+p channels and keys.",user->nick);
+ ServerInstance->WriteOpers("*** Oper %s used SPYLIST to list +s/+p channels and keys.",user->nick);
user->WriteServ("321 %s Channel :Users Name",user->nick);
for (chan_hash::const_iterator i = chanlist.begin(); i != chanlist.end(); i++)
{
- user->WriteServ("322 %s %s %d :[+%s] %s",user->nick,i->second->name,i->second->GetUserCounter(),chanmodes(i->second,true),i->second->topic);
+ user->WriteServ("322 %s %s %d :[+%s] %s",user->nick,i->second->name,i->second->GetUserCounter(),i->second->ChanModes(true),i->second->topic);
}
user->WriteServ("323 %s :End of channel list.",user->nick);
}
if (ServerInstance->Parser->LoopCall(user, this, parameters, pcnt, 1))
return;
- WriteOpers("*** Oper %s used SPYNAMES to view the users on %s",user->nick,parameters[0]);
+ ServerInstance->WriteOpers("*** Oper %s used SPYNAMES to view the users on %s",user->nick,parameters[0]);
- c = FindChan(parameters[0]);
+ c = ServerInstance->FindChan(parameters[0]);
if (c)
{
spy_userlist(user,c);
/* $ModDesc: Provides the SWHOIS command which allows setting of arbitary WHOIS lines */
+extern InspIRCd* ServerInstance;
+
class cmd_swhois : public command_t
{
Server* Srv;
void Handle(const char** parameters, int pcnt, userrec* user)
{
- userrec* dest = Srv->FindNick(std::string(parameters[0]));
+ userrec* dest = ServerInstance->FindNick(parameters[0]);
if(dest)
{
std::string line;
if (!Srv->IsUlined(user->server))
// Ulines set SWHOISes silently
- WriteOpers("*** %s used SWHOIS to set %s's extra whois from '%s' to '%s'", user->nick, dest->nick, text->c_str(), line.c_str());
+ ServerInstance->WriteOpers("*** %s used SWHOIS to set %s's extra whois from '%s' to '%s'", user->nick, dest->nick, text->c_str(), line.c_str());
dest->Shrink("swhois");
DELETE(text);
else if(!Srv->IsUlined(user->server))
{
// Ulines set SWHOISes silently
- WriteOpers("*** %s used SWHOIS to set %s's extra whois to '%s'", user->nick, dest->nick, line.c_str());
+ ServerInstance->WriteOpers("*** %s used SWHOIS to set %s's extra whois to '%s'", user->nick, dest->nick, line.c_str());
}
text = new std::string(line);
void Handle (const char** parameters, int pcnt, userrec *user)
{
- chanrec* channel = Srv->FindChannel(parameters[0]);
+ chanrec* channel = ServerInstance->FindChan(parameters[0]);
if (channel)
{
std::string cm = Srv->ChanMode(user,channel);
{
if (curtime > i->expire)
{
- chanrec* cr = Srv->FindChannel(i->channel);
+ chanrec* cr = ServerInstance->FindChan(i->channel);
again = true;
if (cr)
{
#include "modules.h"
#include "helperfuncs.h"
#include "message.h"
+#include "inspircd.h"
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_uninvite : public command_t
{
void Handle (const char** parameters, int pcnt, userrec *user)
{
- userrec* u = Find(parameters[0]);
- chanrec* c = FindChan(parameters[1]);
+ userrec* u = ServerInstance->FindNick(parameters[0]);
+ chanrec* c = ServerInstance->FindChan(parameters[1]);
if ((!c) || (!u))
{
#include "channels.h"
#include "modules.h"
#include "helperfuncs.h"
+#include "inspircd.h"
/* $ModDesc: Provides support for USERIP command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class cmd_userip : public command_t
{
snprintf(Return,MAXBUF,"340 %s :",user->nick);
for (int i = 0; i < pcnt; i++)
{
- userrec *u = Find(parameters[i]);
+ userrec *u = ServerInstance->FindNick(parameters[i]);
if (u)
{
snprintf(junk,MAXBUF,"%s%s=+%s@%s ",u->nick,*u->oper ? "*" : "",u->ident,u->GetIPString());
/* $ModDesc: Provides support for the /watch command */
static Server *Srv;
+extern InspIRCd* ServerInstance;
class watchentry : public classbase
{
watchentry* a = (watchentry*)(*q);
if (a->watcher == user)
{
- userrec* targ = Srv->FindNick(a->target);
+ userrec* targ = ServerInstance->FindNick(a->target);
if (targ)
{
user->WriteServ("604 %s %s %s %s %lu :is online",user->nick,targ->nick,targ->ident,targ->dhost,targ->age);
watchentry* a = (watchentry*)(*q);
if (a->watcher == user)
{
- userrec* targ = Srv->FindNick(a->target);
+ userrec* targ = ServerInstance->FindNick(a->target);
if (targ)
{
user->WriteServ("604 %s %s %s %s %lu :is online",user->nick,targ->nick,targ->ident,targ->dhost,targ->age);
if (b->watcher == user)
{
irc::string n2 = b->target.c_str();
- userrec* a = Srv->FindNick(b->target);
+ userrec* a = ServerInstance->FindNick(b->target);
if (a)
{
user->WriteServ("602 %s %s %s %s %lu :stopped watching",user->nick,a->nick,a->ident,a->dhost,a->age);
watches.push_back(w);
log(DEBUG,"*** Added %s to watchlist of %s",nick,user->nick);
}
- userrec* a = Srv->FindNick(nick);
+ userrec* a = ServerInstance->FindNick(nick);
if (a)
{
user->WriteServ("604 %s %s %s %s %lu :is online",user->nick,a->nick,a->ident,a->dhost,a->age);
using namespace std;
#include "inspircd_config.h"
-#include "inspircd.h"
#include "configreader.h"
#include <unistd.h>
#include <fcntl.h>
#include "hashcomp.h"
#include "socketengine.h"
#include "userprocess.h"
+#include "inspircd.h"
#include "typedefs.h"
#include "command_parse.h"
#include "cull_list.h"
if (current->lines_in > current->flood)
{
log(DEFAULT,"Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
- WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
+ this->WriteOpers("*** Excess flood from: %s!%s@%s",current->nick,current->ident,current->host);
userrec::QuitUser(this, current,"Excess flood");
return;
}
}
else
{
- WriteOpers("*** Excess flood from %s",current->GetIPString());
+ this->WriteOpers("*** Excess flood from %s",current->GetIPString());
log(DEFAULT,"Excess flood from: %s",current->GetIPString());
add_zline(120,this->Config->ServerName,"Flood from unregistered connection",current->GetIPString());
apply_lines(APPLY_ZLINES);
}
else
{
- WriteOpers("*** Excess flood from %s",current->GetIPString());
+ this->WriteOpers("*** Excess flood from %s",current->GetIPString());
log(DEFAULT,"Excess flood from: %s",current->GetIPString());
add_zline(120,this->Config->ServerName,"Flood from unregistered connection",current->GetIPString());
apply_lines(APPLY_ZLINES);
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;
}
if (user->registered == REG_ALL)
{
- purge_empty_chans(user);
+ user->PurgeEmptyChannels();
FOREACH_MOD_I(Instance,I_OnUserQuit,OnUserQuit(user,reason));
user->WriteCommonExcept("QUIT :%s",reason.c_str());
}
}
/*
- * 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();
}
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;
}
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()
}
+/* 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();
+}
+
while ((glines.size()) && (current > (glines.begin()->duration + glines.begin()->set_time)))
{
std::vector<GLine>::iterator i = glines.begin();
- WriteOpers("*** Expiring timed G-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+ ServerInstance->WriteOpers("*** Expiring timed G-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
glines.erase(i);
}
while ((elines.size()) && (current > (elines.begin()->duration + elines.begin()->set_time)))
{
std::vector<ELine>::iterator i = elines.begin();
- WriteOpers("*** Expiring timed E-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+ ServerInstance->WriteOpers("*** Expiring timed E-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
elines.erase(i);
}
while ((zlines.size()) && (current > (zlines.begin()->duration + zlines.begin()->set_time)))
{
std::vector<ZLine>::iterator i = zlines.begin();
- WriteOpers("*** Expiring timed Z-Line %s (set by %s %d seconds ago)",i->ipaddr,i->source,i->duration);
+ ServerInstance->WriteOpers("*** Expiring timed Z-Line %s (set by %s %d seconds ago)",i->ipaddr,i->source,i->duration);
zlines.erase(i);
}
while ((klines.size()) && (current > (klines.begin()->duration + klines.begin()->set_time)))
{
std::vector<KLine>::iterator i = klines.begin();
- WriteOpers("*** Expiring timed K-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
+ ServerInstance->WriteOpers("*** Expiring timed K-Line %s (set by %s %d seconds ago)",i->hostmask,i->source,i->duration);
klines.erase(i);
}
while ((qlines.size()) && (current > (qlines.begin()->duration + qlines.begin()->set_time)))
{
std::vector<QLine>::iterator i = qlines.begin();
- WriteOpers("*** Expiring timed Q-Line %s (set by %s %d seconds ago)",i->nick,i->source,i->duration);
+ ServerInstance->WriteOpers("*** Expiring timed Q-Line %s (set by %s %d seconds ago)",i->nick,i->source,i->duration);
qlines.erase(i);
}
projects / user / henk / code / inspircd.git / commitdiff