From bc0d192a35489b8f5c42aa381ab2b120957ef770 Mon Sep 17 00:00:00 2001
From: brain
Date: Sat, 7 May 2005 15:35:21 +0000
Subject: Added final documentation for inspircd Beta 4
git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@1322 e03df62e-2008-0410-955e-edbf42e46eb7
---
docs/module-doc/modules_8cpp-source.html | 1736 +++++++++++++++---------------
1 file changed, 876 insertions(+), 860 deletions(-)
(limited to 'docs/module-doc/modules_8cpp-source.html')
diff --git a/docs/module-doc/modules_8cpp-source.html b/docs/module-doc/modules_8cpp-source.html
index 6d4455628..79165ee67 100644
--- a/docs/module-doc/modules_8cpp-source.html
+++ b/docs/module-doc/modules_8cpp-source.html
@@ -114,111 +114,111 @@
00107
00108 extern FILE *log_file;
00109
-00110
-00111 namespace nspace
-00112 {
-00113 #ifdef GCC34
-00114 template<> struct hash<in_addr>
-00115 #else
-00116 template<> struct nspace::hash<in_addr>
-00117 #endif
-00118 {
-00119 size_t operator()(const struct in_addr &a) const
-00120 {
-00121 size_t q;
-00122 memcpy(&q,&a,sizeof(size_t));
-00123 return q;
-00124 }
-00125 };
-00126 #ifdef GCC34
-00127 template<> struct hash<string>
-00128 #else
-00129 template<> struct nspace::hash<string>
-00130 #endif
-00131 {
-00132 size_t operator()(const string &s) const
-00133 {
-00134 char a[MAXBUF];
-00135 static struct hash<const char *> strhash;
-00136 strlcpy(a,s.c_str(),MAXBUF);
-00137 strlower(a);
-00138 return strhash(a);
-00139 }
-00140 };
-00141 }
-00142
-00143 struct StrHashComp
-00144 {
-00145
-00146 bool operator()(const string& s1, const string& s2) const
-00147 {
-00148 char a[MAXBUF],b[MAXBUF];
-00149 strlcpy(a,s1.c_str(),MAXBUF);
-00150 strlcpy(b,s2.c_str(),MAXBUF);
-00151 strlower(a);
-00152 strlower(b);
-00153 return (strcasecmp(a,b) == 0);
-00154 }
-00155
-00156 };
-00157
-00158 struct InAddr_HashComp
-00159 {
-00160
-00161 bool operator()(const in_addr &s1, const in_addr &s2) const
-00162 {
-00163 size_t q;
-00164 size_t p;
-00165
-00166 memcpy(&q,&s1,sizeof(size_t));
-00167 memcpy(&p,&s2,sizeof(size_t));
-00168
-00169 return (q == p);
-00170 }
-00171
-00172 };
-00173
+00110 extern userrec* fd_ref_table[65536];
+00111
+00112 namespace nspace
+00113 {
+00114 #ifdef GCC34
+00115 template<> struct hash<in_addr>
+00116 #else
+00117 template<> struct nspace::hash<in_addr>
+00118 #endif
+00119 {
+00120 size_t operator()(const struct in_addr &a) const
+00121 {
+00122 size_t q;
+00123 memcpy(&q,&a,sizeof(size_t));
+00124 return q;
+00125 }
+00126 };
+00127 #ifdef GCC34
+00128 template<> struct hash<string>
+00129 #else
+00130 template<> struct nspace::hash<string>
+00131 #endif
+00132 {
+00133 size_t operator()(const string &s) const
+00134 {
+00135 char a[MAXBUF];
+00136 static struct hash<const char *> strhash;
+00137 strlcpy(a,s.c_str(),MAXBUF);
+00138 strlower(a);
+00139 return strhash(a);
+00140 }
+00141 };
+00142 }
+00143
+00144 struct StrHashComp
+00145 {
+00146
+00147 bool operator()(const string& s1, const string& s2) const
+00148 {
+00149 char a[MAXBUF],b[MAXBUF];
+00150 strlcpy(a,s1.c_str(),MAXBUF);
+00151 strlcpy(b,s2.c_str(),MAXBUF);
+00152 strlower(a);
+00153 strlower(b);
+00154 return (strcasecmp(a,b) == 0);
+00155 }
+00156
+00157 };
+00158
+00159 struct InAddr_HashComp
+00160 {
+00161
+00162 bool operator()(const in_addr &s1, const in_addr &s2) const
+00163 {
+00164 size_t q;
+00165 size_t p;
+00166
+00167 memcpy(&q,&s1,sizeof(size_t));
+00168 memcpy(&p,&s2,sizeof(size_t));
+00169
+00170 return (q == p);
+00171 }
+00172
+00173 };
00174
-00175 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
-00176 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
-00177 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
-00178 typedef std::deque<command_t> command_table;
-00179
+00175
+00176 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
+00177 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
+00178 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
+00179 typedef std::deque<command_t> command_table;
00180
-00181 extern user_hash clientlist;
-00182 extern chan_hash chanlist;
-00183 extern user_hash whowas;
-00184 extern command_table cmdlist;
-00185 extern file_cache MOTD;
-00186 extern file_cache RULES;
-00187 extern address_cache IP;
-00188
+00181
+00182 extern user_hash clientlist;
+00183 extern chan_hash chanlist;
+00184 extern user_hash whowas;
+00185 extern command_table cmdlist;
+00186 extern file_cache MOTD;
+00187 extern file_cache RULES;
+00188 extern address_cache IP;
00189
-00190
-00191
-00192 class ExtMode : public classbase
-00193 {
-00194 public:
-00195 char modechar;
-00196 int type;
-00197 int params_when_on;
-00198 int params_when_off;
-00199 bool needsoper;
-00200 bool list;
-00201 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) { };
-00202 };
-00203
-00204 typedef std::vector<ExtMode> ExtModeList;
-00205 typedef ExtModeList::iterator ExtModeListIter;
-00206
+00190
+00191
+00192
+00193 class ExtMode : public classbase
+00194 {
+00195 public:
+00196 char modechar;
+00197 int type;
+00198 int params_when_on;
+00199 int params_when_off;
+00200 bool needsoper;
+00201 bool list;
+00202 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) { };
+00203 };
+00204
+00205 typedef std::vector<ExtMode> ExtModeList;
+00206 typedef ExtModeList::iterator ExtModeListIter;
00207
-00208 ExtModeList EMode;
-00209
-00210
-00211 bool ModeDefined(char modechar, int type)
-00212 {
-00213 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00214 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00208
+00209 ExtModeList EMode;
+00210
+00211
+00212 bool ModeDefined(char modechar, int type)
+00213 {
+00214 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
00215 {
00216 if ((i->modechar == modechar) && (i->type == type))
00217 {
@@ -228,662 +228,662 @@
00221 return false;
00222 }
00223
-00224 bool ModeIsListMode(char modechar, int type)
+00224 bool ModeIsListMode(char modechar, int type)
00225 {
-00226 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00227 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00228 {
-00229 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
-00230 {
-00231 return true;
-00232 }
-00233 }
-00234 return false;
-00235 }
-00236
-00237 bool ModeDefinedOper(char modechar, int type)
-00238 {
-00239 log(DEBUG,"Size of extmodes vector is %d",EMode.size());
-00240 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00241 {
-00242 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
-00243 {
-00244 return true;
-00245 }
-00246 }
-00247 return false;
-00248 }
-00249
-00250
-00251 int ModeDefinedOn(char modechar, int type)
-00252 {
-00253 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00254 {
-00255 if ((i->modechar == modechar) && (i->type == type))
-00256 {
-00257 return i->params_when_on;
-00258 }
-00259 }
-00260 return 0;
-00261 }
-00262
-00263
-00264 int ModeDefinedOff(char modechar, int type)
-00265 {
-00266 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00267 {
-00268 if ((i->modechar == modechar) && (i->type == type))
-00269 {
-00270 return i->params_when_off;
-00271 }
-00272 }
-00273 return 0;
-00274 }
-00275
-00276
-00277 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
-00278 {
-00279 if (ModeDefined(modechar,type)) {
-00280 return false;
-00281 }
-00282 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
-00283 return true;
-00284 }
-00285
-00286
-00287 void ModeMakeList(char modechar)
-00288 {
-00289 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
-00290 {
-00291 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
-00292 {
-00293 i->list = true;
-00294 return;
-00295 }
-00296 }
-00297 return;
-00298 }
+00226 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00227 {
+00228 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
+00229 {
+00230 return true;
+00231 }
+00232 }
+00233 return false;
+00234 }
+00235
+00236 bool ModeDefinedOper(char modechar, int type)
+00237 {
+00238 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00239 {
+00240 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
+00241 {
+00242 return true;
+00243 }
+00244 }
+00245 return false;
+00246 }
+00247
+00248
+00249 int ModeDefinedOn(char modechar, int type)
+00250 {
+00251 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00252 {
+00253 if ((i->modechar == modechar) && (i->type == type))
+00254 {
+00255 return i->params_when_on;
+00256 }
+00257 }
+00258 return 0;
+00259 }
+00260
+00261
+00262 int ModeDefinedOff(char modechar, int type)
+00263 {
+00264 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00265 {
+00266 if ((i->modechar == modechar) && (i->type == type))
+00267 {
+00268 return i->params_when_off;
+00269 }
+00270 }
+00271 return 0;
+00272 }
+00273
+00274
+00275 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
+00276 {
+00277 if (ModeDefined(modechar,type)) {
+00278 return false;
+00279 }
+00280 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
+00281 return true;
+00282 }
+00283
+00284
+00285 void ModeMakeList(char modechar)
+00286 {
+00287 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
+00288 {
+00289 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
+00290 {
+00291 i->list = true;
+00292 return;
+00293 }
+00294 }
+00295 return;
+00296 }
+00297
+00298
00299
-00300
+00300 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { };
00301
-00302 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { };
+00302
00303
-00304
+00304 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
00305
-00306 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
+00306 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { };
00307
-00308 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { };
-00309
-00310 char* Request::GetData()
-00311 {
-00312 return this->data;
-00313 }
-00314
-00315 Module* Request::GetSource()
-00316 {
-00317 return this->source;
-00318 }
-00319
-00320 Module* Request::GetDest()
-00321 {
-00322 return this->dest;
-00323 }
-00324
-00325 char* Request::Send()
-00326 {
-00327 if (this->dest)
-00328 {
-00329 return dest->OnRequest(this);
-00330 }
-00331 else
-00332 {
-00333 return NULL;
-00334 }
-00335 }
+00308 char* Request::GetData()
+00309 {
+00310 return this->data;
+00311 }
+00312
+00313 Module* Request::GetSource()
+00314 {
+00315 return this->source;
+00316 }
+00317
+00318 Module* Request::GetDest()
+00319 {
+00320 return this->dest;
+00321 }
+00322
+00323 char* Request::Send()
+00324 {
+00325 if (this->dest)
+00326 {
+00327 return dest->OnRequest(this);
+00328 }
+00329 else
+00330 {
+00331 return NULL;
+00332 }
+00333 }
+00334
+00335 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { };
00336
-00337 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { };
-00338
-00339 char* Event::GetData()
-00340 {
-00341 return this->data;
-00342 }
-00343
-00344 Module* Event::GetSource()
-00345 {
-00346 return this->source;
-00347 }
-00348
-00349 char* Event::Send()
-00350 {
-00351 FOREACH_MOD OnEvent(this);
-00352 return NULL;
-00353 }
-00354
-00355 std::string Event::GetEventID()
-00356 {
-00357 return this->id;
-00358 }
-00359
-00360
-00361 Module::Module() { }
-00362 Module::~Module() { }
-00363 void Module::OnUserConnect(userrec* user) { }
-00364 void Module::OnUserQuit(userrec* user) { }
-00365 void Module::OnUserDisconnect(userrec* user) { }
-00366 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
-00367 void Module::OnUserPart(userrec* user, chanrec* channel) { }
-00368 void Module::OnPacketTransmit(std::string &data, std::string serv) { }
-00369 void Module::OnPacketReceive(std::string &data, std::string serv) { }
-00370 void Module::OnRehash() { }
-00371 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
-00372 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
-00373 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; }
-00374 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
-00375 void Module::OnOper(userrec* user) { };
-00376 void Module::OnInfo(userrec* user) { };
-00377 void Module::OnWhois(userrec* source, userrec* dest) { };
-00378 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
-00379 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
-00380 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
-00381 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
-00382 void Module::OnUserPostNick(userrec* user, std::string oldnick) { };
-00383 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
-00384 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
-00385 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
-00386 void Module::On005Numeric(std::string &output) { };
-00387 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; };
-00388 void Module::OnLoadModule(Module* mod,std::string name) { };
-00389 void Module::OnBackgroundTimer(time_t curtime) { };
-00390 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { };
-00391 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; };
-00392 bool Module::OnCheckReady(userrec* user) { return true; };
-00393 void Module::OnUserRegister(userrec* user) { };
-00394 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; };
-00395 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { };
-00396 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; };
-00397 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
-00398 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
-00399 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
-00400 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
-00401 void Module::OnStats(char symbol) { };
-00402 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
-00403 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
-00404 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
-00405 int Module::OnMeshToken(char token,string_list params,serverrec* source,serverrec* reply, std::string tcp_host,std::string ipaddr,int port) { return 0; };
-00406 void Module::OnEvent(Event* event) { return; };
-00407 char* Module::OnRequest(Request* request) { return NULL; };
-00408 int Module::OnOperCompare(std::string password, std::string input) { return 0; };
-00409 void Module::OnGlobalOper(userrec* user) { };
-00410 void Module::OnGlobalConnect(userrec* user) { };
-00411
-00412
-00413
-00414
-00415
-00416 Server::Server()
-00417 {
-00418 }
-00419
-00420 Server::~Server()
-00421 {
-00422 }
-00423
-00424 void Server::SendOpers(std::string s)
-00425 {
-00426 WriteOpers("%s",s.c_str());
+00337 char* Event::GetData()
+00338 {
+00339 return this->data;
+00340 }
+00341
+00342 Module* Event::GetSource()
+00343 {
+00344 return this->source;
+00345 }
+00346
+00347 char* Event::Send()
+00348 {
+00349 FOREACH_MOD OnEvent(this);
+00350 return NULL;
+00351 }
+00352
+00353 std::string Event::GetEventID()
+00354 {
+00355 return this->id;
+00356 }
+00357
+00358
+00359
+00360 Module::Module() { }
+00361 Module::~Module() { }
+00362 void Module::OnUserConnect(userrec* user) { }
+00363 void Module::OnUserQuit(userrec* user) { }
+00364 void Module::OnUserDisconnect(userrec* user) { }
+00365 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
+00366 void Module::OnUserPart(userrec* user, chanrec* channel) { }
+00367 void Module::OnPacketTransmit(std::string &data, std::string serv) { }
+00368 void Module::OnPacketReceive(std::string &data, std::string serv) { }
+00369 void Module::OnRehash() { }
+00370 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
+00371 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
+00372 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; }
+00373 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
+00374 void Module::OnOper(userrec* user) { };
+00375 void Module::OnInfo(userrec* user) { };
+00376 void Module::OnWhois(userrec* source, userrec* dest) { };
+00377 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
+00378 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00379 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; };
+00380 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
+00381 void Module::OnUserPostNick(userrec* user, std::string oldnick) { };
+00382 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
+00383 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
+00384 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
+00385 void Module::On005Numeric(std::string &output) { };
+00386 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; };
+00387 void Module::OnLoadModule(Module* mod,std::string name) { };
+00388 void Module::OnBackgroundTimer(time_t curtime) { };
+00389 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { };
+00390 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; };
+00391 bool Module::OnCheckReady(userrec* user) { return true; };
+00392 void Module::OnUserRegister(userrec* user) { };
+00393 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; };
+00394 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { };
+00395 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; };
+00396 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
+00397 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
+00398 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
+00399 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
+00400 void Module::OnStats(char symbol) { };
+00401 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
+00402 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
+00403 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
+00404 int Module::OnMeshToken(char token,string_list params,serverrec* source,serverrec* reply, std::string tcp_host,std::string ipaddr,int port) { return 0; };
+00405 void Module::OnEvent(Event* event) { return; };
+00406 char* Module::OnRequest(Request* request) { return NULL; };
+00407 int Module::OnOperCompare(std::string password, std::string input) { return 0; };
+00408 void Module::OnGlobalOper(userrec* user) { };
+00409 void Module::OnGlobalConnect(userrec* user) { };
+00410 int Module::OnAddBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
+00411 int Module::OnDelBan(userrec* source, chanrec* channel,std::string banmask) { return 0; };
+00412 void Module::OnRawSocketAccept(int fd, std::string ip, int localport) { };
+00413 int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; };
+00414 void Module::OnRawSocketClose(int fd) { };
+00415 int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; };
+00416
+00417
+00418
+00419
+00420
+00421 Server::Server()
+00422 {
+00423 }
+00424
+00425 Server::~Server()
+00426 {
00427 }
00428
-00429 bool Server::MatchText(std::string sliteral, std::string spattern)
+00429 void Server::SendOpers(std::string s)
00430 {
-00431 char literal[MAXBUF],pattern[MAXBUF];
-00432 strlcpy(literal,sliteral.c_str(),MAXBUF);
-00433 strlcpy(pattern,spattern.c_str(),MAXBUF);
-00434 return match(literal,pattern);
-00435 }
-00436
-00437 void Server::SendToModeMask(std::string modes, int flags, std::string text)
-00438 {
-00439 WriteMode(modes.c_str(),flags,"%s",text.c_str());
+00431 WriteOpers("%s",s.c_str());
+00432 }
+00433
+00434 bool Server::MatchText(std::string sliteral, std::string spattern)
+00435 {
+00436 char literal[MAXBUF],pattern[MAXBUF];
+00437 strlcpy(literal,sliteral.c_str(),MAXBUF);
+00438 strlcpy(pattern,spattern.c_str(),MAXBUF);
+00439 return match(literal,pattern);
00440 }
00441
-00442 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
+00442 void Server::SendToModeMask(std::string modes, int flags, std::string text)
00443 {
-00444 return add_channel(user,cname.c_str(),key.c_str(),true);
+00444 WriteMode(modes.c_str(),flags,"%s",text.c_str());
00445 }
00446
-00447 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
+00447 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
00448 {
-00449 return del_channel(user,cname.c_str(),reason.c_str(),false);
+00449 return add_channel(user,cname.c_str(),key.c_str(),false);
00450 }
00451
-00452 chanuserlist Server::GetUsers(chanrec* chan)
+00452 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
00453 {
-00454 chanuserlist userl;
-00455 userl.clear();
-00456 for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
-00457 {
-00458 if (i->second)
-00459 {
-00460 if (has_channel(i->second,chan))
-00461 {
-00462 if (isnick(i->second->nick))
-00463 {
-00464 userl.push_back(i->second);
-00465 }
-00466 }
-00467 }
-00468 }
-00469 return userl;
-00470 }
-00471 void Server::ChangeUserNick(userrec* user, std::string nickname)
-00472 {
-00473 force_nickchange(user,nickname.c_str());
-00474 }
-00475
-00476 void Server::QuitUser(userrec* user, std::string reason)
-00477 {
-00478 send_network_quit(user->nick,reason.c_str());
-00479 kill_link(user,reason.c_str());
-00480 }
-00481
-00482 bool Server::IsUlined(std::string server)
-00483 {
-00484 return is_uline(server.c_str());
-00485 }
-00486
-00487 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
-00488 {
-00489 call_handler(commandname.c_str(),parameters,pcnt,user);
-00490 }
-00491
-00492 void Server::Log(int level, std::string s)
-00493 {
-00494 log(level,"%s",s.c_str());
-00495 }
-00496
-00497 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source)
-00498 {
-00499 createcommand(cmd,f,flags,minparams,source);
-00500 }
-00501
-00502 void Server::SendMode(char **parameters, int pcnt, userrec *user)
-00503 {
-00504 server_mode(parameters,pcnt,user);
-00505 }
-00506
-00507 void Server::Send(int Socket, std::string s)
-00508 {
-00509 Write(Socket,"%s",s.c_str());
-00510 }
-00511
-00512 void Server::SendServ(int Socket, std::string s)
-00513 {
-00514 WriteServ(Socket,"%s",s.c_str());
-00515 }
-00516
-00517 void Server::SendFrom(int Socket, userrec* User, std::string s)
-00518 {
-00519 WriteFrom(Socket,User,"%s",s.c_str());
-00520 }
-00521
-00522 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
-00523 {
-00524 if (!Source)
-00525 {
-00526
-00527 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
-00528 }
-00529 else
-00530 {
-00531
-00532 WriteTo(Source,Dest,"%s",s.c_str());
-00533 }
-00534 }
-00535
-00536 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
-00537 {
-00538 if (IncludeSender)
-00539 {
-00540 WriteChannel(Channel,User,"%s",s.c_str());
-00541 }
-00542 else
-00543 {
-00544 ChanExceptSender(Channel,User,"%s",s.c_str());
-00545 }
-00546 }
-00547
-00548 bool Server::CommonChannels(userrec* u1, userrec* u2)
-00549 {
-00550 return (common_channels(u1,u2) != 0);
-00551 }
-00552
-00553 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
-00554 {
-00555 if (IncludeSender)
-00556 {
-00557 WriteCommon(User,"%s",text.c_str());
-00558 }
-00559 else
-00560 {
-00561 WriteCommonExcept(User,"%s",text.c_str());
-00562 }
-00563 }
-00564
-00565 void Server::SendWallops(userrec* User, std::string text)
-00566 {
-00567 WriteWallOps(User,false,"%s",text.c_str());
-00568 }
-00569
-00570 void Server::ChangeHost(userrec* user, std::string host)
-00571 {
-00572 ChangeDisplayedHost(user,host.c_str());
-00573 }
-00574
-00575 void Server::ChangeGECOS(userrec* user, std::string gecos)
-00576 {
-00577 ChangeName(user,gecos.c_str());
-00578 }
-00579
-00580 bool Server::IsNick(std::string nick)
-00581 {
-00582 return (isnick(nick.c_str()) != 0);
-00583 }
-00584
-00585 userrec* Server::FindNick(std::string nick)
-00586 {
-00587 return Find(nick);
-00588 }
-00589
-00590 chanrec* Server::FindChannel(std::string channel)
-00591 {
-00592 return FindChan(channel.c_str());
-00593 }
-00594
-00595 std::string Server::ChanMode(userrec* User, chanrec* Chan)
-00596 {
-00597 return cmode(User,Chan);
-00598 }
-00599
-00600 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
-00601 {
-00602 return has_channel(User,Chan);
-00603 }
-00604
-00605 std::string Server::GetServerName()
-00606 {
-00607 return getservername();
-00608 }
-00609
-00610 std::string Server::GetNetworkName()
-00611 {
-00612 return getnetworkname();
-00613 }
-00614
-00615 Admin Server::GetAdmin()
-00616 {
-00617 return Admin(getadminname(),getadminemail(),getadminnick());
-00618 }
-00619
-00620
+00454 return del_channel(user,cname.c_str(),reason.c_str(),false);
+00455 }
+00456
+00457 chanuserlist Server::GetUsers(chanrec* chan)
+00458 {
+00459 chanuserlist userl;
+00460 userl.clear();
+00461 std::vector<char*> *list = chan->GetUsers();
+00462 for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++)
+00463 {
+00464 char* o = *i;
+00465 userl.push_back((userrec*)o);
+00466 }
+00467 return userl;
+00468 }
+00469 void Server::ChangeUserNick(userrec* user, std::string nickname)
+00470 {
+00471 force_nickchange(user,nickname.c_str());
+00472 }
+00473
+00474 void Server::QuitUser(userrec* user, std::string reason)
+00475 {
+00476 kill_link(user,reason.c_str());
+00477 }
+00478
+00479 bool Server::IsUlined(std::string server)
+00480 {
+00481 return is_uline(server.c_str());
+00482 }
+00483
+00484 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
+00485 {
+00486 call_handler(commandname.c_str(),parameters,pcnt,user);
+00487 }
+00488
+00489 void Server::Log(int level, std::string s)
+00490 {
+00491 log(level,"%s",s.c_str());
+00492 }
+00493
+00494 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source)
+00495 {
+00496 createcommand(cmd,f,flags,minparams,source);
+00497 }
+00498
+00499 void Server::SendMode(char **parameters, int pcnt, userrec *user)
+00500 {
+00501 server_mode(parameters,pcnt,user);
+00502 }
+00503
+00504 void Server::Send(int Socket, std::string s)
+00505 {
+00506 Write(Socket,"%s",s.c_str());
+00507 }
+00508
+00509 void Server::SendServ(int Socket, std::string s)
+00510 {
+00511 WriteServ(Socket,"%s",s.c_str());
+00512 }
+00513
+00514 void Server::SendFrom(int Socket, userrec* User, std::string s)
+00515 {
+00516 WriteFrom(Socket,User,"%s",s.c_str());
+00517 }
+00518
+00519 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
+00520 {
+00521 if (!Source)
+00522 {
+00523
+00524 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
+00525 }
+00526 else
+00527 {
+00528
+00529 WriteTo(Source,Dest,"%s",s.c_str());
+00530 }
+00531 }
+00532
+00533 void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text)
+00534 {
+00535 WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str());
+00536 }
+00537
+00538 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
+00539 {
+00540 if (IncludeSender)
+00541 {
+00542 WriteChannel(Channel,User,"%s",s.c_str());
+00543 }
+00544 else
+00545 {
+00546 ChanExceptSender(Channel,User,"%s",s.c_str());
+00547 }
+00548 }
+00549
+00550 bool Server::CommonChannels(userrec* u1, userrec* u2)
+00551 {
+00552 return (common_channels(u1,u2) != 0);
+00553 }
+00554
+00555 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
+00556 {
+00557 if (IncludeSender)
+00558 {
+00559 WriteCommon(User,"%s",text.c_str());
+00560 }
+00561 else
+00562 {
+00563 WriteCommonExcept(User,"%s",text.c_str());
+00564 }
+00565 }
+00566
+00567 void Server::SendWallops(userrec* User, std::string text)
+00568 {
+00569 WriteWallOps(User,false,"%s",text.c_str());
+00570 }
+00571
+00572 void Server::ChangeHost(userrec* user, std::string host)
+00573 {
+00574 ChangeDisplayedHost(user,host.c_str());
+00575 }
+00576
+00577 void Server::ChangeGECOS(userrec* user, std::string gecos)
+00578 {
+00579 ChangeName(user,gecos.c_str());
+00580 }
+00581
+00582 bool Server::IsNick(std::string nick)
+00583 {
+00584 return (isnick(nick.c_str()) != 0);
+00585 }
+00586
+00587 userrec* Server::FindNick(std::string nick)
+00588 {
+00589 return Find(nick);
+00590 }
+00591
+00592 userrec* Server::FindDescriptor(int socket)
+00593 {
+00594 return (socket < 65536 ? fd_ref_table[socket] : NULL);
+00595 }
+00596
+00597 chanrec* Server::FindChannel(std::string channel)
+00598 {
+00599 return FindChan(channel.c_str());
+00600 }
+00601
+00602 std::string Server::ChanMode(userrec* User, chanrec* Chan)
+00603 {
+00604 return cmode(User,Chan);
+00605 }
+00606
+00607 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
+00608 {
+00609 return has_channel(User,Chan);
+00610 }
+00611
+00612 std::string Server::GetServerName()
+00613 {
+00614 return getservername();
+00615 }
+00616
+00617 std::string Server::GetNetworkName()
+00618 {
+00619 return getnetworkname();
+00620 }
00621
-00622 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
+00622 Admin Server::GetAdmin()
00623 {
-00624 if (type == MT_SERVER)
-00625 {
-00626 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
-00627 return false;
-00628 }
-00629 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
-00630 {
-00631 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
-00632 return false;
-00633 }
-00634 if ((params_when_on>1) || (params_when_off>1))
-00635 {
-00636 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
-00637 return false;
-00638 }
-00639 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
-00640 }
-00641
-00642 bool Server::AddExtendedListMode(char modechar)
-00643 {
-00644 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
-00645 if (res)
-00646 ModeMakeList(modechar);
-00647 return res;
-00648 }
-00649
-00650 int Server::CountUsers(chanrec* c)
-00651 {
-00652 return usercount(c);
-00653 }
-00654
-00655
-00656 bool Server::UserToPseudo(userrec* user,std::string message)
-00657 {
-00658 unsigned int old_fd = user->fd;
-00659 user->fd = FD_MAGIC_NUMBER;
-00660 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
-00661 close(old_fd);
-00662 shutdown (old_fd,2);
+00624 return Admin(getadminname(),getadminemail(),getadminnick());
+00625 }
+00626
+00627
+00628
+00629 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
+00630 {
+00631 if (((modechar >= 'A') && (modechar <= 'Z')) || ((modechar >= 'a') && (modechar <= 'z')))
+00632 {
+00633 if (type == MT_SERVER)
+00634 {
+00635 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
+00636 return false;
+00637 }
+00638 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
+00639 {
+00640 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
+00641 return false;
+00642 }
+00643 if ((params_when_on>1) || (params_when_off>1))
+00644 {
+00645 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
+00646 return false;
+00647 }
+00648 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
+00649 }
+00650 else
+00651 {
+00652 log(DEBUG,"*** API ERROR *** Muppet modechar detected.");
+00653 }
+00654 return false;
+00655 }
+00656
+00657 bool Server::AddExtendedListMode(char modechar)
+00658 {
+00659 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
+00660 if (res)
+00661 ModeMakeList(modechar);
+00662 return res;
00663 }
00664
-00665 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message)
+00665 int Server::CountUsers(chanrec* c)
00666 {
-00667 zombie->fd = alive->fd;
-00668 alive->fd = FD_MAGIC_NUMBER;
-00669 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick);
-00670 kill_link(alive,message.c_str());
-00671 for (int i = 0; i != MAXCHANS; i++)
-00672 {
-00673 if (zombie->chans[i].channel != NULL)
-00674 {
-00675 if (zombie->chans[i].channel->name)
-00676 {
-00677 chanrec* Ptr = zombie->chans[i].channel;
-00678 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name);
-00679 if (Ptr->topicset)
-00680 {
-00681 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
-00682 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
-00683 }
-00684 userlist(zombie,Ptr);
-00685 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
-00686
-00687
-00688
-00689 }
-00690 }
-00691 }
-00692
-00693 }
-00694
-00695 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask)
-00696 {
-00697 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00698 }
-00699
-00700 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname)
-00701 {
-00702 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str());
-00703 }
+00667 return usercount(c);
+00668 }
+00669
+00670
+00671 bool Server::UserToPseudo(userrec* user,std::string message)
+00672 {
+00673 unsigned int old_fd = user->fd;
+00674 user->fd = FD_MAGIC_NUMBER;
+00675 user->ClearBuffer();
+00676 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
+00677 shutdown(old_fd,2);
+00678 close(old_fd);
+00679 }
+00680
+00681 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message)
+00682 {
+00683 zombie->fd = alive->fd;
+00684 alive->fd = FD_MAGIC_NUMBER;
+00685 alive->ClearBuffer();
+00686 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick);
+00687 kill_link(alive,message.c_str());
+00688 fd_ref_table[zombie->fd] = zombie;
+00689 for (int i = 0; i != MAXCHANS; i++)
+00690 {
+00691 if (zombie->chans[i].channel != NULL)
+00692 {
+00693 if (zombie->chans[i].channel->name)
+00694 {
+00695 chanrec* Ptr = zombie->chans[i].channel;
+00696 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name);
+00697 if (Ptr->topicset)
+00698 {
+00699 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
+00700 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
+00701 }
+00702 userlist(zombie,Ptr);
+00703 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
00704
-00705 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr)
-00706 {
-00707 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str());
-00708 }
-00709
-00710 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask)
-00711 {
-00712 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00713 }
-00714
-00715 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask)
-00716 {
-00717 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
-00718 }
-00719
-00720 bool Server::DelGLine(std::string hostmask)
-00721 {
-00722 del_gline(hostmask.c_str());
-00723 }
-00724
-00725 bool Server::DelQLine(std::string nickname)
-00726 {
-00727 del_qline(nickname.c_str());
-00728 }
-00729
-00730 bool Server::DelZLine(std::string ipaddr)
-00731 {
-00732 del_zline(ipaddr.c_str());
-00733 }
-00734
-00735 bool Server::DelKLine(std::string hostmask)
-00736 {
-00737 del_kline(hostmask.c_str());
-00738 }
-00739
-00740 bool Server::DelELine(std::string hostmask)
-00741 {
-00742 del_eline(hostmask.c_str());
-00743 }
-00744
-00745 long Server::CalcDuration(std::string delta)
-00746 {
-00747 return duration(delta.c_str());
-00748 }
-00749
-00750 bool Server::IsValidMask(std::string mask)
-00751 {
-00752 const char* dest = mask.c_str();
-00753 if (strchr(dest,'!')==0)
-00754 return false;
-00755 if (strchr(dest,'@')==0)
-00756 return false;
-00757 for (int i = 0; i < strlen(dest); i++)
-00758 if (dest[i] < 32)
-00759 return false;
-00760 for (int i = 0; i < strlen(dest); i++)
-00761 if (dest[i] > 126)
-00762 return false;
-00763 int c = 0;
-00764 for (int i = 0; i < strlen(dest); i++)
-00765 if (dest[i] == '!')
-00766 c++;
-00767 if (c>1)
-00768 return false;
-00769 c = 0;
-00770 for (int i = 0; i < strlen(dest); i++)
-00771 if (dest[i] == '@')
-00772 c++;
-00773 if (c>1)
-00774 return false;
-00775
-00776 return true;
-00777 }
-00778
-00779 void Server::MeshSendAll(std::string text)
-00780 {
-00781 NetSendToAll((char*)text.c_str());
-00782 }
-00783
-00784 void Server::MeshSendCommon(userrec* user, std::string text)
-00785 {
-00786 if (user)
-00787 NetSendToCommon(user,(char*)text.c_str());
-00788 }
-00789
-00790 void Server::MeshSendAllAlive(std::string text)
-00791 {
-00792 NetSendToAllAlive((char*)text.c_str());
+00705 }
+00706 }
+00707 }
+00708
+00709 }
+00710
+00711 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask)
+00712 {
+00713 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00714 }
+00715
+00716 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname)
+00717 {
+00718 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str());
+00719 }
+00720
+00721 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr)
+00722 {
+00723 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str());
+00724 }
+00725
+00726 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask)
+00727 {
+00728 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00729 }
+00730
+00731 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask)
+00732 {
+00733 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
+00734 }
+00735
+00736 bool Server::DelGLine(std::string hostmask)
+00737 {
+00738 del_gline(hostmask.c_str());
+00739 }
+00740
+00741 bool Server::DelQLine(std::string nickname)
+00742 {
+00743 del_qline(nickname.c_str());
+00744 }
+00745
+00746 bool Server::DelZLine(std::string ipaddr)
+00747 {
+00748 del_zline(ipaddr.c_str());
+00749 }
+00750
+00751 bool Server::DelKLine(std::string hostmask)
+00752 {
+00753 del_kline(hostmask.c_str());
+00754 }
+00755
+00756 bool Server::DelELine(std::string hostmask)
+00757 {
+00758 del_eline(hostmask.c_str());
+00759 }
+00760
+00761 long Server::CalcDuration(std::string delta)
+00762 {
+00763 return duration(delta.c_str());
+00764 }
+00765
+00766 bool Server::IsValidMask(std::string mask)
+00767 {
+00768 const char* dest = mask.c_str();
+00769 if (strchr(dest,'!')==0)
+00770 return false;
+00771 if (strchr(dest,'@')==0)
+00772 return false;
+00773 for (int i = 0; i < strlen(dest); i++)
+00774 if (dest[i] < 32)
+00775 return false;
+00776 for (int i = 0; i < strlen(dest); i++)
+00777 if (dest[i] > 126)
+00778 return false;
+00779 int c = 0;
+00780 for (int i = 0; i < strlen(dest); i++)
+00781 if (dest[i] == '!')
+00782 c++;
+00783 if (c>1)
+00784 return false;
+00785 c = 0;
+00786 for (int i = 0; i < strlen(dest); i++)
+00787 if (dest[i] == '@')
+00788 c++;
+00789 if (c>1)
+00790 return false;
+00791
+00792 return true;
00793 }
00794
-00795 void Server::MeshSendUnicast(std::string destination, std::string text)
+00795 void Server::MeshSendAll(std::string text)
00796 {
-00797 NetSendToOne((char*)destination.c_str(),(char*)text.c_str());
+00797 NetSendToAll((char*)text.c_str());
00798 }
00799
-00800 void Server::MeshSendAllExcept(std::string target, std::string text)
+00800 void Server::MeshSendCommon(userrec* user, std::string text)
00801 {
-00802 NetSendToAllExcept(target.c_str(),(char*)text.c_str());
-00803 }
-00804
-00805 bool Server::MeshCheckChan(chanrec *c,std::string servername)
-00806 {
-00807 if (c)
-00808 {
-00809 return ChanAnyOnThisServer(c,(char*)servername.c_str());
-00810 }
-00811 else return false;
-00812 }
-00813
-00814 bool Server::MeshCheckCommon(userrec* u,std::string servername)
-00815 {
-00816 if (u)
-00817 {
-00818 return CommonOnThisServer(u,(char*)servername.c_str());
-00819 }
-00820 else return false;
-00821 }
-00822
-00823 Module* Server::FindModule(std::string name)
-00824 {
-00825 for (int i = 0; i <= MODCOUNT; i++)
-00826 {
-00827 if (module_names[i] == name)
-00828 {
-00829 return modules[i];
-00830 }
-00831 }
-00832 return NULL;
-00833 }
-00834
-00835 ConfigReader::ConfigReader()
-00836 {
-00837 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00838 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00839 this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog);
-00840 if (!this->readerror)
-00841 this->error = CONF_FILE_NOT_FOUND;
-00842 }
-00843
-00844
-00845 ConfigReader::~ConfigReader()
-00846 {
-00847 if (this->cache)
-00848 delete this->cache;
-00849 if (this->errorlog)
-00850 delete this->errorlog;
-00851 }
-00852
-00853
-00854 ConfigReader::ConfigReader(std::string filename)
-00855 {
-00856 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00857 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
-00858 this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog);
-00859 if (!this->readerror)
-00860 this->error = CONF_FILE_NOT_FOUND;
-00861 };
-00862
-00863 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
-00864 {
-00865 char val[MAXBUF];
-00866 char t[MAXBUF];
-00867 char n[MAXBUF];
-00868 strlcpy(t,tag.c_str(),MAXBUF);
-00869 strlcpy(n,name.c_str(),MAXBUF);
-00870 int res = ReadConf(cache,t,n,index,val);
-00871 if (!res)
-00872 {
-00873 this->error = CONF_VALUE_NOT_FOUND;
-00874 return "";
-00875 }
-00876 return std::string(val);
-00877 }
+00802 if (user)
+00803 NetSendToCommon(user,(char*)text.c_str());
+00804 }
+00805
+00806 void Server::MeshSendAllAlive(std::string text)
+00807 {
+00808 NetSendToAllAlive((char*)text.c_str());
+00809 }
+00810
+00811 void Server::MeshSendUnicast(std::string destination, std::string text)
+00812 {
+00813 NetSendToOne((char*)destination.c_str(),(char*)text.c_str());
+00814 }
+00815
+00816 void Server::MeshSendAllExcept(std::string target, std::string text)
+00817 {
+00818 NetSendToAllExcept(target.c_str(),(char*)text.c_str());
+00819 }
+00820
+00821 bool Server::MeshCheckChan(chanrec *c,std::string servername)
+00822 {
+00823 if (c)
+00824 {
+00825 return ChanAnyOnThisServer(c,(char*)servername.c_str());
+00826 }
+00827 else return false;
+00828 }
+00829
+00830 bool Server::MeshCheckCommon(userrec* u,std::string servername)
+00831 {
+00832 if (u)
+00833 {
+00834 return CommonOnThisServer(u,(char*)servername.c_str());
+00835 }
+00836 else return false;
+00837 }
+00838
+00839 Module* Server::FindModule(std::string name)
+00840 {
+00841 for (int i = 0; i <= MODCOUNT; i++)
+00842 {
+00843 if (module_names[i] == name)
+00844 {
+00845 return modules[i];
+00846 }
+00847 }
+00848 return NULL;
+00849 }
+00850
+00851 ConfigReader::ConfigReader()
+00852 {
+00853 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00854 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00855 this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog);
+00856 if (!this->readerror)
+00857 this->error = CONF_FILE_NOT_FOUND;
+00858 }
+00859
+00860
+00861 ConfigReader::~ConfigReader()
+00862 {
+00863 if (this->cache)
+00864 delete this->cache;
+00865 if (this->errorlog)
+00866 delete this->errorlog;
+00867 }
+00868
+00869
+00870 ConfigReader::ConfigReader(std::string filename)
+00871 {
+00872 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00873 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out);
+00874 this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog);
+00875 if (!this->readerror)
+00876 this->error = CONF_FILE_NOT_FOUND;
+00877 };
00878
-00879 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
+00879 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
00880 {
00881 char val[MAXBUF];
00882 char t[MAXBUF];
@@ -894,152 +894,168 @@
00887 if (!res)
00888 {
00889 this->error = CONF_VALUE_NOT_FOUND;
-00890 return false;
+00890 return "";
00891 }
-00892 std::string s = val;
-00893 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
-00894 }
-00895
-00896 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
-00897 {
-00898 char val[MAXBUF];
-00899 char t[MAXBUF];
-00900 char n[MAXBUF];
-00901 strlcpy(t,tag.c_str(),MAXBUF);
-00902 strlcpy(n,name.c_str(),MAXBUF);
-00903 int res = ReadConf(cache,t,n,index,val);
-00904 if (!res)
-00905 {
-00906 this->error = CONF_VALUE_NOT_FOUND;
-00907 return 0;
-00908 }
-00909 for (int i = 0; i < strlen(val); i++)
-00910 {
-00911 if (!isdigit(val[i]))
-00912 {
-00913 this->error = CONF_NOT_A_NUMBER;
-00914 return 0;
-00915 }
-00916 }
-00917 if ((needs_unsigned) && (atoi(val)<0))
-00918 {
-00919 this->error = CONF_NOT_UNSIGNED;
-00920 return 0;
-00921 }
-00922 return atoi(val);
-00923 }
-00924
-00925 long ConfigReader::GetError()
-00926 {
-00927 long olderr = this->error;
-00928 this->error = 0;
-00929 return olderr;
-00930 }
-00931
-00932 void ConfigReader::DumpErrors(bool bail, userrec* user)
-00933 {
-00934 if (bail)
-00935 {
-00936 printf("There were errors in your configuration:\n%s",errorlog->str().c_str());
-00937 exit(0);
-00938 }
-00939 else
-00940 {
-00941 char dataline[1024];
-00942 if (user)
-00943 {
-00944 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
-00945 while (!errorlog->eof())
-00946 {
-00947 errorlog->getline(dataline,1024);
-00948 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
-00949 }
-00950 }
-00951 else
-00952 {
-00953 WriteOpers("There were errors in the configuration file:",user->nick);
-00954 while (!errorlog->eof())
-00955 {
-00956 errorlog->getline(dataline,1024);
-00957 WriteOpers(dataline);
-00958 }
-00959 }
-00960 return;
-00961 }
-00962 }
-00963
-00964
-00965 int ConfigReader::Enumerate(std::string tag)
-00966 {
-00967 return EnumConf(cache,tag.c_str());
-00968 }
-00969
-00970 int ConfigReader::EnumerateValues(std::string tag, int index)
-00971 {
-00972 return EnumValues(cache, tag.c_str(), index);
-00973 }
-00974
-00975 bool ConfigReader::Verify()
-00976 {
-00977 return this->readerror;
+00892 return std::string(val);
+00893 }
+00894
+00895 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
+00896 {
+00897 char val[MAXBUF];
+00898 char t[MAXBUF];
+00899 char n[MAXBUF];
+00900 strlcpy(t,tag.c_str(),MAXBUF);
+00901 strlcpy(n,name.c_str(),MAXBUF);
+00902 int res = ReadConf(cache,t,n,index,val);
+00903 if (!res)
+00904 {
+00905 this->error = CONF_VALUE_NOT_FOUND;
+00906 return false;
+00907 }
+00908 std::string s = val;
+00909 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
+00910 }
+00911
+00912 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
+00913 {
+00914 char val[MAXBUF];
+00915 char t[MAXBUF];
+00916 char n[MAXBUF];
+00917 strlcpy(t,tag.c_str(),MAXBUF);
+00918 strlcpy(n,name.c_str(),MAXBUF);
+00919 int res = ReadConf(cache,t,n,index,val);
+00920 if (!res)
+00921 {
+00922 this->error = CONF_VALUE_NOT_FOUND;
+00923 return 0;
+00924 }
+00925 for (int i = 0; i < strlen(val); i++)
+00926 {
+00927 if (!isdigit(val[i]))
+00928 {
+00929 this->error = CONF_NOT_A_NUMBER;
+00930 return 0;
+00931 }
+00932 }
+00933 if ((needs_unsigned) && (atoi(val)<0))
+00934 {
+00935 this->error = CONF_NOT_UNSIGNED;
+00936 return 0;
+00937 }
+00938 return atoi(val);
+00939 }
+00940
+00941 long ConfigReader::GetError()
+00942 {
+00943 long olderr = this->error;
+00944 this->error = 0;
+00945 return olderr;
+00946 }
+00947
+00948 void ConfigReader::DumpErrors(bool bail, userrec* user)
+00949 {
+00950 if (bail)
+00951 {
+00952 printf("There were errors in your configuration:\n%s",errorlog->str().c_str());
+00953 exit(0);
+00954 }
+00955 else
+00956 {
+00957 char dataline[1024];
+00958 if (user)
+00959 {
+00960 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
+00961 while (!errorlog->eof())
+00962 {
+00963 errorlog->getline(dataline,1024);
+00964 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline);
+00965 }
+00966 }
+00967 else
+00968 {
+00969 WriteOpers("There were errors in the configuration file:",user->nick);
+00970 while (!errorlog->eof())
+00971 {
+00972 errorlog->getline(dataline,1024);
+00973 WriteOpers(dataline);
+00974 }
+00975 }
+00976 return;
+00977 }
00978 }
00979
00980
-00981 FileReader::FileReader(std::string filename)
+00981 int ConfigReader::Enumerate(std::string tag)
00982 {
-00983 file_cache c;
-00984 readfile(c,filename.c_str());
-00985 this->fc = c;
-00986 }
-00987
-00988 FileReader::FileReader()
-00989 {
-00990 }
-00991
-00992 void FileReader::LoadFile(std::string filename)
-00993 {
-00994 file_cache c;
-00995 readfile(c,filename.c_str());
-00996 this->fc = c;
-00997 }
-00998
-00999
-01000 FileReader::~FileReader()
-01001 {
+00983 return EnumConf(cache,tag.c_str());
+00984 }
+00985
+00986 int ConfigReader::EnumerateValues(std::string tag, int index)
+00987 {
+00988 return EnumValues(cache, tag.c_str(), index);
+00989 }
+00990
+00991 bool ConfigReader::Verify()
+00992 {
+00993 return this->readerror;
+00994 }
+00995
+00996
+00997 FileReader::FileReader(std::string filename)
+00998 {
+00999 file_cache c;
+01000 readfile(c,filename.c_str());
+01001 this->fc = c;
01002 }
01003
-01004 bool FileReader::Exists()
+01004 FileReader::FileReader()
01005 {
-01006 if (fc.size() == 0)
-01007 {
-01008 return(false);
-01009 }
-01010 else
-01011 {
-01012 return(true);
-01013 }
-01014 }
+01006 }
+01007
+01008 void FileReader::LoadFile(std::string filename)
+01009 {
+01010 file_cache c;
+01011 readfile(c,filename.c_str());
+01012 this->fc = c;
+01013 }
+01014
01015
-01016 std::string FileReader::GetLine(int x)
+01016 FileReader::~FileReader()
01017 {
-01018 if ((x<0) || (x>fc.size()))
-01019 return "";
-01020 return fc[x];
-01021 }
-01022
-01023 int FileReader::FileSize()
-01024 {
-01025 return fc.size();
-01026 }
-01027
-01028
-01029 std::vector<Module*> modules(255);
-01030 std::vector<ircd_module*> factory(255);
+01018 }
+01019
+01020 bool FileReader::Exists()
+01021 {
+01022 if (fc.size() == 0)
+01023 {
+01024 return(false);
+01025 }
+01026 else
+01027 {
+01028 return(true);
+01029 }
+01030 }
01031
-01032 int MODCOUNT = -1;
-01033
-01034
-
Generated on Tue Apr 26 17:11:44 2005 for InspIRCd by
+01032 std::string FileReader::GetLine(int x)
+01033 {
+01034 if ((x<0) || (x>fc.size()))
+01035 return "";
+01036 return fc[x];
+01037 }
+01038
+01039 int FileReader::FileSize()
+01040 {
+01041 return fc.size();
+01042 }
+01043
+01044
+01045 std::vector<Module*> modules(255);
+01046 std::vector<ircd_module*> factory(255);
+01047
+01048 int MODCOUNT = -1;
+01049
+01050
+
Generated on Sat May 7 15:34:21 2005 for InspIRCd by
1.3.3
--
cgit v1.3.1-10-gc9f91