]> git.netwichtig.de Git - user/henk/code/inspircd.git/blob - src/modules.cpp
Check return values
[user/henk/code/inspircd.git] / src / modules.cpp
1 /*       +------------------------------------+
2  *       | Inspire Internet Relay Chat Daemon |
3  *       +------------------------------------+
4  *
5  *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
6  *                       E-mail:
7  *                <brain@chatspike.net>
8  *                <Craig@chatspike.net>
9  *     
10  * Written by Craig Edwards, Craig McLure, and others.
11  * This program is free but copyrighted software; see
12  *            the file COPYING for details.
13  *
14  * ---------------------------------------------------
15  */
16
17 #include "inspircd_config.h"
18 #include "inspircd.h"
19 #include "configreader.h"
20 #include <unistd.h>
21 #include <sys/errno.h>
22 #include <time.h>
23 #include <string>
24 #include <map>
25 #include <sstream>
26 #include <vector>
27 #include <deque>
28 #include "users.h"
29 #include "ctables.h"
30 #include "globals.h"
31 #include "modules.h"
32 #include "dynamic.h"
33 #include "wildcard.h"
34 #include "message.h"
35 #include "mode.h"
36 #include "xline.h"
37 #include "commands.h"
38 #include "inspstring.h"
39 #include "helperfuncs.h"
40 #include "hashcomp.h"
41 #include "socket.h"
42 #include "socketengine.h"
43 #include "typedefs.h"
44 #include "modules.h"
45 #include "command_parse.h"
46 #include "dns.h"
47
48 extern ServerConfig *Config;
49 extern InspIRCd* ServerInstance;
50 extern int MODCOUNT;
51 extern ModuleList modules;
52 extern FactoryList factory;
53 extern std::vector<InspSocket*> module_sockets;
54 extern std::vector<userrec*> local_users;
55 extern time_t TIME;
56 extern userrec* fd_ref_table[MAX_DESCRIPTORS];
57 extern user_hash clientlist;
58 extern chan_hash chanlist;
59 extern command_table cmdlist;
60
61 class Server;
62
63 featurelist Features;
64
65 // version is a simple class for holding a modules version number
66
67 Version::Version(int major, int minor, int revision, int build, int flags)
68 : Major(major), Minor(minor), Revision(revision), Build(build), Flags(flags)
69 {
70 }
71
72 // admin is a simple class for holding a server's administrative info
73
74 Admin::Admin(std::string name, std::string email, std::string nick)
75 : Name(name), Email(email), Nick(nick)
76 {
77 }
78
79 Request::Request(char* anydata, Module* src, Module* dst)
80 : data(anydata), source(src), dest(dst)
81 {
82         /* Ensure that because this module doesnt support ID strings, it doesnt break modules that do
83          * by passing them uninitialized pointers (could happen)
84          */
85         id = '\0';
86 }
87
88 Request::Request(Module* src, Module* dst, const char* idstr)
89 : id(idstr), source(src), dest(dst)
90 {
91 };
92
93 char* Request::GetData()
94 {
95         return this->data;
96 }
97
98 const char* Request::GetId()
99 {
100         return this->id;
101 }
102
103 Module* Request::GetSource()
104 {
105         return this->source;
106 }
107
108 Module* Request::GetDest()
109 {
110         return this->dest;
111 }
112
113 char* Request::Send()
114 {
115         if (this->dest)
116         {
117                 return dest->OnRequest(this);
118         }
119         else
120         {
121                 return NULL;
122         }
123 }
124
125 Event::Event(char* anydata, Module* src, const std::string &eventid) : data(anydata), source(src), id(eventid) { };
126
127 char* Event::GetData()
128 {
129         return (char*)this->data;
130 }
131
132 Module* Event::GetSource()
133 {
134         return this->source;
135 }
136
137 char* Event::Send()
138 {
139         FOREACH_MOD(I_OnEvent,OnEvent(this));
140         return NULL;
141 }
142
143 std::string Event::GetEventID()
144 {
145         return this->id;
146 }
147
148
149 // These declarations define the behavours of the base class Module (which does nothing at all)
150
151                 Module::Module(Server* Me) { }
152                 Module::~Module() { }
153 void            Module::OnUserConnect(userrec* user) { }
154 void            Module::OnUserQuit(userrec* user, const std::string& message) { }
155 void            Module::OnUserDisconnect(userrec* user) { }
156 void            Module::OnUserJoin(userrec* user, chanrec* channel) { }
157 void            Module::OnUserPart(userrec* user, chanrec* channel, const std::string &partmessage) { }
158 void            Module::OnRehash(const std::string &parameter) { }
159 void            Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
160 int             Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
161 void            Module::OnMode(userrec* user, void* dest, int target_type, const std::string &text) { };
162 Version         Module::GetVersion() { return Version(1,0,0,0,VF_VENDOR); }
163 void            Module::OnOper(userrec* user, const std::string &opertype) { };
164 void            Module::OnPostOper(userrec* user, const std::string &opertype) { };
165 void            Module::OnInfo(userrec* user) { };
166 void            Module::OnWhois(userrec* source, userrec* dest) { };
167 int             Module::OnUserPreInvite(userrec* source,userrec* dest,chanrec* channel) { return 0; };
168 int             Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text,char status) { return 0; };
169 int             Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text,char status) { return 0; };
170 int             Module::OnUserPreNick(userrec* user, const std::string &newnick) { return 0; };
171 void            Module::OnUserPostNick(userrec* user, const std::string &oldnick) { };
172 int             Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
173 void            Module::On005Numeric(std::string &output) { };
174 int             Module::OnKill(userrec* source, userrec* dest, const std::string &reason) { return 0; };
175 void            Module::OnLoadModule(Module* mod,const std::string &name) { };
176 void            Module::OnUnloadModule(Module* mod,const std::string &name) { };
177 void            Module::OnBackgroundTimer(time_t curtime) { };
178 int             Module::OnPreCommand(const std::string &command, const char** parameters, int pcnt, userrec *user, bool validated) { return 0; };
179 bool            Module::OnCheckReady(userrec* user) { return true; };
180 void            Module::OnUserRegister(userrec* user) { };
181 int             Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason) { return 0; };
182 void            Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, const std::string &reason) { };
183 int             Module::OnRawMode(userrec* user, chanrec* chan, char mode, const std::string &param, bool adding, int pcnt) { return 0; };
184 int             Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
185 int             Module::OnCheckKey(userrec* user, chanrec* chan, const std::string &keygiven) { return 0; };
186 int             Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
187 int             Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
188 int             Module::OnStats(char symbol, userrec* user, string_list &results) { return 0; };
189 int             Module::OnChangeLocalUserHost(userrec* user, const std::string &newhost) { return 0; };
190 int             Module::OnChangeLocalUserGECOS(userrec* user, const std::string &newhost) { return 0; };
191 int             Module::OnLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic) { return 0; };
192 void            Module::OnEvent(Event* event) { return; };
193 char*           Module::OnRequest(Request* request) { return NULL; };
194 int             Module::OnOperCompare(const std::string &password, const std::string &input) { return 0; };
195 void            Module::OnGlobalOper(userrec* user) { };
196 void            Module::OnGlobalConnect(userrec* user) { };
197 int             Module::OnAddBan(userrec* source, chanrec* channel,const std::string &banmask) { return 0; };
198 int             Module::OnDelBan(userrec* source, chanrec* channel,const std::string &banmask) { return 0; };
199 void            Module::OnRawSocketAccept(int fd, const std::string &ip, int localport) { };
200 int             Module::OnRawSocketWrite(int fd, char* buffer, int count) { return 0; };
201 void            Module::OnRawSocketClose(int fd) { };
202 int             Module::OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult) { return 0; };
203 void            Module::OnUserMessage(userrec* user, void* dest, int target_type, const std::string &text, char status) { };
204 void            Module::OnUserNotice(userrec* user, void* dest, int target_type, const std::string &text, char status) { };
205 void            Module::OnRemoteKill(userrec* source, userrec* dest, const std::string &reason) { };
206 void            Module::OnUserInvite(userrec* source,userrec* dest,chanrec* channel) { };
207 void            Module::OnPostLocalTopicChange(userrec* user, chanrec* chan, const std::string &topic) { };
208 void            Module::OnGetServerDescription(const std::string &servername,std::string &description) { };
209 void            Module::OnSyncUser(userrec* user, Module* proto, void* opaque) { };
210 void            Module::OnSyncChannel(chanrec* chan, Module* proto, void* opaque) { };
211 void            Module::ProtoSendMode(void* opaque, int target_type, void* target, const std::string &modeline) { };
212 void            Module::OnSyncChannelMetaData(chanrec* chan, Module* proto,void* opaque, const std::string &extname) { };
213 void            Module::OnSyncUserMetaData(userrec* user, Module* proto,void* opaque, const std::string &extname) { };
214 void            Module::OnSyncOtherMetaData(Module* proto, void* opaque) { };
215 void            Module::OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata) { };
216 void            Module::ProtoSendMetaData(void* opaque, int target_type, void* target, const std::string &extname, const std::string &extdata) { };
217 void            Module::OnWallops(userrec* user, const std::string &text) { };
218 void            Module::OnChangeHost(userrec* user, const std::string &newhost) { };
219 void            Module::OnChangeName(userrec* user, const std::string &gecos) { };
220 void            Module::OnAddGLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { };
221 void            Module::OnAddZLine(long duration, userrec* source, const std::string &reason, const std::string &ipmask) { };
222 void            Module::OnAddKLine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { };
223 void            Module::OnAddQLine(long duration, userrec* source, const std::string &reason, const std::string &nickmask) { };
224 void            Module::OnAddELine(long duration, userrec* source, const std::string &reason, const std::string &hostmask) { };
225 void            Module::OnDelGLine(userrec* source, const std::string &hostmask) { };
226 void            Module::OnDelZLine(userrec* source, const std::string &ipmask) { };
227 void            Module::OnDelKLine(userrec* source, const std::string &hostmask) { };
228 void            Module::OnDelQLine(userrec* source, const std::string &nickmask) { };
229 void            Module::OnDelELine(userrec* source, const std::string &hostmask) { };
230 void            Module::OnCleanup(int target_type, void* item) { };
231 void            Module::Implements(char* Implements) { for (int j = 0; j < 255; j++) Implements[j] = 0; };
232 void            Module::OnChannelDelete(chanrec* chan) { };
233 Priority        Module::Prioritize() { return PRIORITY_DONTCARE; }
234 void            Module::OnSetAway(userrec* user) { };
235 void            Module::OnCancelAway(userrec* user) { };
236
237 /* server is a wrapper class that provides methods to all of the C-style
238  * exports in the core
239  */
240
241 Server::Server()
242 {
243 }
244
245 Server::~Server()
246 {
247 }
248
249 void Server::AddSocket(InspSocket* sock)
250 {
251         module_sockets.push_back(sock);
252 }
253
254 void Server::RemoveSocket(InspSocket* sock)
255 {
256         for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
257         {
258                 InspSocket* s = (InspSocket*)*a;
259                 if (s == sock)
260                         s->MarkAsClosed();
261         }
262 }
263
264 long Server::PriorityAfter(const std::string &modulename)
265 {
266         for (unsigned int j = 0; j < Config->module_names.size(); j++)
267         {
268                 if (Config->module_names[j] == modulename)
269                 {
270                         return ((j << 8) | PRIORITY_AFTER);
271                 }
272         }
273         return PRIORITY_DONTCARE;
274 }
275
276 long Server::PriorityBefore(const std::string &modulename)
277 {
278         for (unsigned int j = 0; j < Config->module_names.size(); j++)
279         {
280                 if (Config->module_names[j] == modulename)
281                 {
282                         return ((j << 8) | PRIORITY_BEFORE);
283                 }
284         }
285         return PRIORITY_DONTCARE;
286 }
287
288 bool Server::PublishFeature(const std::string &FeatureName, Module* Mod)
289 {
290         if (Features.find(FeatureName) == Features.end())
291         {
292                 Features[FeatureName] = Mod;
293                 return true;
294         }
295         return false;
296 }
297
298 bool Server::UnpublishFeature(const std::string &FeatureName)
299 {
300         featurelist::iterator iter = Features.find(FeatureName);
301         
302         if (iter == Features.end())
303                 return false;
304
305         Features.erase(iter);
306         return true;
307 }
308
309 Module* Server::FindFeature(const std::string &FeatureName)
310 {
311         featurelist::iterator iter = Features.find(FeatureName);
312
313         if (iter == Features.end())
314                 return NULL;
315
316         return iter->second;
317 }
318
319 const std::string& Server::GetModuleName(Module* m)
320 {
321         static std::string nothing = ""; /* Prevent compiler warning */
322         for (int i = 0; i <= MODCOUNT; i++)
323         {
324                 if (modules[i] == m)
325                 {
326                         return Config->module_names[i];
327                 }
328         }
329         return nothing; /* As above */
330 }
331
332 void Server::RehashServer()
333 {
334         WriteOpers("*** Rehashing config file");
335         Config->Read(false,NULL);
336 }
337
338 ServerConfig* Server::GetConfig()
339 {
340         return Config;
341 }
342
343 std::string Server::GetVersion()
344 {
345         return ServerInstance->GetVersionString();
346 }
347
348 void Server::DelSocket(InspSocket* sock)
349 {
350         for (std::vector<InspSocket*>::iterator a = module_sockets.begin(); a < module_sockets.end(); a++)
351         {
352                 if (*a == sock)
353                 {
354                         module_sockets.erase(a);
355                         return;
356                 }
357         }
358 }
359
360 long Server::GetChannelCount()
361 {
362         return (long)chanlist.size();
363 }
364
365 /* This is ugly, yes, but hash_map's arent designed to be
366  * addressed in this manner, and this is a bit of a kludge.
367  * Luckily its a specialist function and rarely used by
368  * many modules (in fact, it was specially created to make
369  * m_safelist possible, initially).
370  */
371
372 chanrec* Server::GetChannelIndex(long index)
373 {
374         int target = 0;
375         for (chan_hash::iterator n = chanlist.begin(); n != chanlist.end(); n++, target++)
376         {
377                 if (index == target)
378                         return n->second;
379         }
380         return NULL;
381 }
382
383 void Server::AddTimer(InspTimer* T)
384 {
385         ::AddTimer(T);
386 }
387
388 void Server::SendOpers(const std::string &s)
389 {
390         WriteOpers("%s",s.c_str());
391 }
392
393 bool Server::MatchText(const std::string &sliteral, const std::string &spattern)
394 {
395         return match(sliteral.c_str(),spattern.c_str());
396 }
397
398 void Server::SendToModeMask(const std::string &modes, int flags, const std::string &text)
399 {
400         WriteMode(modes.c_str(),flags,"%s",text.c_str());
401 }
402
403 chanrec* Server::JoinUserToChannel(userrec* user, const std::string &cname, const std::string &key)
404 {
405         return add_channel(user,cname.c_str(),key.c_str(),false);
406 }
407
408 chanrec* Server::PartUserFromChannel(userrec* user, const std::string &cname, const std::string &reason)
409 {
410         return del_channel(user,cname.c_str(),reason.c_str(),false);
411 }
412
413 chanuserlist Server::GetUsers(chanrec* chan)
414 {
415         chanuserlist userl;
416         userl.clear();
417         CUList *list = chan->GetUsers();
418         for (CUList::iterator i = list->begin(); i != list->end(); i++)
419                 userl.push_back(i->second);
420         return userl;
421 }
422 void Server::ChangeUserNick(userrec* user, const std::string &nickname)
423 {
424         force_nickchange(user,nickname.c_str());
425 }
426
427 void Server::KickUser(userrec* source, userrec* target, chanrec* chan, const std::string &reason)
428 {
429         if (source)
430         {
431                 if (!chan->KickUser(source, target, reason.c_str()))
432                         /* No users left? */
433                         delete chan;
434         }
435         else
436         {
437                 if (!chan->ServerKickUser(target, reason.c_str(), true))
438                         /* No users left? */
439                         delete chan;
440         }
441 }
442
443 void Server::QuitUser(userrec* user, const std::string &reason)
444 {
445         kill_link(user,reason.c_str());
446 }
447
448 bool Server::IsUlined(const std::string &server)
449 {
450         return is_uline(server.c_str());
451 }
452
453 bool Server::CallCommandHandler(const std::string &commandname, const char** parameters, int pcnt, userrec* user)
454 {
455         return ServerInstance->Parser->CallHandler(commandname,parameters,pcnt,user);
456 }
457
458 bool Server::IsValidModuleCommand(const std::string &commandname, int pcnt, userrec* user)
459 {
460         return ServerInstance->Parser->IsValidCommand(commandname, pcnt, user);
461 }
462
463 void Server::Log(int level, const std::string &s)
464 {
465         log(level,"%s",s.c_str());
466 }
467
468 void Server::AddCommand(command_t *f)
469 {
470         if (!ServerInstance->Parser->CreateCommand(f))
471         {
472                 ModuleException err("Command "+std::string(f->command)+" already exists.");
473                 throw (err);
474         }
475 }
476
477 void Server::SendMode(const char** parameters, int pcnt, userrec *user)
478 {
479         ServerInstance->ModeGrok->Process(parameters,pcnt,user,true);
480 }
481
482 void Server::Send(int Socket, const std::string &s)
483 {
484         Write_NoFormat(Socket,s.c_str());
485 }
486
487 void Server::SendServ(int Socket, const std::string &s)
488 {
489         WriteServ_NoFormat(Socket,s.c_str());
490 }
491
492 void Server::SendFrom(int Socket, userrec* User, const std::string &s)
493 {
494         WriteFrom_NoFormat(Socket,User,s.c_str());
495 }
496
497 void Server::SendTo(userrec* Source, userrec* Dest, const std::string &s)
498 {
499         if (!Source)
500         {
501                 // if source is NULL, then the message originates from the local server
502                 WriteServ_NoFormat(Dest->fd,s.c_str());
503         }
504         else
505         {
506                 // otherwise it comes from the user specified
507                 WriteTo_NoFormat(Source,Dest,s.c_str());
508         }
509 }
510
511 void Server::SendChannelServerNotice(const std::string &ServName, chanrec* Channel, const std::string &text)
512 {
513         WriteChannelWithServ_NoFormat((char*)ServName.c_str(), Channel, text.c_str());
514 }
515
516 void Server::SendChannel(userrec* User, chanrec* Channel, const std::string &s, bool IncludeSender)
517 {
518         if (IncludeSender)
519         {
520                 WriteChannel_NoFormat(Channel,User,s.c_str());
521         }
522         else
523         {
524                 ChanExceptSender_NoFormat(Channel,User,0,s.c_str());
525         }
526 }
527
528 bool Server::CommonChannels(userrec* u1, userrec* u2)
529 {
530         return (common_channels(u1,u2) != 0);
531 }
532
533 void Server::DumpText(userrec* User, const std::string &LinePrefix, stringstream &TextStream)
534 {
535         std::string CompleteLine = LinePrefix;
536         std::string Word = "";
537         while (TextStream >> Word)
538         {
539                 if (CompleteLine.length() + Word.length() + 3 > 500)
540                 {
541                         WriteServ_NoFormat(User->fd,CompleteLine.c_str());
542                         CompleteLine = LinePrefix;
543                 }
544                 CompleteLine = CompleteLine + Word + " ";
545         }
546         WriteServ_NoFormat(User->fd,CompleteLine.c_str());
547 }
548
549 void Server::SendCommon(userrec* User, const std::string &text, bool IncludeSender)
550 {
551         if (IncludeSender)
552         {
553                 WriteCommon_NoFormat(User,text.c_str());
554         }
555         else
556         {
557                 WriteCommonExcept_NoFormat(User,text.c_str());
558         }
559 }
560
561 void Server::SendWallops(userrec* User, const std::string &text)
562 {
563         WriteWallOps(User,false,"%s",text.c_str());
564 }
565
566 void Server::ChangeHost(userrec* user, const std::string &host)
567 {
568         ChangeDisplayedHost(user,host.c_str());
569 }
570
571 void Server::ChangeGECOS(userrec* user, const std::string &gecos)
572 {
573         ChangeName(user,gecos.c_str());
574 }
575
576 bool Server::IsNick(const std::string &nick)
577 {
578         return (isnick(nick.c_str()) != 0);
579 }
580
581 userrec* Server::FindNick(const std::string &nick)
582 {
583         return Find(nick);
584 }
585
586 userrec* Server::FindDescriptor(int socket)
587 {
588         return (socket < 65536 ? fd_ref_table[socket] : NULL);
589 }
590
591 chanrec* Server::FindChannel(const std::string &channel)
592 {
593         return FindChan(channel.c_str());
594 }
595
596 std::string Server::ChanMode(userrec* User, chanrec* Chan)
597 {
598         return cmode(User,Chan);
599 }
600
601 std::string Server::GetServerName()
602 {
603         return Config->ServerName;
604 }
605
606 std::string Server::GetNetworkName()
607 {
608         return Config->Network;
609 }
610
611 std::string Server::GetServerDescription()
612 {
613         return Config->ServerDesc;
614 }
615
616 Admin Server::GetAdmin()
617 {
618         return Admin(Config->AdminName,Config->AdminEmail,Config->AdminNick);
619 }
620
621
622 bool Server::AddMode(ModeHandler* mh, const unsigned char mode)
623 {
624         return ServerInstance->ModeGrok->AddMode(mh,mode);
625 }
626
627 bool Server::AddModeWatcher(ModeWatcher* mw)
628 {
629         return ServerInstance->ModeGrok->AddModeWatcher(mw);
630 }
631
632 bool Server::DelModeWatcher(ModeWatcher* mw)
633 {
634         return ServerInstance->ModeGrok->DelModeWatcher(mw);
635 }
636
637 bool Server::AddResolver(Resolver* r)
638 {
639         return ServerInstance->Res->AddResolverClass(r);
640 }
641
642 int Server::CountUsers(chanrec* c)
643 {
644         return usercount(c);
645 }
646
647 bool Server::UserToPseudo(userrec* user, const std::string &message)
648 {
649         unsigned int old_fd = user->fd;
650         Write(old_fd,"ERROR :Closing link (%s@%s) [%s]",user->ident,user->host,message.c_str());
651         user->FlushWriteBuf();
652         user->ClearBuffer();
653         user->fd = FD_MAGIC_NUMBER;
654
655         if (find(local_users.begin(),local_users.end(),user) != local_users.end())
656         {
657                 local_users.erase(find(local_users.begin(),local_users.end(),user));
658                 log(DEBUG,"Delete local user");
659         }
660
661         ServerInstance->SE->DelFd(old_fd);
662         shutdown(old_fd,2);
663         close(old_fd);
664         return true;
665 }
666
667 bool Server::PseudoToUser(userrec* alive, userrec* zombie, const std::string &message)
668 {
669         log(DEBUG,"PseudoToUser");
670         zombie->fd = alive->fd;
671         FOREACH_MOD(I_OnUserQuit,OnUserQuit(alive,message));
672         alive->fd = FD_MAGIC_NUMBER;
673         alive->FlushWriteBuf();
674         alive->ClearBuffer();
675         // save these for later
676         std::string oldnick = alive->nick;
677         std::string oldhost = alive->host;
678         std::string oldident = alive->ident;
679         kill_link(alive,message.c_str());
680         if (find(local_users.begin(),local_users.end(),alive) != local_users.end())
681         {
682                 local_users.erase(find(local_users.begin(),local_users.end(),alive));
683                 log(DEBUG,"Delete local user");
684         }
685         // Fix by brain - cant write the user until their fd table entry is updated
686         fd_ref_table[zombie->fd] = zombie;
687         Write(zombie->fd,":%s!%s@%s NICK %s",oldnick.c_str(),oldident.c_str(),oldhost.c_str(),zombie->nick);
688         for (std::vector<ucrec*>::const_iterator i = zombie->chans.begin(); i != zombie->chans.end(); i++)
689         {
690                 if (((ucrec*)(*i))->channel != NULL)
691                 {
692                                 chanrec* Ptr = ((ucrec*)(*i))->channel;
693                                 WriteFrom(zombie->fd,zombie,"JOIN %s",Ptr->name);
694                                 if (Ptr->topicset)
695                                 {
696                                         WriteServ(zombie->fd,"332 %s %s :%s", zombie->nick, Ptr->name, Ptr->topic);
697                                         WriteServ(zombie->fd,"333 %s %s %s %d", zombie->nick, Ptr->name, Ptr->setby, Ptr->topicset);
698                                 }
699                                 userlist(zombie,Ptr);
700                                 WriteServ(zombie->fd,"366 %s %s :End of /NAMES list.", zombie->nick, Ptr->name);
701                 }
702         }
703         if ((find(local_users.begin(),local_users.end(),zombie) == local_users.end()) && (zombie->fd != FD_MAGIC_NUMBER))
704                 local_users.push_back(zombie);
705
706         return true;
707 }
708
709 void Server::AddGLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask)
710 {
711         add_gline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
712         apply_lines(APPLY_GLINES);
713 }
714
715 void Server::AddQLine(long duration, const std::string &source, const std::string &reason, const std::string &nickname)
716 {
717         add_qline(duration, source.c_str(), reason.c_str(), nickname.c_str());
718         apply_lines(APPLY_QLINES);
719 }
720
721 void Server::AddZLine(long duration, const std::string &source, const std::string &reason, const std::string &ipaddr)
722 {
723         add_zline(duration, source.c_str(), reason.c_str(), ipaddr.c_str());
724         apply_lines(APPLY_ZLINES);
725 }
726
727 void Server::AddKLine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask)
728 {
729         add_kline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
730         apply_lines(APPLY_KLINES);
731 }
732
733 void Server::AddELine(long duration, const std::string &source, const std::string &reason, const std::string &hostmask)
734 {
735         add_eline(duration, source.c_str(), reason.c_str(), hostmask.c_str());
736 }
737
738 bool Server::DelGLine(const std::string &hostmask)
739 {
740         return del_gline(hostmask.c_str());
741 }
742
743 bool Server::DelQLine(const std::string &nickname)
744 {
745         return del_qline(nickname.c_str());
746 }
747
748 bool Server::DelZLine(const std::string &ipaddr)
749 {
750         return del_zline(ipaddr.c_str());
751 }
752
753 bool Server::DelKLine(const std::string &hostmask)
754 {
755         return del_kline(hostmask.c_str());
756 }
757
758 bool Server::DelELine(const std::string &hostmask)
759 {
760         return del_eline(hostmask.c_str());
761 }
762
763 long Server::CalcDuration(const std::string &delta)
764 {
765         return duration(delta.c_str());
766 }
767
768 /*
769  * XXX why on *earth* is this in modules.cpp...? I think
770  * perhaps we need a server.cpp for Server:: stuff where possible. -- w00t
771  */
772 bool Server::IsValidMask(const std::string &mask)
773 {
774         char* dest = (char*)mask.c_str();
775         if (strchr(dest,'!')==0)
776                 return false;
777         if (strchr(dest,'@')==0)
778                 return false;
779         for (char* i = dest; *i; i++)
780                 if (*i < 32)
781                         return false;
782         for (char* i = dest; *i; i++)
783                 if (*i > 126)
784                         return false;
785         unsigned int c = 0;
786         for (char* i = dest; *i; i++)
787                 if (*i == '!')
788                         c++;
789         if (c>1)
790                 return false;
791         c = 0;
792         for (char* i = dest; *i; i++)
793                 if (*i == '@')
794                         c++;
795         if (c>1)
796                 return false;
797
798         return true;
799 }
800
801 Module* Server::FindModule(const std::string &name)
802 {
803         for (int i = 0; i <= MODCOUNT; i++)
804         {
805                 if (Config->module_names[i] == name)
806                 {
807                         return modules[i];
808                 }
809         }
810         return NULL;
811 }
812
813 ConfigReader::ConfigReader()
814 {
815         // Config->ClearStack();
816         
817         /* Is there any reason to load the entire config file again here?
818          * it's needed if they specify another config file, but using the
819          * default one we can just use the global config data - pre-parsed!
820          */
821         //~ this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
822         this->errorlog = new std::ostringstream(std::stringstream::in | std::stringstream::out);
823         
824         //~ this->readerror = Config->LoadConf(CONFIG_FILE, this->cache,this->errorlog);
825         //~ if (!this->readerror)
826                 //~ this->error = CONF_FILE_NOT_FOUND;
827         
828         this->data = &Config->config_data;
829         this->privatehash = false;
830 }
831
832
833 ConfigReader::~ConfigReader()
834 {
835         //~ if (this->cache)
836                 //~ delete this->cache;
837         if (this->errorlog)
838                 DELETE(this->errorlog);
839         if(this->privatehash)
840                 DELETE(this->data);
841 }
842
843
844 ConfigReader::ConfigReader(const std::string &filename)
845 {
846         Config->ClearStack();
847         
848         this->data = new ConfigDataHash;
849         this->privatehash = true;
850         this->errorlog = new std::ostringstream(std::stringstream::in | std::stringstream::out);
851         this->readerror = Config->LoadConf(*this->data, filename, *this->errorlog);
852         if (!this->readerror)
853                 this->error = CONF_FILE_NOT_FOUND;
854 };
855
856 std::string ConfigReader::ReadValue(const std::string &tag, const std::string &name, int index)
857 {
858         /* Don't need to strlcpy() tag and name anymore, ReadConf() takes const char* */ 
859         std::string result;
860         
861         if (!Config->ConfValue(*this->data, tag, name, index, result))
862         {
863                 this->error = CONF_VALUE_NOT_FOUND;
864                 return "";
865         }
866         
867         return result;
868 }
869
870 bool ConfigReader::ReadFlag(const std::string &tag, const std::string &name, int index)
871 {
872         return Config->ConfValueBool(*this->data, tag, name, index);
873 }
874
875 long ConfigReader::ReadInteger(const std::string &tag, const std::string &name, int index, bool needs_unsigned)
876 {
877         int result;
878         
879         if(!Config->ConfValueInteger(*this->data, tag, name, index, result))
880         {
881                 this->error = CONF_VALUE_NOT_FOUND;
882                 return 0;
883         }
884         
885         if ((needs_unsigned) && (result < 0))
886         {
887                 this->error = CONF_NOT_UNSIGNED;
888                 return 0;
889         }
890         
891         return result;
892 }
893
894 long ConfigReader::GetError()
895 {
896         long olderr = this->error;
897         this->error = 0;
898         return olderr;
899 }
900
901 void ConfigReader::DumpErrors(bool bail, userrec* user)
902 {
903         /* XXX - Duplicated code */
904         
905         if (bail)
906         {
907                 printf("There were errors in your configuration:\n%s", this->errorlog->str().c_str());
908                 Exit(0);
909         }
910         else
911         {
912                 std::string errors = this->errorlog->str();
913                 std::string::size_type start;
914                 unsigned int prefixlen;
915                 
916                 start = 0;
917                 /* ":Config->ServerName NOTICE user->nick :" */
918                 prefixlen = strlen(Config->ServerName) + strlen(user->nick) + 11;
919         
920                 if (user)
921                 {
922                         WriteServ(user->fd,"NOTICE %s :There were errors in the configuration file:",user->nick);
923                         
924                         while(start < errors.length())
925                         {
926                                 WriteServ(user->fd, "NOTICE %s :%s",user->nick, errors.substr(start, 510 - prefixlen).c_str());
927                                 start += 510 - prefixlen;
928                         }
929                 }
930                 else
931                 {
932                         WriteOpers("There were errors in the configuration file:");
933                         
934                         while(start < errors.length())
935                         {
936                                 WriteOpers(errors.substr(start, 360).c_str());
937                                 start += 360;
938                         }
939                 }
940
941                 return;
942         }
943 }
944
945
946 int ConfigReader::Enumerate(const std::string &tag)
947 {
948         return Config->ConfValueEnum(*this->data, tag);
949 }
950
951 int ConfigReader::EnumerateValues(const std::string &tag, int index)
952 {
953         return Config->ConfVarEnum(*this->data, tag, index);
954 }
955
956 bool ConfigReader::Verify()
957 {
958         return this->readerror;
959 }
960
961
962 FileReader::FileReader(const std::string &filename)
963 {
964         file_cache c;
965         readfile(c,filename.c_str());
966         this->fc = c;
967         this->CalcSize();
968 }
969
970 FileReader::FileReader()
971 {
972 }
973
974 std::string FileReader::Contents()
975 {
976         std::string x = "";
977         for (file_cache::iterator a = this->fc.begin(); a != this->fc.end(); a++)
978         {
979                 x.append(*a);
980                 x.append("\r\n");
981         }
982         return x;
983 }
984
985 unsigned long FileReader::ContentSize()
986 {
987         return this->contentsize;
988 }
989
990 void FileReader::CalcSize()
991 {
992         unsigned long n = 0;
993         for (file_cache::iterator a = this->fc.begin(); a != this->fc.end(); a++)
994                 n += (a->length() + 2);
995         this->contentsize = n;
996 }
997
998 void FileReader::LoadFile(const std::string &filename)
999 {
1000         file_cache c;
1001         readfile(c,filename.c_str());
1002         this->fc = c;
1003         this->CalcSize();
1004 }
1005
1006
1007 FileReader::~FileReader()
1008 {
1009 }
1010
1011 bool FileReader::Exists()
1012 {
1013         return (!(fc.size() == 0));
1014 }
1015
1016 std::string FileReader::GetLine(int x)
1017 {
1018         if ((x<0) || ((unsigned)x>fc.size()))
1019                 return "";
1020         return fc[x];
1021 }
1022
1023 int FileReader::FileSize()
1024 {
1025         return fc.size();
1026 }
1027
1028
1029 std::vector<Module*> modules(255);
1030 std::vector<ircd_module*> factory(255);
1031
1032 int MODCOUNT  = -1;