00001
-00002
-00003
-00004
-00005
-00006
-00007
-00008 #include <typeinfo>
-00009 #include <iostream>
-00010 #include "globals.h"
-00011 #include "modules.h"
-00012 #include "ctables.h"
-00013 #include "inspircd_io.h"
-00014 #include "wildcard.h"
-00015 #include "mode.h"
-00016 #include "message.h"
-00017 #include "commands.h"
-00018
-00019
-00020
-00021 class ExtMode : public classbase
-00022 {
-00023 public:
-00024 char modechar;
-00025 int type;
-00026 int params_when_on;
-00027 int params_when_off;
-00028 bool needsoper;
-00029 bool list;
-00030 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) { };
-00031 };
-00032
-00033 typedef std::vector<ExtMode> ExtModeList;
-00034 typedef ExtModeList::iterator ExtModeListIter;
-00035
-00036 ExtModeList EMode;
-00037
-00038
-00039 bool ModeDefined(char modechar, int type)
-00040 {
-00041 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00042 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00043 {
-00044 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00045 if ((i->modechar == modechar) && (i->type == type))
-00046 {
-00047 return true;
-00048 }
-00049 }
-00050 return false;
-00051 }
-00052
-00053 bool ModeIsListMode(char modechar, int type)
-00054 {
-00055 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00056 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00057 {
-00058 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00059 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
-00060 {
-00061 return true;
-00062 }
-00063 }
-00064 return false;
-00065 }
-00066
-00067 bool ModeDefinedOper(char modechar, int type)
-00068 {
-00069 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00070 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00071 {
-00072 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
-00073 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
-00074 {
-00075 return true;
-00076 }
-00077 }
-00078 return false;
-00079 }
-00080
-00081
-00082 int ModeDefinedOn(char modechar, int type)
-00083 {
-00084 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00085 {
-00086 if ((i->modechar == modechar) && (i->type == type))
-00087 {
-00088 return i->params_when_on;
-00089 }
-00090 }
-00091 return 0;
-00092 }
-00093
-00094
-00095 int ModeDefinedOff(char modechar, int type)
-00096 {
-00097 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00098 {
-00099 if ((i->modechar == modechar) && (i->type == type))
-00100 {
-00101 return i->params_when_off;
+
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 return 0;
-00105 }
-00106
-00107
-00108 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
-00109 {
-00110 if (ModeDefined(modechar,type)) {
-00111 return false;
-00112 }
-00113 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
-00114 return true;
-00115 }
-00116
-00117
-00118 void ModeMakeList(char modechar)
-00119 {
-00120 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00121 {
-00122 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
-00123 {
-00124 i->list = true;
-00125 return;
-00126 }
-00127 }
-00128 return;
-00129 }
-00130
-00131
-00132
-00133 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+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
-00136
-00137 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
-00138
-00139 Module::Module() { }
-00140 Module::~Module() { }
-00141 void Module::OnUserConnect(userrec* user) { }
-00142 void Module::OnUserQuit(userrec* user) { }
-00143 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-00144 void Module::OnUserPart(userrec* user, chanrec* channel) { }
-00145 void Module::OnPacketTransmit(char *p) { }
-00146 void Module::OnPacketReceive(char *p) { }
-00147 void Module::OnRehash() { }
-00148 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
-00149 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
-00150 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; }
-00151 Version Module::GetVersion() { return Version(1,0,0,0); }
-00152 void Module::OnOper(userrec* user) { };
-00153 void Module::OnInfo(userrec* user) { };
-00154 void Module::OnWhois(userrec* source, userrec* dest) { };
-00155 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; };
-00156 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; };
-00157 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
-00158 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
-00159
-00160
-00161
-00162
+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 Server::Server()
-00165 {
-00166 }
-00167
-00168 Server::~Server()
-00169 {
-00170 }
-00171
-00172 void Server::SendOpers(std::string s)
-00173 {
-00174 WriteOpers("%s",s.c_str());
-00175 }
-00176
-00177 bool Server::MatchText(std::string sliteral, std::string spattern)
-00178 {
-00179 char literal[MAXBUF],pattern[MAXBUF];
-00180 strncpy(literal,sliteral.c_str(),MAXBUF);
-00181 strncpy(pattern,spattern.c_str(),MAXBUF);
-00182 return match(literal,pattern);
-00183 }
-00184
-00185 void Server::SendToModeMask(std::string modes, int flags, std::string text)
+00164
+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
+00185 bool ModeDefined(char modechar, int type)
00186 {
-00187 WriteMode(modes.c_str(),flags,"%s",text.c_str());
-00188 }
-00189
-00190 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
-00191 {
-00192 return add_channel(user,cname.c_str(),key.c_str(),true);
-00193 }
-00194
-00195 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
-00196 {
-00197 return del_channel(user,cname.c_str(),reason.c_str(),false);
-00198 }
-00199
-00200 void Server::ChangeUserNick(userrec* user, std::string nickname)
-00201 {
-00202 force_nickchange(user,nickname.c_str());
-00203 }
-00204
-00205 void Server::QuitUser(userrec* user, std::string reason)
-00206 {
-00207 send_network_quit(user->nick,reason.c_str());
-00208 kill_link(user,reason.c_str());
-00209 }
-00210
-00211 bool Server::IsUlined(std::string server)
-00212 {
-00213 return is_uline(server.c_str());
-00214 }
-00215
-00216 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
-00217 {
-00218 call_handler(commandname.c_str(),parameters,pcnt,user);
-00219 }
-00220
-00221 void Server::Log(int level, std::string s)
-00222 {
-00223 log(level,"%s",s.c_str());
-00224 }
-00225
-00226 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
-00227 {
-00228 createcommand(cmd,f,flags,minparams);
-00229 }
-00230
-00231 void Server::SendMode(char **parameters, int pcnt, userrec *user)
-00232 {
-00233 server_mode(parameters,pcnt,user);
-00234 }
-00235
-00236 void Server::Send(int Socket, std::string s)
-00237 {
-00238 Write(Socket,"%s",s.c_str());
-00239 }
-00240
-00241 void Server::SendServ(int Socket, std::string s)
+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
+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
+00241 int ModeDefinedOff(char modechar, int type)
00242 {
-00243 WriteServ(Socket,"%s",s.c_str());
-00244 }
-00245
-00246 void Server::SendFrom(int Socket, userrec* User, std::string s)
-00247 {
-00248 WriteFrom(Socket,User,"%s",s.c_str());
-00249 }
-00250
-00251 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
-00252 {
-00253 if (!Source)
-00254 {
-00255
-00256 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
-00257 }
-00258 else
-00259 {
-00260
-00261 WriteTo(Source,Dest,"%s",s.c_str());
-00262 }
-00263 }
-00264
-00265 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
-00266 {
-00267 if (IncludeSender)
-00268 {
-00269 WriteChannel(Channel,User,"%s",s.c_str());
-00270 }
-00271 else
-00272 {
-00273 ChanExceptSender(Channel,User,"%s",s.c_str());
-00274 }
+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
+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
+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 bool Server::CommonChannels(userrec* u1, userrec* u2)
-00278 {
-00279 return (common_channels(u1,u2) != 0);
-00280 }
-00281
-00282 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
-00283 {
-00284 if (IncludeSender)
-00285 {
-00286 WriteCommon(User,"%s",text.c_str());
-00287 }
-00288 else
-00289 {
-00290 WriteCommonExcept(User,"%s",text.c_str());
-00291 }
-00292 }
-00293
-00294 void Server::SendWallops(userrec* User, std::string text)
-00295 {
-00296 WriteWallOps(User,false,"%s",text.c_str());
-00297 }
-00298
-00299 void Server::ChangeHost(userrec* user, std::string host)
-00300 {
-00301 ChangeDisplayedHost(user,host.c_str());
-00302 }
-00303
-00304 void Server::ChangeGECOS(userrec* user, std::string gecos)
-00305 {
-00306 ChangeName(user,gecos.c_str());
-00307 }
+00277
+00278
+00279 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
+00280
+00281
+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 ¶ms) { 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 bool Server::IsNick(std::string nick)
-00310 {
-00311 return (isnick(nick.c_str()) != 0);
-00312 }
-00313
-00314 userrec* Server::FindNick(std::string nick)
-00315 {
-00316 return Find(nick);
-00317 }
-00318
-00319 chanrec* Server::FindChannel(std::string channel)
-00320 {
-00321 return FindChan(channel.c_str());
-00322 }
-00323
-00324 std::string Server::ChanMode(userrec* User, chanrec* Chan)
-00325 {
-00326 return cmode(User,Chan);
-00327 }
-00328
-00329 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
-00330 {
-00331 return has_channel(User,Chan);
+00309
+00310
+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 std::string Server::GetServerName()
+00334 void Server::SendToModeMask(std::string modes, int flags, std::string text)
00335 {
-00336 return getservername();
+00336 WriteMode(modes.c_str(),flags,"%s",text.c_str());
00337 }
00338
-00339 std::string Server::GetNetworkName()
+00339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
00340 {
-00341 return getnetworkname();
+00341 return add_channel(user,cname.c_str(),key.c_str(),true);
00342 }
00343
-00344 Admin Server::GetAdmin()
+00344 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
00345 {
-00346 return Admin(getadminname(),getadminemail(),getadminnick());
+00346 return del_channel(user,cname.c_str(),reason.c_str(),false);
00347 }
00348
-00349
-00350
-00351 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
-00352 {
-00353 if (type == MT_SERVER)
+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 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
-00356 return false;
-00357 }
-00358 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
-00359 {
-00360 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
-00361 return false;
-00362 }
-00363 if ((params_when_on>1) || (params_when_off>1))
-00364 {
-00365 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
-00366 return false;
-00367 }
-00368 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
-00369 }
-00370
-00371 bool Server::AddExtendedListMode(char modechar)
-00372 {
-00373 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
-00374 if (res)
-00375 ModeMakeList(modechar);
-00376 return res;
+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 int Server::CountUsers(chanrec* c)
+00379 bool Server::IsUlined(std::string server)
00380 {
-00381 return usercount(c);
+00381 return is_uline(server.c_str());
00382 }
00383
-00384
-00385 ConfigReader::ConfigReader()
-00386 {
-00387 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00388 this->error = LoadConf(CONFIG_FILE,this->cache);
-00389 }
-00390
-00391
-00392 ConfigReader::~ConfigReader()
-00393 {
-00394 if (this->cache)
-00395 delete this->cache;
-00396 }
-00397
+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 ConfigReader::ConfigReader(std::string filename)
+00399 void Server::SendMode(char **parameters, int pcnt, userrec *user)
00400 {
-00401 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00402 this->error = LoadConf(filename.c_str(),this->cache);
-00403 };
-00404
-00405 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
-00406 {
-00407 char val[MAXBUF];
-00408 char t[MAXBUF];
-00409 char n[MAXBUF];
-00410 strncpy(t,tag.c_str(),MAXBUF);
-00411 strncpy(n,name.c_str(),MAXBUF);
-00412 ReadConf(cache,t,n,index,val);
-00413 return std::string(val);
-00414 }
-00415
-00416
-00417 int ConfigReader::Enumerate(std::string tag)
-00418 {
-00419 return EnumConf(cache,tag.c_str());
-00420 }
-00421
-00422 int ConfigReader::EnumerateValues(std::string tag, int index)
-00423 {
-00424 return EnumValues(cache, tag.c_str(), index);
-00425 }
-00426
-00427 bool ConfigReader::Verify()
-00428 {
-00429 return this->error;
-00430 }
-00431
+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
+00424 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+00425 }
+00426 else
+00427 {
+00428
+00429 WriteTo(Source,Dest,"%s",s.c_str());
+00430 }
+00431 }
00432
-00433 FileReader::FileReader(std::string filename)
+00433 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
00434 {
-00435 file_cache c;
-00436 readfile(c,filename.c_str());
-00437 this->fc = c;
-00438 }
-00439
-00440 FileReader::FileReader()
-00441 {
-00442 }
-00443
-00444 void FileReader::LoadFile(std::string filename)
-00445 {
-00446 file_cache c;
-00447 readfile(c,filename.c_str());
-00448 this->fc = c;
-00449 }
-00450
-00451
-00452 FileReader::~FileReader()
-00453 {
-00454 }
-00455
-00456 bool FileReader::Exists()
-00457 {
-00458 if (fc.size() == 0)
-00459 {
-00460 return(false);
-00461 }
-00462 else
-00463 {
-00464 return(true);
-00465 }
-00466 }
-00467
-00468 std::string FileReader::GetLine(int x)
-00469 {
-00470 if ((x<0) || (x>fc.size()))
-00471 return "";
-00472 return fc[x];
-00473 }
-00474
-00475 int FileReader::FileSize()
-00476 {
-00477 return fc.size();
-00478 }
-00479
-00480
-00481 std::vector<Module*> modules(255);
-00482 std::vector<ircd_module*> factory(255);
-00483
-00484 int MODCOUNT = -1;
-00485
+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
-
Generated on Sat May 1 13:39:00 2004 for InspIRCd by
+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->error = LoadConf(CONFIG_FILE,this->cache);
+00557 }
+00558
+00559
+00560 ConfigReader::~ConfigReader()
+00561 {
+00562 if (this->cache)
+00563 delete this->cache;
+00564 }
+00565
+00566
+00567 ConfigReader::ConfigReader(std::string filename)
+00568 {
+00569 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00570 this->error = LoadConf(filename.c_str(),this->cache);
+00571 };
+00572
+00573 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
+00574 {
+00575 char val[MAXBUF];
+00576 char t[MAXBUF];
+00577 char n[MAXBUF];
+00578 strncpy(t,tag.c_str(),MAXBUF);
+00579 strncpy(n,name.c_str(),MAXBUF);
+00580 ReadConf(cache,t,n,index,val);
+00581 return std::string(val);
+00582 }
+00583
+00584
+00585 int ConfigReader::Enumerate(std::string tag)
+00586 {
+00587 return EnumConf(cache,tag.c_str());
+00588 }
+00589
+00590 int ConfigReader::EnumerateValues(std::string tag, int index)
+00591 {
+00592 return EnumValues(cache, tag.c_str(), index);
+00593 }
+00594
+00595 bool ConfigReader::Verify()
+00596 {
+00597 return this->error;
+00598 }
+00599
+00600
+00601 FileReader::FileReader(std::string filename)
+00602 {
+00603 file_cache c;
+00604 readfile(c,filename.c_str());
+00605 this->fc = c;
+00606 }
+00607
+00608 FileReader::FileReader()
+00609 {
+00610 }
+00611
+00612 void FileReader::LoadFile(std::string filename)
+00613 {
+00614 file_cache c;
+00615 readfile(c,filename.c_str());
+00616 this->fc = c;
+00617 }
+00618
+00619
+00620 FileReader::~FileReader()
+00621 {
+00622 }
+00623
+00624 bool FileReader::Exists()
+00625 {
+00626 if (fc.size() == 0)
+00627 {
+00628 return(false);
+00629 }
+00630 else
+00631 {
+00632 return(true);
+00633 }
+00634 }
+00635
+00636 std::string FileReader::GetLine(int x)
+00637 {
+00638 if ((x<0) || (x>fc.size()))
+00639 return "";
+00640 return fc[x];
+00641 }
+00642
+00643 int FileReader::FileSize()
+00644 {
+00645 return fc.size();
+00646 }
+00647
+00648
+00649 std::vector<Module*> modules(255);
+00650 std::vector<ircd_module*> factory(255);
+00651
+00652 int MODCOUNT = -1;
+00653
+00654
+