Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

modules.cpp

Go to the documentation of this file.
00001 #include "inspircd.h"
00002 #include "inspircd_io.h"
00003 #include "inspircd_util.h"
00004 #include "inspircd_config.h"
00005 #include <unistd.h>
00006 #include <fcntl.h>
00007 #include <sys/errno.h>
00008 #include <sys/ioctl.h>
00009 #include <sys/utsname.h>
00010 #include <cstdio>
00011 #include <time.h>
00012 #include <string>
00013 #ifdef GCC3
00014 #include <ext/hash_map>
00015 #else
00016 #include <hash_map>
00017 #endif
00018 #include <map>
00019 #include <sstream>
00020 #include <vector>
00021 #include <errno.h>
00022 #include <deque>
00023 #include <errno.h>
00024 #include <unistd.h>
00025 #include <sched.h>
00026 #include "connection.h"
00027 #include "users.h"
00028 #include "servers.h"
00029 #include "ctables.h"
00030 #include "globals.h"
00031 #include "modules.h"
00032 #include "dynamic.h"
00033 #include "wildcard.h"
00034 #include "message.h"
00035 #include "mode.h"
00036 #include "xline.h"
00037 #include "commands.h"
00038 
00039 #ifdef GCC3
00040 #define nspace __gnu_cxx
00041 #else
00042 #define nspace std
00043 #endif
00044 
00045 using namespace std;
00046 
00047 extern int MODCOUNT;
00048 extern vector<Module*> modules;
00049 extern vector<ircd_module*> factory;
00050 
00051 extern int LogLevel;
00052 extern char ServerName[MAXBUF];
00053 extern char Network[MAXBUF];
00054 extern char ServerDesc[MAXBUF];
00055 extern char AdminName[MAXBUF];
00056 extern char AdminEmail[MAXBUF];
00057 extern char AdminNick[MAXBUF];
00058 extern char diepass[MAXBUF];
00059 extern char restartpass[MAXBUF];
00060 extern char motd[MAXBUF];
00061 extern char rules[MAXBUF];
00062 extern char list[MAXBUF];
00063 extern char PrefixQuit[MAXBUF];
00064 extern char DieValue[MAXBUF];
00065 
00066 extern int debugging;
00067 extern int WHOWAS_STALE;
00068 extern int WHOWAS_MAX;
00069 extern int DieDelay;
00070 extern time_t startup_time;
00071 extern int NetBufferSize;
00072 extern int MaxWhoResults;
00073 extern time_t nb_start;
00074 
00075 extern std::vector<int> fd_reap;
00076 extern std::vector<std::string> module_names;
00077 
00078 extern char bannerBuffer[MAXBUF];
00079 extern int boundPortCount;
00080 extern int portCount;
00081 extern int UDPportCount;
00082 extern int ports[MAXSOCKS];
00083 extern int defaultRoute;
00084 
00085 extern std::vector<long> auth_cookies;
00086 extern std::stringstream config_f;
00087 
00088 extern serverrec* me[32];
00089 
00090 extern FILE *log_file;
00091 
00092 
00093 namespace nspace
00094 {
00095         template<> struct nspace::hash<in_addr>
00096         {
00097                 size_t operator()(const struct in_addr &a) const
00098                 {
00099                         size_t q;
00100                         memcpy(&q,&a,sizeof(size_t));
00101                         return q;
00102                 }
00103         };
00104 
00105         template<> struct nspace::hash<string>
00106         {
00107                 size_t operator()(const string &s) const
00108                 {
00109                         char a[MAXBUF];
00110                         static struct hash<const char *> strhash;
00111                         strcpy(a,s.c_str());
00112                         strlower(a);
00113                         return strhash(a);
00114                 }
00115         };
00116 }       
00117 
00118 
00119 struct StrHashComp
00120 {
00121 
00122         bool operator()(const string& s1, const string& s2) const
00123         {
00124                 char a[MAXBUF],b[MAXBUF];
00125                 strcpy(a,s1.c_str());
00126                 strcpy(b,s2.c_str());
00127                 return (strcasecmp(a,b) == 0);
00128         }
00129 
00130 };
00131 
00132 struct InAddr_HashComp
00133 {
00134 
00135         bool operator()(const in_addr &s1, const in_addr &s2) const
00136         {
00137                 size_t q;
00138                 size_t p;
00139                 
00140                 memcpy(&q,&s1,sizeof(size_t));
00141                 memcpy(&p,&s2,sizeof(size_t));
00142                 
00143                 return (q == p);
00144         }
00145 
00146 };
00147 
00148 
00149 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
00150 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
00151 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
00152 typedef std::deque<command_t> command_table;
00153 
00154 
00155 extern user_hash clientlist;
00156 extern chan_hash chanlist;
00157 extern user_hash whowas;
00158 extern command_table cmdlist;
00159 extern file_cache MOTD;
00160 extern file_cache RULES;
00161 extern address_cache IP;
00162 
00163 
00164 // class type for holding an extended mode character - internal to core
00165 
00166 class ExtMode : public classbase
00167 {
00168 public:
00169         char modechar;
00170         int type;
00171         int params_when_on;
00172         int params_when_off;
00173         bool needsoper;
00174         bool list;
00175         ExtMode(char mc, int ty, bool oper, int p_on, int p_off) : modechar(mc), type(ty), needsoper(oper), params_when_on(p_on), params_when_off(p_off) { };
00176 };                                     
00177 
00178 typedef std::vector<ExtMode> ExtModeList;
00179 typedef ExtModeList::iterator ExtModeListIter;
00180 
00181 
00182 ExtModeList EMode;
00183 
00184 // returns true if an extended mode character is in use
00185 bool ModeDefined(char modechar, int type)
00186 {
00187         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
00188         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00189         {
00190                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
00191                 if ((i->modechar == modechar) && (i->type == type))
00192                 {
00193                         return true;
00194                 }
00195         }
00196         return false;
00197 }
00198 
00199 bool ModeIsListMode(char modechar, int type)
00200 {
00201         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
00202         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00203         {
00204                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
00205                 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
00206                 {
00207                         return true;
00208                 }
00209         }
00210         return false;
00211 }
00212 
00213 bool ModeDefinedOper(char modechar, int type)
00214 {
00215         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
00216         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00217         {
00218                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
00219                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
00220                 {
00221                         return true;
00222                 }
00223         }
00224         return false;
00225 }
00226 
00227 // returns number of parameters for a custom mode when it is switched on
00228 int ModeDefinedOn(char modechar, int type)
00229 {
00230         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00231         {
00232                 if ((i->modechar == modechar) && (i->type == type))
00233                 {
00234                         return i->params_when_on;
00235                 }
00236         }
00237         return 0;
00238 }
00239 
00240 // returns number of parameters for a custom mode when it is switched on
00241 int ModeDefinedOff(char modechar, int type)
00242 {
00243         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00244         {
00245                 if ((i->modechar == modechar) && (i->type == type))
00246                 {
00247                         return i->params_when_off;
00248                 }
00249         }
00250         return 0;
00251 }
00252 
00253 // returns true if an extended mode character is in use
00254 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
00255 {
00256         if (ModeDefined(modechar,type)) {
00257                 return false;
00258         }
00259         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
00260         return true;
00261 }
00262 
00263 // turns a mode into a listmode
00264 void ModeMakeList(char modechar)
00265 {
00266         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00267         {
00268                 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
00269                 {
00270                         i->list = true;
00271                         return;
00272                 }
00273         }
00274         return;
00275 }
00276 
00277 // version is a simple class for holding a modules version number
00278 
00279 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
00280 
00281 // admin is a simple class for holding a server's administrative info
00282 
00283 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
00284 
00285 Module::Module() { }
00286 Module::~Module() { }
00287 void Module::OnUserConnect(userrec* user) { }
00288 void Module::OnUserQuit(userrec* user) { }
00289 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
00290 void Module::OnUserPart(userrec* user, chanrec* channel) { }
00291 void Module::OnPacketTransmit(char *p) { }
00292 void Module::OnPacketReceive(char *p) { }
00293 void Module::OnRehash() { }
00294 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
00295 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
00296 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { return false; }
00297 Version Module::GetVersion() { return Version(1,0,0,0); }
00298 void Module::OnOper(userrec* user) { };
00299 void Module::OnInfo(userrec* user) { };
00300 void Module::OnWhois(userrec* source, userrec* dest) { };
00301 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; };
00302 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; };
00303 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
00304 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
00305 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
00306 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
00307 
00308 
00309 // server is a wrapper class that provides methods to all of the C-style
00310 // exports in the core
00311 //
00312 
00313 Server::Server()
00314 {
00315 }
00316 
00317 Server::~Server()
00318 {
00319 }
00320 
00321 void Server::SendOpers(std::string s)
00322 {
00323         WriteOpers("%s",s.c_str());
00324 }
00325 
00326 bool Server::MatchText(std::string sliteral, std::string spattern)
00327 {
00328         char literal[MAXBUF],pattern[MAXBUF];
00329         strncpy(literal,sliteral.c_str(),MAXBUF);
00330         strncpy(pattern,spattern.c_str(),MAXBUF);
00331         return match(literal,pattern);
00332 }
00333 
00334 void Server::SendToModeMask(std::string modes, int flags, std::string text)
00335 {
00336         WriteMode(modes.c_str(),flags,"%s",text.c_str());
00337 }
00338 
00339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
00340 {
00341         return add_channel(user,cname.c_str(),key.c_str(),true);
00342 }
00343 
00344 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
00345 {
00346         return del_channel(user,cname.c_str(),reason.c_str(),false);
00347 }
00348 
00349 chanuserlist Server::GetUsers(chanrec* chan)
00350 {
00351         chanuserlist userl;
00352         userl.clear();
00353         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
00354         {
00355                 if (i->second)
00356                 {
00357                         if (has_channel(i->second,chan))
00358                         {
00359                                 if (isnick(i->second->nick))
00360                                 {
00361                                         userl.push_back(i->second);
00362                                 }
00363                         }
00364                 }
00365         }
00366         return userl;
00367 }
00368 void Server::ChangeUserNick(userrec* user, std::string nickname)
00369 {
00370         force_nickchange(user,nickname.c_str());
00371 }
00372 
00373 void Server::QuitUser(userrec* user, std::string reason)
00374 {
00375         send_network_quit(user->nick,reason.c_str());
00376         kill_link(user,reason.c_str());
00377 }
00378 
00379 bool Server::IsUlined(std::string server)
00380 {
00381         return is_uline(server.c_str());
00382 }
00383 
00384 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
00385 {
00386         call_handler(commandname.c_str(),parameters,pcnt,user);
00387 }
00388 
00389 void Server::Log(int level, std::string s)
00390 {
00391         log(level,"%s",s.c_str());
00392 }
00393 
00394 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
00395 {
00396         createcommand(cmd,f,flags,minparams);
00397 }
00398 
00399 void Server::SendMode(char **parameters, int pcnt, userrec *user)
00400 {
00401         server_mode(parameters,pcnt,user);
00402 }
00403 
00404 void Server::Send(int Socket, std::string s)
00405 {
00406         Write(Socket,"%s",s.c_str());
00407 }
00408 
00409 void Server::SendServ(int Socket, std::string s)
00410 {
00411         WriteServ(Socket,"%s",s.c_str());
00412 }
00413 
00414 void Server::SendFrom(int Socket, userrec* User, std::string s)
00415 {
00416         WriteFrom(Socket,User,"%s",s.c_str());
00417 }
00418 
00419 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
00420 {
00421         if (!Source)
00422         {
00423                 // if source is NULL, then the message originates from the local server
00424                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
00425         }
00426         else
00427         {
00428                 // otherwise it comes from the user specified
00429                 WriteTo(Source,Dest,"%s",s.c_str());
00430         }
00431 }
00432 
00433 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
00434 {
00435         if (IncludeSender)
00436         {
00437                 WriteChannel(Channel,User,"%s",s.c_str());
00438         }
00439         else
00440         {
00441                 ChanExceptSender(Channel,User,"%s",s.c_str());
00442         }
00443 }
00444 
00445 bool Server::CommonChannels(userrec* u1, userrec* u2)
00446 {
00447         return (common_channels(u1,u2) != 0);
00448 }
00449 
00450 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
00451 {
00452         if (IncludeSender)
00453         {
00454                 WriteCommon(User,"%s",text.c_str());
00455         }
00456         else
00457         {
00458                 WriteCommonExcept(User,"%s",text.c_str());
00459         }
00460 }
00461 
00462 void Server::SendWallops(userrec* User, std::string text)
00463 {
00464         WriteWallOps(User,false,"%s",text.c_str());
00465 }
00466 
00467 void Server::ChangeHost(userrec* user, std::string host)
00468 {
00469         ChangeDisplayedHost(user,host.c_str());
00470 }
00471 
00472 void Server::ChangeGECOS(userrec* user, std::string gecos)
00473 {
00474         ChangeName(user,gecos.c_str());
00475 }
00476 
00477 bool Server::IsNick(std::string nick)
00478 {
00479         return (isnick(nick.c_str()) != 0);
00480 }
00481 
00482 userrec* Server::FindNick(std::string nick)
00483 {
00484         return Find(nick);
00485 }
00486 
00487 chanrec* Server::FindChannel(std::string channel)
00488 {
00489         return FindChan(channel.c_str());
00490 }
00491 
00492 std::string Server::ChanMode(userrec* User, chanrec* Chan)
00493 {
00494         return cmode(User,Chan);
00495 }
00496 
00497 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
00498 {
00499         return has_channel(User,Chan);
00500 }
00501 
00502 std::string Server::GetServerName()
00503 {
00504         return getservername();
00505 }
00506 
00507 std::string Server::GetNetworkName()
00508 {
00509         return getnetworkname();
00510 }
00511 
00512 Admin Server::GetAdmin()
00513 {
00514         return Admin(getadminname(),getadminemail(),getadminnick());
00515 }
00516 
00517 
00518 
00519 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
00520 {
00521         if (type == MT_SERVER)
00522         {
00523                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
00524                 return false;
00525         }
00526         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
00527         {
00528                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
00529                 return false;
00530         }
00531         if ((params_when_on>1) || (params_when_off>1))
00532         {
00533                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
00534                 return false;
00535         }
00536         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
00537 }
00538 
00539 bool Server::AddExtendedListMode(char modechar)
00540 {
00541         bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
00542         if (res)
00543                 ModeMakeList(modechar);
00544         return res;
00545 }
00546 
00547 int Server::CountUsers(chanrec* c)
00548 {
00549         return usercount(c);
00550 }
00551 
00552 
00553 ConfigReader::ConfigReader()
00554 {
00555         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
00556         this->readerror = LoadConf(CONFIG_FILE,this->cache);
00557         if (!this->readerror)
00558                 this->error = CONF_FILE_NOT_FOUND;
00559 }
00560 
00561 
00562 ConfigReader::~ConfigReader()
00563 {
00564         if (this->cache)
00565                 delete this->cache;
00566 }
00567 
00568 
00569 ConfigReader::ConfigReader(std::string filename)
00570 {
00571         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
00572         this->readerror = LoadConf(filename.c_str(),this->cache);
00573         if (!this->readerror)
00574                 this->error = CONF_FILE_NOT_FOUND;
00575 };
00576 
00577 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
00578 {
00579         char val[MAXBUF];
00580         char t[MAXBUF];
00581         char n[MAXBUF];
00582         strncpy(t,tag.c_str(),MAXBUF);
00583         strncpy(n,name.c_str(),MAXBUF);
00584         int res = ReadConf(cache,t,n,index,val);
00585         if (!res)
00586         {
00587                 this->error = CONF_VALUE_NOT_FOUND;
00588                 return "";
00589         }
00590         return std::string(val);
00591 }
00592 
00593 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
00594 {
00595         char val[MAXBUF];
00596         char t[MAXBUF];
00597         char n[MAXBUF];
00598         strncpy(t,tag.c_str(),MAXBUF);
00599         strncpy(n,name.c_str(),MAXBUF);
00600         int res = ReadConf(cache,t,n,index,val);
00601         if (!res)
00602         {
00603                 this->error = CONF_VALUE_NOT_FOUND;
00604                 return false;
00605         }
00606         std::string s = val;
00607         return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
00608 }
00609 
00610 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
00611 {
00612         char val[MAXBUF];
00613         char t[MAXBUF];
00614         char n[MAXBUF];
00615         strncpy(t,tag.c_str(),MAXBUF);
00616         strncpy(n,name.c_str(),MAXBUF);
00617         int res = ReadConf(cache,t,n,index,val);
00618         if (!res)
00619         {
00620                 this->error = CONF_VALUE_NOT_FOUND;
00621                 return 0;
00622         }
00623         for (int i = 0; i < strlen(val); i++)
00624         {
00625                 if (!isdigit(val[i]))
00626                 {
00627                         this->error = CONF_NOT_A_NUMBER;
00628                         return 0;
00629                 }
00630         }
00631         if ((needs_unsigned) && (atoi(val)<0))
00632         {
00633                 this->error = CONF_NOT_UNSIGNED;
00634                 return 0;
00635         }
00636         return atoi(val);
00637 }
00638 
00639 long ConfigReader::GetError()
00640 {
00641         long olderr = this->error;
00642         this->error = 0;
00643         return olderr;
00644 }
00645 
00646 
00647 int ConfigReader::Enumerate(std::string tag)
00648 {
00649         return EnumConf(cache,tag.c_str());
00650 }
00651 
00652 int ConfigReader::EnumerateValues(std::string tag, int index)
00653 {
00654         return EnumValues(cache, tag.c_str(), index);
00655 }
00656 
00657 bool ConfigReader::Verify()
00658 {
00659         return this->readerror;
00660 }
00661 
00662 
00663 FileReader::FileReader(std::string filename)
00664 {
00665         file_cache c;
00666         readfile(c,filename.c_str());
00667         this->fc = c;
00668 }
00669 
00670 FileReader::FileReader()
00671 {
00672 }
00673 
00674 void FileReader::LoadFile(std::string filename)
00675 {
00676         file_cache c;
00677         readfile(c,filename.c_str());
00678         this->fc = c;
00679 }
00680 
00681 
00682 FileReader::~FileReader()
00683 {
00684 }
00685 
00686 bool FileReader::Exists()
00687 {
00688         if (fc.size() == 0)
00689         {
00690                 return(false);
00691         }
00692         else
00693         {
00694                 return(true);
00695         }
00696 }
00697 
00698 std::string FileReader::GetLine(int x)
00699 {
00700         if ((x<0) || (x>fc.size()))
00701                 return "";
00702         return fc[x];
00703 }
00704 
00705 int FileReader::FileSize()
00706 {
00707         return fc.size();
00708 }
00709 
00710 
00711 std::vector<Module*> modules(255);
00712 std::vector<ircd_module*> factory(255);
00713 
00714 int MODCOUNT  = -1;
00715 
00716 

Generated on Sun May 2 00:09:18 2004 for InspIRCd by doxygen1.3-rc3