* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
+ * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
* E-mail:
* <brain@chatspike.net>
* <Craig@chatspike.net>
extern std::vector<userrec*> local_users;
extern time_t TIME;
class Server;
-extern userrec* fd_ref_table[65536];
+extern userrec* fd_ref_table[MAX_DESCRIPTORS];
extern user_hash clientlist;
extern chan_hash chanlist;
void Module::OnUserQuit(userrec* user, std::string message) { }
void Module::OnUserDisconnect(userrec* user) { }
void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-void Module::OnUserPart(userrec* user, chanrec* channel) { }
+void Module::OnUserPart(userrec* user, chanrec* channel, std::string partmessage) { }
void Module::OnRehash(std::string parameter) { }
void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
void Module::OnMode(userrec* user, void* dest, int target_type, std::string text) { };
Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
void Module::OnOper(userrec* user, std::string opertype) { };
+void Module::OnPostOper(userrec* user, std::string opertype) { };
void Module::OnInfo(userrec* user) { };
void Module::OnWhois(userrec* source, userrec* dest) { };
int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
-int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
-int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text,char status) { return 0; };
+int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text,char status) { return 0; };
int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
void Module::OnUserPostNick(userrec* user, std::string oldnick) { };
int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; };
void Module::OnRawSocketClose(int fd) { };
int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; };
-void Module::OnUserMessage(userrec* user, void* dest, int target_type, std::string text) { };
-void Module::OnUserNotice(userrec* user, void* dest, int target_type, std::string text) { };
+void Module::OnUserMessage(userrec* user, void* dest, int target_type, std::string text, char status) { };
+void Module::OnUserNotice(userrec* user, void* dest, int target_type, std::string text, char status) { };
void Module::OnRemoteKill(userrec* source, userrec* dest, std::string reason) { };
void Module::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { };
void Module::OnPostLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { };
void Module::ProtoSendMode(void* opaque, int target_type, void* target, std::string modeline) { };
void Module::OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, std::string extname) { };
void Module::OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, std::string extname) { };
+void Module::OnSyncOtherMetaData(Module* proto, void* opaque) { };
void Module::OnDecodeMetaData(int target_type, void* target, std::string extname, std::string extdata) { };
void Module::ProtoSendMetaData(void* opaque, int target_type, void* target, std::string extname, std::string extdata) { };
void Module::OnWallops(userrec* user, std::string text) { };
void Module::OnDelELine(userrec* source, std::string hostmask) { };
void Module::OnCleanup(int target_type, void* item) { };
void Module::Implements(char* Implements) { for (int j = 0; j < 255; j++) Implements[j] = 0; };
-Priority Modules::Prioritize() { return PRIORITY_DONTCARE; }
+void Module::OnChannelDelete(chanrec* chan) { };
+Priority Module::Prioritize() { return PRIORITY_DONTCARE; }
+void Module::OnSetAway(userrec* user) { };
+void Module::OnCancelAway(userrec* user) { };
/* server is a wrapper class that provides methods to all of the C-style
* exports in the core
module_sockets.push_back(sock);
}
+void Server::RemoveSocket(InspSocket* sock)
+{
+ for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
+ {
+ InspSocket* s = (InspSocket*)*a;
+ if (s == sock)
+ {
+ log(DEBUG,"Forcibly removed socket");
+ ServerInstance->SE->DelFd(s->GetFd());
+ s->Close();
+ module_sockets.erase(a);
+ delete s;
+ return;
+ }
+ }
+}
+
+long Server::PriorityAfter(std::string modulename)
+{
+ for (unsigned int j = 0; j < Config->module_names.size(); j++)
+ {
+ if (Config->module_names[j] == modulename)
+ {
+ return ((j << 8) | PRIORITY_AFTER);
+ }
+ }
+ return PRIORITY_DONTCARE;
+}
+
+long Server::PriorityBefore(std::string modulename)
+{
+ for (unsigned int j = 0; j < Config->module_names.size(); j++)
+ {
+ if (Config->module_names[j] == modulename)
+ {
+ return ((j << 8) | PRIORITY_BEFORE);
+ }
+ }
+ return PRIORITY_DONTCARE;
+}
+
void Server::RehashServer()
{
WriteOpers("*** Rehashing config file");
}
}
+long Server::GetChannelCount()
+{
+ return (long)chanlist.size();
+}
+
+/* This is ugly, yes, but hash_map's arent designed to be
+ * addressed in this manner, and this is a bit of a kludge.
+ * Luckily its a specialist function and rarely used by
+ * many modules (in fact, it was specially created to make
+ * m_safelist possible, initially).
+ */
+
+chanrec* Server::GetChannelIndex(long index)
+{
+ int target = 0;
+ for (chan_hash::iterator n = chanlist.begin(); n != chanlist.end(); n++, target++)
+ {
+ if (index == target)
+ return n->second;
+ }
+ return NULL;
+}
+
+void Server::AddTimer(InspTimer* T)
+{
+ ::AddTimer(T);
+}
+
void Server::SendOpers(std::string s)
{
WriteOpers("%s",s.c_str());
{
chanuserlist userl;
userl.clear();
- std::vector<char*> *list = chan->GetUsers();
- for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++)
- {
- char* o = *i;
- userl.push_back((userrec*)o);
- }
+ CUList *list = chan->GetUsers();
+ for (CUList::iterator i = list->begin(); i != list->end(); i++)
+ userl.push_back(i->second);
return userl;
}
void Server::ChangeUserNick(userrec* user, std::string nickname)
force_nickchange(user,nickname.c_str());
}
+void Server::KickUser(userrec* source, userrec* target, chanrec* chan, std::string reason)
+{
+ if (source)
+ {
+ kick_channel(source,target,chan,(char*)reason.c_str());
+ }
+ else
+ {
+ server_kick_channel(target,chan,(char*)reason.c_str(),true);
+ }
+}
+
void Server::QuitUser(userrec* user, std::string reason)
{
kill_link(user,reason.c_str());
return is_uline(server.c_str());
}
-void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+bool Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
{
- ServerInstance->Parser->CallHandler(commandname,parameters,pcnt,user);
+ return ServerInstance->Parser->CallHandler(commandname,parameters,pcnt,user);
}
bool Server::IsValidModuleCommand(std::string commandname, int pcnt, userrec* user)
void Server::AddCommand(command_t *f)
{
- ServerInstance->Parser->CreateCommand(f);
+ if (!ServerInstance->Parser->CreateCommand(f))
+ {
+ ModuleException err("Command "+std::string(f->command)+" already exists.");
+ throw (err);
+ }
}
void Server::SendMode(char **parameters, int pcnt, userrec *user)
if (!Source)
{
// if source is NULL, then the message originates from the local server
- Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+ WriteServ_NoFormat(Dest->fd,s.c_str());
}
else
{
}
else
{
- ChanExceptSender_NoFormat(Channel,User,s.c_str());
+ ChanExceptSender_NoFormat(Channel,User,0,s.c_str());
}
}
return (common_channels(u1,u2) != 0);
}
+void Server::DumpText(userrec* User, std::string LinePrefix, stringstream &TextStream)
+{
+ std::string CompleteLine = LinePrefix;
+ std::string Word = "";
+ while (TextStream >> Word)
+ {
+ if (CompleteLine.length() + Word.length() + 3 > 500)
+ {
+ WriteServ_NoFormat(User->fd,CompleteLine.c_str());
+ CompleteLine = LinePrefix;
+ }
+ CompleteLine = CompleteLine + Word + " ";
+ }
+ WriteServ_NoFormat(User->fd,CompleteLine.c_str());
+}
+
void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
{
if (IncludeSender)
return cmode(User,Chan);
}
-bool Server::IsOnChannel(userrec* User, chanrec* Chan)
-{
- return has_channel(User,Chan);
-}
-
std::string Server::GetServerName()
{
return Config->ServerName;
{
if (type == MT_SERVER)
{
- log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
+ ModuleException e("Modes of type MT_SERVER are reserved for future expansion");
+ throw(e);
return false;
}
if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
{
- log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
+ ModuleException e("Parameters on MT_CLIENT modes are not supported");
+ throw(e);
return false;
}
if ((params_when_on>1) || (params_when_off>1))
{
- log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
+ ModuleException e("More than one parameter for an MT_CHANNEL mode is not yet supported");
+ throw(e);
return false;
}
return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
}
else
{
- log(DEBUG,"*** API ERROR *** Muppet modechar detected.");
+ ModuleException e("Muppet modechar detected.");
+ throw(e);
}
return false;
}
alive->fd = FD_MAGIC_NUMBER;
alive->FlushWriteBuf();
alive->ClearBuffer();
- Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick);
+ // save these for later
+ std::string oldnick = alive->nick;
+ std::string oldhost = alive->host;
+ std::string oldident = alive->ident;
kill_link(alive,message.c_str());
-
if (find(local_users.begin(),local_users.end(),alive) != local_users.end())
{
local_users.erase(find(local_users.begin(),local_users.end(),alive));
log(DEBUG,"Delete local user");
}
-
+ // Fix by brain - cant write the user until their fd table entry is updated
fd_ref_table[zombie->fd] = zombie;
+ Write(zombie->fd,":%s!%s@%s NICK %s",oldnick.c_str(),oldident.c_str(),oldhost.c_str(),zombie->nick);
for (unsigned int i = 0; i < zombie->chans.size(); i++)
{
if (zombie->chans[i].channel != NULL)
bool Server::IsValidMask(std::string mask)
{
- const char* dest = mask.c_str();
+ char* dest = (char*)mask.c_str();
if (strchr(dest,'!')==0)
return false;
if (strchr(dest,'@')==0)
return false;
- for (unsigned int i = 0; i < strlen(dest); i++)
- if (dest[i] < 32)
+ for (char* i = dest; *i; i++)
+ if (*i < 32)
return false;
- for (unsigned int i = 0; i < strlen(dest); i++)
- if (dest[i] > 126)
+ for (char* i = dest; *i; i++)
+ if (*i > 126)
return false;
unsigned int c = 0;
- for (unsigned int i = 0; i < strlen(dest); i++)
- if (dest[i] == '!')
+ for (char* i = dest; *i; i++)
+ if (*i == '!')
c++;
if (c>1)
return false;
c = 0;
- for (unsigned int i = 0; i < strlen(dest); i++)
- if (dest[i] == '@')
+ for (char* i = dest; *i; i++)
+ if (*i == '@')
c++;
if (c>1)
return false;
this->error = CONF_VALUE_NOT_FOUND;
return 0;
}
- for (unsigned int i = 0; i < strlen(val); i++)
+ for (char* i = val; *i; i++)
{
- if (!isdigit(val[i]))
+ if (!isdigit(*i))
{
this->error = CONF_NOT_A_NUMBER;
return 0;