-00001 /* +------------------------------------+ -00002 * | Inspire Internet Relay Chat Daemon | -00003 * +------------------------------------+ -00004 * -00005 * Inspire is copyright (C) 2002-2004 ChatSpike-Dev. -00006 * E-mail: -00007 * <brain@chatspike.net> -00008 * <Craig@chatspike.net> -00009 * -00010 * Written by Craig Edwards, Craig McLure, and others. -00011 * This program is free but copyrighted software; see -00012 * the file COPYING for details. -00013 * -00014 * --------------------------------------------------- -00015 */ -00016 -00017 using namespace std; -00018 -00019 #include "inspircd_config.h" -00020 #include "inspircd.h" -00021 #include "inspircd_io.h" -00022 #include "inspircd_util.h" -00023 #include <unistd.h> -00024 #include <sys/errno.h> -00025 -00026 #ifdef USE_KQUEUE -00027 #include <sys/types.h> -00028 #include <sys/event.h> -00029 #include <sys/time.h> -00030 #endif -00031 -00032 #ifdef USE_EPOLL -00033 #include <sys/epoll.h> -00034 #endif -00035 -00036 #include <time.h> -00037 #include <string> -00038 #ifdef GCC3 -00039 #include <ext/hash_map> -00040 #else -00041 #include <hash_map> -00042 #endif -00043 #include <map> -00044 #include <sstream> -00045 #include <vector> -00046 #include <deque> -00047 #include "connection.h" -00048 #include "users.h" -00049 #include "servers.h" -00050 #include "ctables.h" -00051 #include "globals.h" -00052 #include "modules.h" -00053 #include "dynamic.h" -00054 #include "wildcard.h" -00055 #include "message.h" -00056 #include "mode.h" -00057 #include "xline.h" -00058 #include "commands.h" -00059 #include "inspstring.h" -00060 #include "helperfuncs.h" -00061 #include "hashcomp.h" -00062 -00063 #ifdef USE_KQUEUE -00064 extern int kq; -00065 #endif -00066 -00067 #ifdef USE_EPOLL -00068 int ep; -00069 #endif -00070 -00071 extern int MODCOUNT; -00072 extern std::vector<Module*> modules; -00073 extern std::vector<ircd_module*> factory; -00074 -00075 extern std::vector<std::string> include_stack; -00076 -00077 extern time_t TIME; -00078 -00079 extern int LogLevel; -00080 extern char ServerName[MAXBUF]; -00081 extern char Network[MAXBUF]; -00082 extern char ServerDesc[MAXBUF]; -00083 extern char AdminName[MAXBUF]; -00084 extern char AdminEmail[MAXBUF]; -00085 extern char AdminNick[MAXBUF]; -00086 extern char diepass[MAXBUF]; -00087 extern char restartpass[MAXBUF]; -00088 extern char motd[MAXBUF]; -00089 extern char rules[MAXBUF]; -00090 extern char list[MAXBUF]; -00091 extern char PrefixQuit[MAXBUF]; -00092 extern char DieValue[MAXBUF]; -00093 -00094 extern int debugging; -00095 extern int WHOWAS_STALE; -00096 extern int WHOWAS_MAX; -00097 extern int DieDelay; -00098 extern time_t startup_time; -00099 extern int NetBufferSize; -00100 extern int MaxWhoResults; -00101 extern time_t nb_start; -00102 -00103 extern std::vector<std::string> module_names; -00104 -00105 extern int boundPortCount; -00106 extern int portCount; -00107 extern int SERVERportCount; -00108 extern int ports[MAXSOCKS]; -00109 extern int defaultRoute; -00110 -00111 extern std::vector<long> auth_cookies; -00112 extern std::stringstream config_f; -00113 -00114 extern serverrec* me[32]; -00115 -00116 extern FILE *log_file; -00117 -00118 extern userrec* fd_ref_table[65536]; -00119 -00120 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash; -00121 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash; -00122 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache; -00123 typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash; -00124 typedef std::deque<command_t> command_table; -00125 -00126 -00127 extern user_hash clientlist; -00128 extern chan_hash chanlist; -00129 extern whowas_hash whowas; -00130 extern command_table cmdlist; -00131 extern file_cache MOTD; -00132 extern file_cache RULES; -00133 extern address_cache IP; -00134 -00135 -00136 // class type for holding an extended mode character - internal to core -00137 -00138 class ExtMode : public classbase -00139 { -00140 public: -00141 char modechar; -00142 int type; -00143 int params_when_on; -00144 int params_when_off; -00145 bool needsoper; -00146 bool list; -00147 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) { }; -00148 }; -00149 -00150 typedef std::vector<ExtMode> ExtModeList; -00151 typedef ExtModeList::iterator ExtModeListIter; -00152 -00153 -00154 ExtModeList EMode; -00155 -00156 // returns true if an extended mode character is in use -00157 bool ModeDefined(char modechar, int type) -00158 { -00159 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00160 { -00161 if ((i->modechar == modechar) && (i->type == type)) -00162 { -00163 return true; -00164 } -00165 } -00166 return false; -00167 } -00168 -00169 bool ModeIsListMode(char modechar, int type) -00170 { -00171 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00172 { -00173 if ((i->modechar == modechar) && (i->type == type) && (i->list == true)) -00174 { -00175 return true; -00176 } -00177 } -00178 return false; -00179 } -00180 -00181 bool ModeDefinedOper(char modechar, int type) -00182 { -00183 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00184 { -00185 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true)) -00186 { -00187 return true; -00188 } -00189 } -00190 return false; -00191 } -00192 -00193 // returns number of parameters for a custom mode when it is switched on -00194 int ModeDefinedOn(char modechar, int type) -00195 { -00196 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00197 { -00198 if ((i->modechar == modechar) && (i->type == type)) -00199 { -00200 return i->params_when_on; -00201 } -00202 } -00203 return 0; -00204 } -00205 -00206 // returns number of parameters for a custom mode when it is switched on -00207 int ModeDefinedOff(char modechar, int type) -00208 { -00209 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00210 { -00211 if ((i->modechar == modechar) && (i->type == type)) -00212 { -00213 return i->params_when_off; -00214 } -00215 } -00216 return 0; -00217 } -00218 -00219 // returns true if an extended mode character is in use -00220 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off) -00221 { -00222 if (ModeDefined(modechar,type)) { -00223 return false; -00224 } -00225 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off)); -00226 return true; -00227 } -00228 -00229 // turns a mode into a listmode -00230 void ModeMakeList(char modechar) -00231 { -00232 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) -00233 { -00234 if ((i->modechar == modechar) && (i->type == MT_CHANNEL)) -00235 { -00236 i->list = true; -00237 return; -00238 } -00239 } -00240 return; -00241 } -00242 -00243 // version is a simple class for holding a modules version number -00244 -00245 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { }; -00246 -00247 // admin is a simple class for holding a server's administrative info -00248 -00249 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { }; -00250 -00251 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { }; -00252 -00253 char* Request::GetData() -00254 { -00255 return this->data; -00256 } -00257 -00258 Module* Request::GetSource() -00259 { -00260 return this->source; -00261 } -00262 -00263 Module* Request::GetDest() -00264 { -00265 return this->dest; -00266 } -00267 -00268 char* Request::Send() -00269 { -00270 if (this->dest) -00271 { -00272 return dest->OnRequest(this); -00273 } -00274 else -00275 { -00276 return NULL; -00277 } -00278 } -00279 -00280 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { }; -00281 -00282 char* Event::GetData() -00283 { -00284 return this->data; -00285 } -00286 -00287 Module* Event::GetSource() -00288 { -00289 return this->source; -00290 } -00291 -00292 char* Event::Send() -00293 { -00294 FOREACH_MOD OnEvent(this); -00295 return NULL; -00296 } -00297 -00298 std::string Event::GetEventID() -00299 { -00300 return this->id; -00301 } -00302 -00303 -00304 // These declarations define the behavours of the base class Module (which does nothing at all) -00305 Module::Module() { } -00306 Module::~Module() { } -00307 void Module::OnUserConnect(userrec* user) { } -00308 void Module::OnUserQuit(userrec* user) { } -00309 void Module::OnUserDisconnect(userrec* user) { } -00310 void Module::OnUserJoin(userrec* user, chanrec* channel) { } -00311 void Module::OnUserPart(userrec* user, chanrec* channel) { } -00312 void Module::OnPacketTransmit(std::string &data, std::string serv) { } -00313 void Module::OnPacketReceive(std::string &data, std::string serv) { } -00314 void Module::OnRehash() { } -00315 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { } -00316 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; } -00317 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; } -00318 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); } -00319 void Module::OnOper(userrec* user) { }; -00320 void Module::OnInfo(userrec* user) { }; -00321 void Module::OnWhois(userrec* source, userrec* dest) { }; -00322 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; }; -00323 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; -00324 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; -00325 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; }; -00326 void Module::OnUserPostNick(userrec* user, std::string oldnick) { }; -00327 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; }; -00328 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; } -00329 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; } -00330 void Module::On005Numeric(std::string &output) { }; -00331 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; }; -00332 void Module::OnLoadModule(Module* mod,std::string name) { }; -00333 void Module::OnBackgroundTimer(time_t curtime) { }; -00334 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { }; -00335 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; }; -00336 bool Module::OnCheckReady(userrec* user) { return true; }; -00337 void Module::OnUserRegister(userrec* user) { }; -00338 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; }; -00339 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { }; -00340 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; }; -00341 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; }; -00342 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; }; -00343 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; }; -00344 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; }; -00345 void Module::OnStats(char symbol) { }; -00346 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; }; -00347 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; }; -00348 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; }; -00349 int Module::OnMeshToken(char token,string_list params,serverrec* source,serverrec* reply, std::string tcp_host,std::string ipaddr,int port) { return 0; }; -00350 void Module::OnEvent(Event* event) { return; }; -00351 char* Module::OnRequest(Request* request) { return NULL; }; -00352 int Module::OnOperCompare(std::string password, std::string input) { return 0; }; -00353 void Module::OnGlobalOper(userrec* user) { }; -00354 void Module::OnGlobalConnect(userrec* user) { }; -00355 int Module::OnAddBan(userrec* source, chanrec* channel,std::string banmask) { return 0; }; -00356 int Module::OnDelBan(userrec* source, chanrec* channel,std::string banmask) { return 0; }; -00357 void Module::OnRawSocketAccept(int fd, std::string ip, int localport) { }; -00358 int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; }; -00359 void Module::OnRawSocketClose(int fd) { }; -00360 int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; }; -00361 -00362 // server is a wrapper class that provides methods to all of the C-style -00363 // exports in the core -00364 // -00365 -00366 Server::Server() -00367 { -00368 } -00369 -00370 Server::~Server() -00371 { -00372 } -00373 -00374 void Server::SendOpers(std::string s) -00375 { -00376 WriteOpers("%s",s.c_str()); -00377 } -00378 -00379 bool Server::MatchText(std::string sliteral, std::string spattern) -00380 { -00381 char literal[MAXBUF],pattern[MAXBUF]; -00382 strlcpy(literal,sliteral.c_str(),MAXBUF); -00383 strlcpy(pattern,spattern.c_str(),MAXBUF); -00384 return match(literal,pattern); -00385 } -00386 -00387 void Server::SendToModeMask(std::string modes, int flags, std::string text) -00388 { -00389 WriteMode(modes.c_str(),flags,"%s",text.c_str()); -00390 } -00391 -00392 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key) -00393 { -00394 return add_channel(user,cname.c_str(),key.c_str(),false); -00395 } -00396 -00397 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason) -00398 { -00399 return del_channel(user,cname.c_str(),reason.c_str(),false); -00400 } -00401 -00402 chanuserlist Server::GetUsers(chanrec* chan) -00403 { -00404 chanuserlist userl; -00405 userl.clear(); -00406 std::vector<char*> *list = chan->GetUsers(); -00407 for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++) -00408 { -00409 char* o = *i; -00410 userl.push_back((userrec*)o); -00411 } -00412 return userl; -00413 } -00414 void Server::ChangeUserNick(userrec* user, std::string nickname) -00415 { -00416 force_nickchange(user,nickname.c_str()); -00417 } -00418 -00419 void Server::QuitUser(userrec* user, std::string reason) -00420 { -00421 kill_link(user,reason.c_str()); -00422 } -00423 -00424 bool Server::IsUlined(std::string server) -00425 { -00426 return is_uline(server.c_str()); -00427 } -00428 -00429 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user) -00430 { -00431 call_handler(commandname.c_str(),parameters,pcnt,user); -00432 } -00433 -00434 void Server::Log(int level, std::string s) -00435 { -00436 log(level,"%s",s.c_str()); -00437 } -00438 -00439 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source) -00440 { -00441 createcommand(cmd,f,flags,minparams,source); -00442 } -00443 -00444 void Server::SendMode(char **parameters, int pcnt, userrec *user) -00445 { -00446 server_mode(parameters,pcnt,user); -00447 } -00448 -00449 void Server::Send(int Socket, std::string s) -00450 { -00451 Write(Socket,"%s",s.c_str()); -00452 } -00453 -00454 void Server::SendServ(int Socket, std::string s) -00455 { -00456 WriteServ(Socket,"%s",s.c_str()); -00457 } -00458 -00459 void Server::SendFrom(int Socket, userrec* User, std::string s) -00460 { -00461 WriteFrom(Socket,User,"%s",s.c_str()); -00462 } -00463 -00464 void Server::SendTo(userrec* Source, userrec* Dest, std::string s) -00465 { -00466 if (!Source) -00467 { -00468 // if source is NULL, then the message originates from the local server -00469 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str()); -00470 } -00471 else -00472 { -00473 // otherwise it comes from the user specified -00474 WriteTo(Source,Dest,"%s",s.c_str()); -00475 } -00476 } -00477 -00478 void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text) -00479 { -00480 WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str()); -00481 } -00482 -00483 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender) -00484 { -00485 if (IncludeSender) -00486 { -00487 WriteChannel(Channel,User,"%s",s.c_str()); -00488 } -00489 else -00490 { -00491 ChanExceptSender(Channel,User,"%s",s.c_str()); -00492 } -00493 } -00494 -00495 bool Server::CommonChannels(userrec* u1, userrec* u2) -00496 { -00497 return (common_channels(u1,u2) != 0); -00498 } -00499 -00500 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) -00501 { -00502 if (IncludeSender) -00503 { -00504 WriteCommon(User,"%s",text.c_str()); -00505 } -00506 else -00507 { -00508 WriteCommonExcept(User,"%s",text.c_str()); -00509 } -00510 } -00511 -00512 void Server::SendWallops(userrec* User, std::string text) -00513 { -00514 WriteWallOps(User,false,"%s",text.c_str()); -00515 } -00516 -00517 void Server::ChangeHost(userrec* user, std::string host) -00518 { -00519 ChangeDisplayedHost(user,host.c_str()); -00520 } -00521 -00522 void Server::ChangeGECOS(userrec* user, std::string gecos) -00523 { -00524 ChangeName(user,gecos.c_str()); -00525 } -00526 -00527 bool Server::IsNick(std::string nick) -00528 { -00529 return (isnick(nick.c_str()) != 0); -00530 } -00531 -00532 userrec* Server::FindNick(std::string nick) -00533 { -00534 return Find(nick); -00535 } -00536 -00537 userrec* Server::FindDescriptor(int socket) -00538 { -00539 return (socket < 65536 ? fd_ref_table[socket] : NULL); -00540 } -00541 -00542 chanrec* Server::FindChannel(std::string channel) -00543 { -00544 return FindChan(channel.c_str()); -00545 } -00546 -00547 std::string Server::ChanMode(userrec* User, chanrec* Chan) -00548 { -00549 return cmode(User,Chan); -00550 } -00551 -00552 bool Server::IsOnChannel(userrec* User, chanrec* Chan) -00553 { -00554 return has_channel(User,Chan); -00555 } -00556 -00557 std::string Server::GetServerName() -00558 { -00559 return getservername(); -00560 } -00561 -00562 std::string Server::GetNetworkName() -00563 { -00564 return getnetworkname(); -00565 } -00566 -00567 std::string Server::GetServerDescription() -00568 { -00569 return getserverdesc(); -00570 } -00571 -00572 Admin Server::GetAdmin() -00573 { -00574 return Admin(getadminname(),getadminemail(),getadminnick()); -00575 } -00576 -00577 -00578 -00579 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off) -00580 { -00581 if (((modechar >= 'A') && (modechar <= 'Z')) || ((modechar >= 'a') && (modechar <= 'z'))) -00582 { -00583 if (type == MT_SERVER) -00584 { -00585 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion"); -00586 return false; -00587 } -00588 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT)) -00589 { -00590 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported"); -00591 return false; -00592 } -00593 if ((params_when_on>1) || (params_when_off>1)) -00594 { -00595 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported"); -00596 return false; -00597 } -00598 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off); -00599 } -00600 else -00601 { -00602 log(DEBUG,"*** API ERROR *** Muppet modechar detected."); -00603 } -00604 return false; -00605 } -00606 -00607 bool Server::AddExtendedListMode(char modechar) -00608 { -00609 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1); -00610 if (res) -00611 ModeMakeList(modechar); -00612 return res; -00613 } -00614 -00615 int Server::CountUsers(chanrec* c) -00616 { -00617 return usercount(c); -00618 } -00619 -00620 -00621 bool Server::UserToPseudo(userrec* user,std::string message) -00622 { -00623 unsigned int old_fd = user->fd; -00624 user->fd = FD_MAGIC_NUMBER; -00625 user->ClearBuffer(); -00626 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str()); -00627 #ifdef USE_KQUEUE -00628 struct kevent ke; -00629 EV_SET(&ke, old_fd, EVFILT_READ, EV_DELETE, 0, 0, NULL); -00630 int i = kevent(kq, &ke, 1, 0, 0, NULL); -00631 if (i == -1) -00632 { -00633 log(DEBUG,"kqueue: Failed to remove user from queue!"); -00634 } -00635 #endif -00636 #ifdef USE_EPOLL -00637 struct epoll_event ev; -00638 ev.events = EPOLLIN | EPOLLET; -00639 ev.data.fd = old_fd; -00640 int i = epoll_ctl(ep, EPOLL_CTL_DEL, old_fd, &ev); -00641 if (i < 0) -00642 { -00643 log(DEBUG,"epoll: List deletion failure!"); -00644 } -00645 #endif -00646 -00647 shutdown(old_fd,2); -00648 close(old_fd); -00649 } -00650 -00651 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message) -00652 { -00653 zombie->fd = alive->fd; -00654 alive->fd = FD_MAGIC_NUMBER; -00655 alive->ClearBuffer(); -00656 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick); -00657 kill_link(alive,message.c_str()); -00658 fd_ref_table[zombie->fd] = zombie; -00659 for (int i = 0; i != MAXCHANS; i++) -00660 { -00661 if (zombie->chans[i].channel != NULL) -00662 { -00663 if (zombie->chans[i].channel->name) -00664 { -00665 chanrec* Ptr = zombie->chans[i].channel; -00666 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name); -00667 if (Ptr->topicset) -00668 { -00669 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic); -00670 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset); -00671 } -00672 userlist(zombie,Ptr); -00673 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name); -00674 -00675 } -00676 } -00677 } -00678 -00679 } -00680 -00681 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask) -00682 { -00683 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); -00684 } -00685 -00686 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname) -00687 { -00688 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str()); -00689 } -00690 -00691 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr) -00692 { -00693 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str()); -00694 } -00695 -00696 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask) -00697 { -00698 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); -00699 } -00700 -00701 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask) -00702 { -00703 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); -00704 } -00705 -00706 bool Server::DelGLine(std::string hostmask) -00707 { -00708 del_gline(hostmask.c_str()); -00709 } -00710 -00711 bool Server::DelQLine(std::string nickname) -00712 { -00713 del_qline(nickname.c_str()); -00714 } -00715 -00716 bool Server::DelZLine(std::string ipaddr) -00717 { -00718 del_zline(ipaddr.c_str()); -00719 } -00720 -00721 bool Server::DelKLine(std::string hostmask) -00722 { -00723 del_kline(hostmask.c_str()); -00724 } -00725 -00726 bool Server::DelELine(std::string hostmask) -00727 { -00728 del_eline(hostmask.c_str()); -00729 } -00730 -00731 long Server::CalcDuration(std::string delta) -00732 { -00733 return duration(delta.c_str()); -00734 } -00735 -00736 bool Server::IsValidMask(std::string mask) -00737 { -00738 const char* dest = mask.c_str(); -00739 if (strchr(dest,'!')==0) -00740 return false; -00741 if (strchr(dest,'@')==0) -00742 return false; -00743 for (int i = 0; i < strlen(dest); i++) -00744 if (dest[i] < 32) -00745 return false; -00746 for (int i = 0; i < strlen(dest); i++) -00747 if (dest[i] > 126) -00748 return false; -00749 int c = 0; -00750 for (int i = 0; i < strlen(dest); i++) -00751 if (dest[i] == '!') -00752 c++; -00753 if (c>1) -00754 return false; -00755 c = 0; -00756 for (int i = 0; i < strlen(dest); i++) -00757 if (dest[i] == '@') -00758 c++; -00759 if (c>1) -00760 return false; -00761 -00762 return true; -00763 } -00764 -00765 void Server::MeshSendAll(std::string text) -00766 { -00767 NetSendToAll((char*)text.c_str()); -00768 } -00769 -00770 void Server::MeshSendCommon(userrec* user, std::string text) -00771 { -00772 if (user) -00773 NetSendToCommon(user,(char*)text.c_str()); -00774 } -00775 -00776 void Server::MeshSendAllAlive(std::string text) -00777 { -00778 NetSendToAllAlive((char*)text.c_str()); -00779 } -00780 -00781 void Server::MeshSendUnicast(std::string destination, std::string text) -00782 { -00783 NetSendToOne((char*)destination.c_str(),(char*)text.c_str()); -00784 } -00785 -00786 void Server::MeshSendAllExcept(std::string target, std::string text) -00787 { -00788 NetSendToAllExcept(target.c_str(),(char*)text.c_str()); -00789 } -00790 -00791 bool Server::MeshCheckChan(chanrec *c,std::string servername) -00792 { -00793 if (c) -00794 { -00795 return ChanAnyOnThisServer(c,(char*)servername.c_str()); -00796 } -00797 else return false; -00798 } -00799 -00800 bool Server::MeshCheckCommon(userrec* u,std::string servername) -00801 { -00802 if (u) -00803 { -00804 return CommonOnThisServer(u,(char*)servername.c_str()); -00805 } -00806 else return false; -00807 } -00808 -00809 Module* Server::FindModule(std::string name) -00810 { -00811 for (int i = 0; i <= MODCOUNT; i++) -00812 { -00813 if (module_names[i] == name) -00814 { -00815 return modules[i]; -00816 } -00817 } -00818 return NULL; -00819 } -00820 -00821 ConfigReader::ConfigReader() -00822 { -00823 include_stack.clear(); -00824 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); -00825 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); -00826 this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog); -00827 if (!this->readerror) -00828 this->error = CONF_FILE_NOT_FOUND; -00829 } -00830 -00831 -00832 ConfigReader::~ConfigReader() -00833 { -00834 if (this->cache) -00835 delete this->cache; -00836 if (this->errorlog) -00837 delete this->errorlog; -00838 } -00839 -00840 -00841 ConfigReader::ConfigReader(std::string filename) -00842 { -00843 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); -00844 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); -00845 this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog); -00846 if (!this->readerror) -00847 this->error = CONF_FILE_NOT_FOUND; -00848 }; -00849 -00850 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index) -00851 { -00852 char val[MAXBUF]; -00853 char t[MAXBUF]; -00854 char n[MAXBUF]; -00855 strlcpy(t,tag.c_str(),MAXBUF); -00856 strlcpy(n,name.c_str(),MAXBUF); -00857 int res = ReadConf(cache,t,n,index,val); -00858 if (!res) -00859 { -00860 this->error = CONF_VALUE_NOT_FOUND; -00861 return ""; -00862 } -00863 return val; -00864 } -00865 -00866 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index) -00867 { -00868 char val[MAXBUF]; -00869 char t[MAXBUF]; -00870 char n[MAXBUF]; -00871 strlcpy(t,tag.c_str(),MAXBUF); -00872 strlcpy(n,name.c_str(),MAXBUF); -00873 int res = ReadConf(cache,t,n,index,val); -00874 if (!res) -00875 { -00876 this->error = CONF_VALUE_NOT_FOUND; -00877 return false; -00878 } -00879 std::string s = val; -00880 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1")); -00881 } -00882 -00883 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned) -00884 { -00885 char val[MAXBUF]; -00886 char t[MAXBUF]; -00887 char n[MAXBUF]; -00888 strlcpy(t,tag.c_str(),MAXBUF); -00889 strlcpy(n,name.c_str(),MAXBUF); -00890 int res = ReadConf(cache,t,n,index,val); -00891 if (!res) -00892 { -00893 this->error = CONF_VALUE_NOT_FOUND; -00894 return 0; -00895 } -00896 for (int i = 0; i < strlen(val); i++) -00897 { -00898 if (!isdigit(val[i])) -00899 { -00900 this->error = CONF_NOT_A_NUMBER; -00901 return 0; -00902 } -00903 } -00904 if ((needs_unsigned) && (atoi(val)<0)) -00905 { -00906 this->error = CONF_NOT_UNSIGNED; -00907 return 0; -00908 } -00909 return atoi(val); -00910 } -00911 -00912 long ConfigReader::GetError() -00913 { -00914 long olderr = this->error; -00915 this->error = 0; -00916 return olderr; -00917 } -00918 -00919 void ConfigReader::DumpErrors(bool bail, userrec* user) -00920 { -00921 if (bail) -00922 { -00923 printf("There were errors in your configuration:\n%s",errorlog->str().c_str()); -00924 exit(0); -00925 } -00926 else -00927 { -00928 char dataline[1024]; -00929 if (user) -00930 { -00931 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick); -00932 while (!errorlog->eof()) -00933 { -00934 errorlog->getline(dataline,1024); -00935 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline); -00936 } -00937 } -00938 else -00939 { -00940 WriteOpers("There were errors in the configuration file:",user->nick); -00941 while (!errorlog->eof()) -00942 { -00943 errorlog->getline(dataline,1024); -00944 WriteOpers(dataline); -00945 } -00946 } -00947 return; -00948 } -00949 } -00950 -00951 -00952 int ConfigReader::Enumerate(std::string tag) -00953 { -00954 return EnumConf(cache,tag.c_str()); -00955 } -00956 -00957 int ConfigReader::EnumerateValues(std::string tag, int index) -00958 { -00959 return EnumValues(cache, tag.c_str(), index); -00960 } -00961 -00962 bool ConfigReader::Verify() -00963 { -00964 return this->readerror; -00965 } -00966 -00967 -00968 FileReader::FileReader(std::string filename) -00969 { -00970 file_cache c; -00971 readfile(c,filename.c_str()); -00972 this->fc = c; -00973 } -00974 -00975 FileReader::FileReader() -00976 { -00977 } -00978 -00979 void FileReader::LoadFile(std::string filename) -00980 { -00981 file_cache c; -00982 readfile(c,filename.c_str()); -00983 this->fc = c; -00984 } -00985 -00986 -00987 FileReader::~FileReader() -00988 { -00989 } -00990 -00991 bool FileReader::Exists() -00992 { -00993 if (fc.size() == 0) -00994 { -00995 return(false); -00996 } -00997 else -00998 { -00999 return(true); -01000 } -01001 } -01002 -01003 std::string FileReader::GetLine(int x) -01004 { -01005 if ((x<0) || (x>fc.size())) -01006 return ""; -01007 return fc[x]; -01008 } -01009 -01010 int FileReader::FileSize() -01011 { -01012 return fc.size(); -01013 } -01014 -01015 -01016 std::vector<Module*> modules(255); -01017 std::vector<ircd_module*> factory(255); -01018 -01019 int MODCOUNT = -1; -01020 -01021 -
00001 /* +------------------------------------+ +00002 * | Inspire Internet Relay Chat Daemon | +00003 * +------------------------------------+ +00004 * +00005 * Inspire is copyright (C) 2002-2004 ChatSpike-Dev. +00006 * E-mail: +00007 * <brain@chatspike.net> +00008 * <Craig@chatspike.net> +00009 * +00010 * Written by Craig Edwards, Craig McLure, and others. +00011 * This program is free but copyrighted software; see +00012 * the file COPYING for details. +00013 * +00014 * --------------------------------------------------- +00015 */ +00016 +00017 using namespace std; +00018 +00019 #include "inspircd_config.h" +00020 #include "inspircd.h" +00021 #include "inspircd_io.h" +00022 #include "inspircd_util.h" +00023 #include <unistd.h> +00024 #include <sys/errno.h> +00025 +00026 #ifdef USE_KQUEUE +00027 #include <sys/types.h> +00028 #include <sys/event.h> +00029 #include <sys/time.h> +00030 #endif +00031 +00032 #ifdef USE_EPOLL +00033 #include <sys/epoll.h> +00034 #endif +00035 +00036 #include <time.h> +00037 #include <string> +00038 #ifdef GCC3 +00039 #include <ext/hash_map> +00040 #else +00041 #include <hash_map> +00042 #endif +00043 #include <map> +00044 #include <sstream> +00045 #include <vector> +00046 #include <deque> +00047 #include "users.h" +00048 #include "ctables.h" +00049 #include "globals.h" +00050 #include "modules.h" +00051 #include "dynamic.h" +00052 #include "wildcard.h" +00053 #include "message.h" +00054 #include "mode.h" +00055 #include "xline.h" +00056 #include "commands.h" +00057 #include "inspstring.h" +00058 #include "helperfuncs.h" +00059 #include "hashcomp.h" +00060 #include "socket.h" +00061 +00062 #ifdef USE_KQUEUE +00063 extern int kq; +00064 #endif +00065 +00066 #ifdef USE_EPOLL +00067 int ep; +00068 #endif +00069 +00070 extern int MODCOUNT; +00071 extern std::vector<Module*> modules; +00072 extern std::vector<ircd_module*> factory; +00073 +00074 extern std::vector<std::string> include_stack; +00075 +00076 extern std::vector<InspSocket*> module_sockets; +00077 +00078 extern time_t TIME; +00079 +00080 extern int LogLevel; +00081 extern char ServerName[MAXBUF]; +00082 extern char Network[MAXBUF]; +00083 extern char ServerDesc[MAXBUF]; +00084 extern char AdminName[MAXBUF]; +00085 extern char AdminEmail[MAXBUF]; +00086 extern char AdminNick[MAXBUF]; +00087 extern char diepass[MAXBUF]; +00088 extern char restartpass[MAXBUF]; +00089 extern char motd[MAXBUF]; +00090 extern char rules[MAXBUF]; +00091 extern char list[MAXBUF]; +00092 extern char PrefixQuit[MAXBUF]; +00093 extern char DieValue[MAXBUF]; +00094 +00095 extern int debugging; +00096 extern int WHOWAS_STALE; +00097 extern int WHOWAS_MAX; +00098 extern int DieDelay; +00099 extern time_t startup_time; +00100 extern int NetBufferSize; +00101 extern int MaxWhoResults; +00102 extern time_t nb_start; +00103 +00104 extern std::vector<std::string> module_names; +00105 +00106 extern int boundPortCount; +00107 extern int portCount; +00108 +00109 extern int ports[MAXSOCKS]; +00110 +00111 +00112 +00113 extern std::stringstream config_f; +00114 +00115 +00116 +00117 extern FILE *log_file; +00118 +00119 extern userrec* fd_ref_table[65536]; +00120 +00121 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, irc::StrHashComp> user_hash; +00122 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, irc::StrHashComp> chan_hash; +00123 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, irc::InAddr_HashComp> address_cache; +00124 typedef nspace::hash_map<std::string, WhoWasUser*, nspace::hash<string>, irc::StrHashComp> whowas_hash; +00125 typedef std::deque<command_t> command_table; +00126 +00127 +00128 extern user_hash clientlist; +00129 extern chan_hash chanlist; +00130 extern whowas_hash whowas; +00131 extern command_table cmdlist; +00132 extern file_cache MOTD; +00133 extern file_cache RULES; +00134 extern address_cache IP; +00135 +00136 +00137 // class type for holding an extended mode character - internal to core +00138 +00139 class ExtMode : public classbase +00140 { +00141 public: +00142 char modechar; +00143 int type; +00144 bool needsoper; +00145 int params_when_on; +00146 int params_when_off; +00147 bool list; +00148 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) { }; +00149 }; +00150 +00151 typedef std::vector<ExtMode> ExtModeList; +00152 typedef ExtModeList::iterator ExtModeListIter; +00153 +00154 +00155 ExtModeList EMode; +00156 +00157 // returns true if an extended mode character is in use +00158 bool ModeDefined(char modechar, int type) +00159 { +00160 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00161 { +00162 if ((i->modechar == modechar) && (i->type == type)) +00163 { +00164 return true; +00165 } +00166 } +00167 return false; +00168 } +00169 +00170 bool ModeIsListMode(char modechar, int type) +00171 { +00172 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00173 { +00174 if ((i->modechar == modechar) && (i->type == type) && (i->list == true)) +00175 { +00176 return true; +00177 } +00178 } +00179 return false; +00180 } +00181 +00182 bool ModeDefinedOper(char modechar, int type) +00183 { +00184 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00185 { +00186 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true)) +00187 { +00188 return true; +00189 } +00190 } +00191 return false; +00192 } +00193 +00194 // returns number of parameters for a custom mode when it is switched on +00195 int ModeDefinedOn(char modechar, int type) +00196 { +00197 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00198 { +00199 if ((i->modechar == modechar) && (i->type == type)) +00200 { +00201 return i->params_when_on; +00202 } +00203 } +00204 return 0; +00205 } +00206 +00207 // returns number of parameters for a custom mode when it is switched on +00208 int ModeDefinedOff(char modechar, int type) +00209 { +00210 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00211 { +00212 if ((i->modechar == modechar) && (i->type == type)) +00213 { +00214 return i->params_when_off; +00215 } +00216 } +00217 return 0; +00218 } +00219 +00220 // returns true if an extended mode character is in use +00221 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off) +00222 { +00223 if (ModeDefined(modechar,type)) { +00224 return false; +00225 } +00226 EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off)); +00227 return true; +00228 } +00229 +00230 // turns a mode into a listmode +00231 void ModeMakeList(char modechar) +00232 { +00233 for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++) +00234 { +00235 if ((i->modechar == modechar) && (i->type == MT_CHANNEL)) +00236 { +00237 i->list = true; +00238 return; +00239 } +00240 } +00241 return; +00242 } +00243 +00244 // version is a simple class for holding a modules version number +00245 +00246 Version::Version(int major, int minor, int revision, int build, int flags) : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags) { }; +00247 +00248 // admin is a simple class for holding a server's administrative info +00249 +00250 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { }; +00251 +00252 Request::Request(char* anydata, Module* src, Module* dst) : data(anydata), source(src), dest(dst) { }; +00253 +00254 char* Request::GetData() +00255 { +00256 return this->data; +00257 } +00258 +00259 Module* Request::GetSource() +00260 { +00261 return this->source; +00262 } +00263 +00264 Module* Request::GetDest() +00265 { +00266 return this->dest; +00267 } +00268 +00269 char* Request::Send() +00270 { +00271 if (this->dest) +00272 { +00273 return dest->OnRequest(this); +00274 } +00275 else +00276 { +00277 return NULL; +00278 } +00279 } +00280 +00281 Event::Event(char* anydata, Module* src, std::string eventid) : data(anydata), source(src), id(eventid) { }; +00282 +00283 char* Event::GetData() +00284 { +00285 return this->data; +00286 } +00287 +00288 Module* Event::GetSource() +00289 { +00290 return this->source; +00291 } +00292 +00293 char* Event::Send() +00294 { +00295 FOREACH_MOD OnEvent(this); +00296 return NULL; +00297 } +00298 +00299 std::string Event::GetEventID() +00300 { +00301 return this->id; +00302 } +00303 +00304 +00305 // These declarations define the behavours of the base class Module (which does nothing at all) +00306 Module::Module() { } +00307 Module::~Module() { } +00308 void Module::OnUserConnect(userrec* user) { } +00309 void Module::OnUserQuit(userrec* user) { } +00310 void Module::OnUserDisconnect(userrec* user) { } +00311 void Module::OnUserJoin(userrec* user, chanrec* channel) { } +00312 void Module::OnUserPart(userrec* user, chanrec* channel) { } +00313 void Module::OnPacketTransmit(std::string &data, std::string serv) { } +00314 void Module::OnPacketReceive(std::string &data, std::string serv) { } +00315 void Module::OnRehash() { } +00316 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { } +00317 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; } +00318 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list ¶ms) { return false; } +00319 Version Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); } +00320 void Module::OnOper(userrec* user) { }; +00321 void Module::OnInfo(userrec* user) { }; +00322 void Module::OnWhois(userrec* source, userrec* dest) { }; +00323 int Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; }; +00324 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; +00325 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text) { return 0; }; +00326 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; }; +00327 void Module::OnUserPostNick(userrec* user, std::string oldnick) { }; +00328 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; }; +00329 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; } +00330 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; } +00331 void Module::On005Numeric(std::string &output) { }; +00332 int Module::OnKill(userrec* source, userrec* dest, std::string reason) { return 0; }; +00333 void Module::OnLoadModule(Module* mod,std::string name) { }; +00334 void Module::OnUnloadModule(Module* mod,std::string name) { }; +00335 void Module::OnBackgroundTimer(time_t curtime) { }; +00336 void Module::OnSendList(userrec* user, chanrec* channel, char mode) { }; +00337 int Module::OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user) { return 0; }; +00338 bool Module::OnCheckReady(userrec* user) { return true; }; +00339 void Module::OnUserRegister(userrec* user) { }; +00340 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; }; +00341 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { }; +00342 int Module::OnRawMode(userrec* user, chanrec* chan, char mode, std::string param, bool adding, int pcnt) { return 0; }; +00343 int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; }; +00344 int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; }; +00345 int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; }; +00346 int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; }; +00347 void Module::OnStats(char symbol) { }; +00348 int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; }; +00349 int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; }; +00350 int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; }; +00351 void Module::OnEvent(Event* event) { return; }; +00352 char* Module::OnRequest(Request* request) { return NULL; }; +00353 int Module::OnOperCompare(std::string password, std::string input) { return 0; }; +00354 void Module::OnGlobalOper(userrec* user) { }; +00355 void Module::OnGlobalConnect(userrec* user) { }; +00356 int Module::OnAddBan(userrec* source, chanrec* channel,std::string banmask) { return 0; }; +00357 int Module::OnDelBan(userrec* source, chanrec* channel,std::string banmask) { return 0; }; +00358 void Module::OnRawSocketAccept(int fd, std::string ip, int localport) { }; +00359 int Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; }; +00360 void Module::OnRawSocketClose(int fd) { }; +00361 int Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; }; +00362 +00363 // server is a wrapper class that provides methods to all of the C-style +00364 // exports in the core +00365 // +00366 +00367 Server::Server() +00368 { +00369 } +00370 +00371 Server::~Server() +00372 { +00373 } +00374 +00375 void Server::AddSocket(InspSocket* sock) +00376 { +00377 module_sockets.push_back(sock); +00378 } +00379 +00380 void Server::DelSocket(InspSocket* sock) +00381 { +00382 for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++) +00383 { +00384 if (*a == sock) +00385 { +00386 module_sockets.erase(a); +00387 return; +00388 } +00389 } +00390 } +00391 +00392 void Server::SendOpers(std::string s) +00393 { +00394 WriteOpers("%s",s.c_str()); +00395 } +00396 +00397 bool Server::MatchText(std::string sliteral, std::string spattern) +00398 { +00399 char literal[MAXBUF],pattern[MAXBUF]; +00400 strlcpy(literal,sliteral.c_str(),MAXBUF); +00401 strlcpy(pattern,spattern.c_str(),MAXBUF); +00402 return match(literal,pattern); +00403 } +00404 +00405 void Server::SendToModeMask(std::string modes, int flags, std::string text) +00406 { +00407 WriteMode(modes.c_str(),flags,"%s",text.c_str()); +00408 } +00409 +00410 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key) +00411 { +00412 return add_channel(user,cname.c_str(),key.c_str(),false); +00413 } +00414 +00415 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason) +00416 { +00417 return del_channel(user,cname.c_str(),reason.c_str(),false); +00418 } +00419 +00420 chanuserlist Server::GetUsers(chanrec* chan) +00421 { +00422 chanuserlist userl; +00423 userl.clear(); +00424 std::vector<char*> *list = chan->GetUsers(); +00425 for (std::vector<char*>::iterator i = list->begin(); i != list->end(); i++) +00426 { +00427 char* o = *i; +00428 userl.push_back((userrec*)o); +00429 } +00430 return userl; +00431 } +00432 void Server::ChangeUserNick(userrec* user, std::string nickname) +00433 { +00434 force_nickchange(user,nickname.c_str()); +00435 } +00436 +00437 void Server::QuitUser(userrec* user, std::string reason) +00438 { +00439 kill_link(user,reason.c_str()); +00440 } +00441 +00442 bool Server::IsUlined(std::string server) +00443 { +00444 return is_uline(server.c_str()); +00445 } +00446 +00447 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user) +00448 { +00449 call_handler(commandname.c_str(),parameters,pcnt,user); +00450 } +00451 +00452 void Server::Log(int level, std::string s) +00453 { +00454 log(level,"%s",s.c_str()); +00455 } +00456 +00457 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams, char* source) +00458 { +00459 createcommand(cmd,f,flags,minparams,source); +00460 } +00461 +00462 void Server::SendMode(char **parameters, int pcnt, userrec *user) +00463 { +00464 server_mode(parameters,pcnt,user); +00465 } +00466 +00467 void Server::Send(int Socket, std::string s) +00468 { +00469 Write(Socket,"%s",s.c_str()); +00470 } +00471 +00472 void Server::SendServ(int Socket, std::string s) +00473 { +00474 WriteServ(Socket,"%s",s.c_str()); +00475 } +00476 +00477 void Server::SendFrom(int Socket, userrec* User, std::string s) +00478 { +00479 WriteFrom(Socket,User,"%s",s.c_str()); +00480 } +00481 +00482 void Server::SendTo(userrec* Source, userrec* Dest, std::string s) +00483 { +00484 if (!Source) +00485 { +00486 // if source is NULL, then the message originates from the local server +00487 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str()); +00488 } +00489 else +00490 { +00491 // otherwise it comes from the user specified +00492 WriteTo(Source,Dest,"%s",s.c_str()); +00493 } +00494 } +00495 +00496 void Server::SendChannelServerNotice(std::string ServName, chanrec* Channel, std::string text) +00497 { +00498 WriteChannelWithServ((char*)ServName.c_str(), Channel, "%s", text.c_str()); +00499 } +00500 +00501 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender) +00502 { +00503 if (IncludeSender) +00504 { +00505 WriteChannel(Channel,User,"%s",s.c_str()); +00506 } +00507 else +00508 { +00509 ChanExceptSender(Channel,User,"%s",s.c_str()); +00510 } +00511 } +00512 +00513 bool Server::CommonChannels(userrec* u1, userrec* u2) +00514 { +00515 return (common_channels(u1,u2) != 0); +00516 } +00517 +00518 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender) +00519 { +00520 if (IncludeSender) +00521 { +00522 WriteCommon(User,"%s",text.c_str()); +00523 } +00524 else +00525 { +00526 WriteCommonExcept(User,"%s",text.c_str()); +00527 } +00528 } +00529 +00530 void Server::SendWallops(userrec* User, std::string text) +00531 { +00532 WriteWallOps(User,false,"%s",text.c_str()); +00533 } +00534 +00535 void Server::ChangeHost(userrec* user, std::string host) +00536 { +00537 ChangeDisplayedHost(user,host.c_str()); +00538 } +00539 +00540 void Server::ChangeGECOS(userrec* user, std::string gecos) +00541 { +00542 ChangeName(user,gecos.c_str()); +00543 } +00544 +00545 bool Server::IsNick(std::string nick) +00546 { +00547 return (isnick(nick.c_str()) != 0); +00548 } +00549 +00550 userrec* Server::FindNick(std::string nick) +00551 { +00552 return Find(nick); +00553 } +00554 +00555 userrec* Server::FindDescriptor(int socket) +00556 { +00557 return (socket < 65536 ? fd_ref_table[socket] : NULL); +00558 } +00559 +00560 chanrec* Server::FindChannel(std::string channel) +00561 { +00562 return FindChan(channel.c_str()); +00563 } +00564 +00565 std::string Server::ChanMode(userrec* User, chanrec* Chan) +00566 { +00567 return cmode(User,Chan); +00568 } +00569 +00570 bool Server::IsOnChannel(userrec* User, chanrec* Chan) +00571 { +00572 return has_channel(User,Chan); +00573 } +00574 +00575 std::string Server::GetServerName() +00576 { +00577 return getservername(); +00578 } +00579 +00580 std::string Server::GetNetworkName() +00581 { +00582 return getnetworkname(); +00583 } +00584 +00585 std::string Server::GetServerDescription() +00586 { +00587 return getserverdesc(); +00588 } +00589 +00590 Admin Server::GetAdmin() +00591 { +00592 return Admin(getadminname(),getadminemail(),getadminnick()); +00593 } +00594 +00595 +00596 +00597 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off) +00598 { +00599 if (((modechar >= 'A') && (modechar <= 'Z')) || ((modechar >= 'a') && (modechar <= 'z'))) +00600 { +00601 if (type == MT_SERVER) +00602 { +00603 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion"); +00604 return false; +00605 } +00606 if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT)) +00607 { +00608 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported"); +00609 return false; +00610 } +00611 if ((params_when_on>1) || (params_when_off>1)) +00612 { +00613 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported"); +00614 return false; +00615 } +00616 return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off); +00617 } +00618 else +00619 { +00620 log(DEBUG,"*** API ERROR *** Muppet modechar detected."); +00621 } +00622 return false; +00623 } +00624 +00625 bool Server::AddExtendedListMode(char modechar) +00626 { +00627 bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1); +00628 if (res) +00629 ModeMakeList(modechar); +00630 return res; +00631 } +00632 +00633 int Server::CountUsers(chanrec* c) +00634 { +00635 return usercount(c); +00636 } +00637 +00638 +00639 bool Server::UserToPseudo(userrec* user,std::string message) +00640 { +00641 unsigned int old_fd = user->fd; +00642 user->fd = FD_MAGIC_NUMBER; +00643 user->ClearBuffer(); +00644 Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str()); +00645 #ifdef USE_KQUEUE +00646 struct kevent ke; +00647 EV_SET(&ke, old_fd, EVFILT_READ, EV_DELETE, 0, 0, NULL); +00648 int i = kevent(kq, &ke, 1, 0, 0, NULL); +00649 if (i == -1) +00650 { +00651 log(DEBUG,"kqueue: Failed to remove user from queue!"); +00652 } +00653 #endif +00654 #ifdef USE_EPOLL +00655 struct epoll_event ev; +00656 ev.events = EPOLLIN | EPOLLET; +00657 ev.data.fd = old_fd; +00658 int i = epoll_ctl(ep, EPOLL_CTL_DEL, old_fd, &ev); +00659 if (i < 0) +00660 { +00661 log(DEBUG,"epoll: List deletion failure!"); +00662 } +00663 #endif +00664 +00665 shutdown(old_fd,2); +00666 close(old_fd); +00667 return true; +00668 } +00669 +00670 bool Server::PseudoToUser(userrec* alive,userrec* zombie,std::string message) +00671 { +00672 zombie->fd = alive->fd; +00673 alive->fd = FD_MAGIC_NUMBER; +00674 alive->ClearBuffer(); +00675 Write(zombie->fd,":%s!%s@%s NICK %s",alive->nick,alive->ident,alive->host,zombie->nick); +00676 kill_link(alive,message.c_str()); +00677 fd_ref_table[zombie->fd] = zombie; +00678 for (int i = 0; i != MAXCHANS; i++) +00679 { +00680 if (zombie->chans[i].channel != NULL) +00681 { +00682 if (zombie->chans[i].channel->name) +00683 { +00684 chanrec* Ptr = zombie->chans[i].channel; +00685 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name); +00686 if (Ptr->topicset) +00687 { +00688 WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic); +00689 WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset); +00690 } +00691 userlist(zombie,Ptr); +00692 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name); +00693 +00694 } +00695 } +00696 } +00697 return true; +00698 } +00699 +00700 void Server::AddGLine(long duration, std::string source, std::string reason, std::string hostmask) +00701 { +00702 add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); +00703 } +00704 +00705 void Server::AddQLine(long duration, std::string source, std::string reason, std::string nickname) +00706 { +00707 add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str()); +00708 } +00709 +00710 void Server::AddZLine(long duration, std::string source, std::string reason, std::string ipaddr) +00711 { +00712 add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str()); +00713 } +00714 +00715 void Server::AddKLine(long duration, std::string source, std::string reason, std::string hostmask) +00716 { +00717 add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); +00718 } +00719 +00720 void Server::AddELine(long duration, std::string source, std::string reason, std::string hostmask) +00721 { +00722 add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str()); +00723 } +00724 +00725 bool Server::DelGLine(std::string hostmask) +00726 { +00727 return del_gline(hostmask.c_str()); +00728 } +00729 +00730 bool Server::DelQLine(std::string nickname) +00731 { +00732 return del_qline(nickname.c_str()); +00733 } +00734 +00735 bool Server::DelZLine(std::string ipaddr) +00736 { +00737 return del_zline(ipaddr.c_str()); +00738 } +00739 +00740 bool Server::DelKLine(std::string hostmask) +00741 { +00742 return del_kline(hostmask.c_str()); +00743 } +00744 +00745 bool Server::DelELine(std::string hostmask) +00746 { +00747 return del_eline(hostmask.c_str()); +00748 } +00749 +00750 long Server::CalcDuration(std::string delta) +00751 { +00752 return duration(delta.c_str()); +00753 } +00754 +00755 bool Server::IsValidMask(std::string mask) +00756 { +00757 const char* dest = mask.c_str(); +00758 if (strchr(dest,'!')==0) +00759 return false; +00760 if (strchr(dest,'@')==0) +00761 return false; +00762 for (unsigned int i = 0; i < strlen(dest); i++) +00763 if (dest[i] < 32) +00764 return false; +00765 for (unsigned int i = 0; i < strlen(dest); i++) +00766 if (dest[i] > 126) +00767 return false; +00768 unsigned int c = 0; +00769 for (unsigned int i = 0; i < strlen(dest); i++) +00770 if (dest[i] == '!') +00771 c++; +00772 if (c>1) +00773 return false; +00774 c = 0; +00775 for (unsigned int i = 0; i < strlen(dest); i++) +00776 if (dest[i] == '@') +00777 c++; +00778 if (c>1) +00779 return false; +00780 +00781 return true; +00782 } +00783 +00784 Module* Server::FindModule(std::string name) +00785 { +00786 for (int i = 0; i <= MODCOUNT; i++) +00787 { +00788 if (module_names[i] == name) +00789 { +00790 return modules[i]; +00791 } +00792 } +00793 return NULL; +00794 } +00795 +00796 ConfigReader::ConfigReader() +00797 { +00798 include_stack.clear(); +00799 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); +00800 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); +00801 this->readerror = LoadConf(CONFIG_FILE,this->cache,this->errorlog); +00802 if (!this->readerror) +00803 this->error = CONF_FILE_NOT_FOUND; +00804 } +00805 +00806 +00807 ConfigReader::~ConfigReader() +00808 { +00809 if (this->cache) +00810 delete this->cache; +00811 if (this->errorlog) +00812 delete this->errorlog; +00813 } +00814 +00815 +00816 ConfigReader::ConfigReader(std::string filename) +00817 { +00818 this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out); +00819 this->errorlog = new std::stringstream(std::stringstream::in | std::stringstream::out); +00820 this->readerror = LoadConf(filename.c_str(),this->cache,this->errorlog); +00821 if (!this->readerror) +00822 this->error = CONF_FILE_NOT_FOUND; +00823 }; +00824 +00825 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index) +00826 { +00827 char val[MAXBUF]; +00828 char t[MAXBUF]; +00829 char n[MAXBUF]; +00830 strlcpy(t,tag.c_str(),MAXBUF); +00831 strlcpy(n,name.c_str(),MAXBUF); +00832 int res = ReadConf(cache,t,n,index,val); +00833 if (!res) +00834 { +00835 this->error = CONF_VALUE_NOT_FOUND; +00836 return ""; +00837 } +00838 return val; +00839 } +00840 +00841 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index) +00842 { +00843 char val[MAXBUF]; +00844 char t[MAXBUF]; +00845 char n[MAXBUF]; +00846 strlcpy(t,tag.c_str(),MAXBUF); +00847 strlcpy(n,name.c_str(),MAXBUF); +00848 int res = ReadConf(cache,t,n,index,val); +00849 if (!res) +00850 { +00851 this->error = CONF_VALUE_NOT_FOUND; +00852 return false; +00853 } +00854 std::string s = val; +00855 return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1")); +00856 } +00857 +00858 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned) +00859 { +00860 char val[MAXBUF]; +00861 char t[MAXBUF]; +00862 char n[MAXBUF]; +00863 strlcpy(t,tag.c_str(),MAXBUF); +00864 strlcpy(n,name.c_str(),MAXBUF); +00865 int res = ReadConf(cache,t,n,index,val); +00866 if (!res) +00867 { +00868 this->error = CONF_VALUE_NOT_FOUND; +00869 return 0; +00870 } +00871 for (unsigned int i = 0; i < strlen(val); i++) +00872 { +00873 if (!isdigit(val[i])) +00874 { +00875 this->error = CONF_NOT_A_NUMBER; +00876 return 0; +00877 } +00878 } +00879 if ((needs_unsigned) && (atoi(val)<0)) +00880 { +00881 this->error = CONF_NOT_UNSIGNED; +00882 return 0; +00883 } +00884 return atoi(val); +00885 } +00886 +00887 long ConfigReader::GetError() +00888 { +00889 long olderr = this->error; +00890 this->error = 0; +00891 return olderr; +00892 } +00893 +00894 void ConfigReader::DumpErrors(bool bail, userrec* user) +00895 { +00896 if (bail) +00897 { +00898 printf("There were errors in your configuration:\n%s",errorlog->str().c_str()); +00899 exit(0); +00900 } +00901 else +00902 { +00903 char dataline[1024]; +00904 if (user) +00905 { +00906 WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick); +00907 while (!errorlog->eof()) +00908 { +00909 errorlog->getline(dataline,1024); +00910 WriteServ(user->fd,"NOTICE %s :%s",user->nick,dataline); +00911 } +00912 } +00913 else +00914 { +00915 WriteOpers("There were errors in the configuration file:",user->nick); +00916 while (!errorlog->eof()) +00917 { +00918 errorlog->getline(dataline,1024); +00919 WriteOpers(dataline); +00920 } +00921 } +00922 return; +00923 } +00924 } +00925 +00926 +00927 int ConfigReader::Enumerate(std::string tag) +00928 { +00929 return EnumConf(cache,tag.c_str()); +00930 } +00931 +00932 int ConfigReader::EnumerateValues(std::string tag, int index) +00933 { +00934 return EnumValues(cache, tag.c_str(), index); +00935 } +00936 +00937 bool ConfigReader::Verify() +00938 { +00939 return this->readerror; +00940 } +00941 +00942 +00943 FileReader::FileReader(std::string filename) +00944 { +00945 file_cache c; +00946 readfile(c,filename.c_str()); +00947 this->fc = c; +00948 } +00949 +00950 FileReader::FileReader() +00951 { +00952 } +00953 +00954 void FileReader::LoadFile(std::string filename) +00955 { +00956 file_cache c; +00957 readfile(c,filename.c_str()); +00958 this->fc = c; +00959 } +00960 +00961 +00962 FileReader::~FileReader() +00963 { +00964 } +00965 +00966 bool FileReader::Exists() +00967 { +00968 if (fc.size() == 0) +00969 { +00970 return(false); +00971 } +00972 else +00973 { +00974 return(true); +00975 } +00976 } +00977 +00978 std::string FileReader::GetLine(int x) +00979 { +00980 if ((x<0) || ((unsigned)x>fc.size())) +00981 return ""; +00982 return fc[x]; +00983 } +00984 +00985 int FileReader::FileSize() +00986 { +00987 return fc.size(); +00988 } +00989 +00990 +00991 std::vector<Module*> modules(255); +00992 std::vector<ircd_module*> factory(255); +00993 +00994 int MODCOUNT = -1; +00995 +00996 +
-1.3.3
+ 1.4.4-20050815
--
cgit v1.3.1-10-gc9f91