* | 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<Module*> modules;
extern std::vector<ircd_module*> factory;
extern std::vector<InspSocket*> module_sockets;
+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::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
-void Module::OnStats(char symbol) { };
+int Module::OnStats(char symbol, userrec* user) { return 0; };
int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
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; };
+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++)
+ std::map<char*,char*> *list = chan->GetUsers();
+ for (std::map<char*,char*>::iterator i = list->begin(); i != list->end(); i++)
{
- char* o = *i;
+ char* o = i->second;
userl.push_back((userrec*)o);
}
return userl;
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());
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)
void Server::Send(int Socket, std::string s)
{
- Write(Socket,"%s",s.c_str());
+ Write_NoFormat(Socket,s.c_str());
}
void Server::SendServ(int Socket, std::string s)
{
- WriteServ(Socket,"%s",s.c_str());
+ WriteServ_NoFormat(Socket,s.c_str());
}
void Server::SendFrom(int Socket, userrec* User, std::string s)
{
- WriteFrom(Socket,User,"%s",s.c_str());
+ WriteFrom_NoFormat(Socket,User,s.c_str());
}
void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
else
{
// otherwise it comes from the user specified
- WriteTo(Source,Dest,"%s",s.c_str());
+ WriteTo_NoFormat(Source,Dest,s.c_str());
}
}
void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text)
{
- WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str());
+ WriteChannelWithServ_NoFormat((char*)ServName.c_str(), Channel, text.c_str());
}
void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
{
if (IncludeSender)
{
- WriteChannel(Channel,User,"%s",s.c_str());
+ WriteChannel_NoFormat(Channel,User,s.c_str());
}
else
{
- ChanExceptSender(Channel,User,"%s",s.c_str());
+ ChanExceptSender_NoFormat(Channel,User,0,s.c_str());
}
}
{
if (IncludeSender)
{
- WriteCommon(User,"%s",text.c_str());
+ WriteCommon_NoFormat(User,text.c_str());
}
else
{
- WriteCommonExcept(User,"%s",text.c_str());
+ WriteCommonExcept_NoFormat(User,text.c_str());
}
}
{
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;
}
bool Server::UserToPseudo(userrec* user,std::string message)
{
unsigned int old_fd = user->fd;
- user->fd = FD_MAGIC_NUMBER;
- user->ClearBuffer();
Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
+ user->FlushWriteBuf();
+ user->ClearBuffer();
+ user->fd = FD_MAGIC_NUMBER;
+
+ if (find(local_users.begin(),local_users.end(),user) != local_users.end())
+ {
+ local_users.erase(find(local_users.begin(),local_users.end(),user));
+ log(DEBUG,"Delete local user");
+ }
+
ServerInstance->SE->DelFd(old_fd);
shutdown(old_fd,2);
close(old_fd);
bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message)
{
+ log(DEBUG,"PseudoToUser");
zombie->fd = alive->fd;
+ FOREACH_MOD(I_OnUserQuit,OnUserQuit(alive,message));
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)
}
}
}
+ if ((find(local_users.begin(),local_users.end(),zombie) == local_users.end()) && (zombie->fd != FD_MAGIC_NUMBER))
+ local_users.push_back(zombie);
+
return true;
}
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;
projects / user / henk / code / inspircd.git / blobdiff