src/modules.cpp

   1 #include "inspircd.h"
   2 #include "inspircd_io.h"
   3 #include "inspircd_util.h"
   4 #include "inspircd_config.h"
   5 #include <unistd.h>
   6 #include <fcntl.h>
   7 #include <sys/errno.h>
   8 #include <sys/ioctl.h>
   9 #include <sys/utsname.h>
  10 #include <cstdio>
  11 #include <time.h>
  12 #include <string>
  13 #ifdef GCC3
  14 #include <ext/hash_map>
  15 #else
  16 #include <hash_map>
  17 #endif
  18 #include <map>
  19 #include <sstream>
  20 #include <vector>
  21 #include <errno.h>
  22 #include <deque>
  23 #include <errno.h>
  24 #include <unistd.h>
  25 #include <sched.h>
  26 #include "connection.h"
  27 #include "users.h"
  28 #include "servers.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
  39 #ifdef GCC3
  40 #define nspace __gnu_cxx
  41 #else
  42 #define nspace std
  43 #endif
  44
  45 using namespace std;
  46
  47 extern int MODCOUNT;
  48 extern vector<Module*> modules;
  49 extern vector<ircd_module*> factory;
  50
  51 extern int LogLevel;
  52 extern char ServerName[MAXBUF];
  53 extern char Network[MAXBUF];
  54 extern char ServerDesc[MAXBUF];
  55 extern char AdminName[MAXBUF];
  56 extern char AdminEmail[MAXBUF];
  57 extern char AdminNick[MAXBUF];
  58 extern char diepass[MAXBUF];
  59 extern char restartpass[MAXBUF];
  60 extern char motd[MAXBUF];
  61 extern char rules[MAXBUF];
  62 extern char list[MAXBUF];
  63 extern char PrefixQuit[MAXBUF];
  64 extern char DieValue[MAXBUF];
  65
  66 extern int debugging;
  67 extern int WHOWAS_STALE;
  68 extern int WHOWAS_MAX;
  69 extern int DieDelay;
  70 extern time_t startup_time;
  71 extern int NetBufferSize;
  72 extern int MaxWhoResults;
  73 extern time_t nb_start;
  74
  75 extern std::vector<int> fd_reap;
  76 extern std::vector<std::string> module_names;
  77
  78 extern char bannerBuffer[MAXBUF];
  79 extern int boundPortCount;
  80 extern int portCount;
  81 extern int UDPportCount;
  82 extern int ports[MAXSOCKS];
  83 extern int defaultRoute;
  84
  85 extern std::vector<long> auth_cookies;
  86 extern std::stringstream config_f;
  87
  88 extern serverrec* me[32];
  89
  90 extern FILE *log_file;
  91
  92
  93 namespace nspace
  94 {
  95         template<> struct nspace::hash<in_addr>
  96         {
  97                 size_t operator()(const struct in_addr &a) const
  98                 {
  99                         size_t q;
 100                         memcpy(&q,&a,sizeof(size_t));
 101                         return q;
 102                 }
 103         };
 104
 105         template<> struct nspace::hash<string>
 106         {
 107                 size_t operator()(const string &s) const
 108                 {
 109                         char a[MAXBUF];
 110                         static struct hash<const char *> strhash;
 111                         strcpy(a,s.c_str());
 112                         strlower(a);
 113                         return strhash(a);
 114                 }
 115         };
 116 }
 117
 118
 119 struct StrHashComp
 120 {
 121
 122         bool operator()(const string& s1, const string& s2) const
 123         {
 124                 char a[MAXBUF],b[MAXBUF];
 125                 strcpy(a,s1.c_str());
 126                 strcpy(b,s2.c_str());
 127                 return (strcasecmp(a,b) == 0);
 128         }
 129
 130 };
 131
 132 struct InAddr_HashComp
 133 {
 134
 135         bool operator()(const in_addr &s1, const in_addr &s2) const
 136         {
 137                 size_t q;
 138                 size_t p;
 139
 140                 memcpy(&q,&s1,sizeof(size_t));
 141                 memcpy(&p,&s2,sizeof(size_t));
 142
 143                 return (q == p);
 144         }
 145
 146 };
 147
 148
 149 typedef nspace::hash_map<std::string, userrec*, nspace::hash<string>, StrHashComp> user_hash;
 150 typedef nspace::hash_map<std::string, chanrec*, nspace::hash<string>, StrHashComp> chan_hash;
 151 typedef nspace::hash_map<in_addr,string*, nspace::hash<in_addr>, InAddr_HashComp> address_cache;
 152 typedef std::deque<command_t> command_table;
 153
 154
 155 extern user_hash clientlist;
 156 extern chan_hash chanlist;
 157 extern user_hash whowas;
 158 extern command_table cmdlist;
 159 extern file_cache MOTD;
 160 extern file_cache RULES;
 161 extern address_cache IP;
 162
 163
 164 // class type for holding an extended mode character - internal to core
 165
 166 class ExtMode : public classbase
 167 {
 168 public:
 169         char modechar;
 170         int type;
 171         int params_when_on;
 172         int params_when_off;
 173         bool needsoper;
 174         bool list;
 175         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) { };
 176 };
 177
 178 typedef std::vector<ExtMode> ExtModeList;
 179 typedef ExtModeList::iterator ExtModeListIter;
 180
 181
 182 ExtModeList EMode;
 183
 184 // returns true if an extended mode character is in use
 185 bool ModeDefined(char modechar, int type)
 186 {
 187         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
 188         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 189         {
 190                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
 191                 if ((i->modechar == modechar) && (i->type == type))
 192                 {
 193                         return true;
 194                 }
 195         }
 196         return false;
 197 }
 198
 199 bool ModeIsListMode(char modechar, int type)
 200 {
 201         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
 202         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 203         {
 204                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
 205                 if ((i->modechar == modechar) && (i->type == type) && (i->list == true))
 206                 {
 207                         return true;
 208                 }
 209         }
 210         return false;
 211 }
 212
 213 bool ModeDefinedOper(char modechar, int type)
 214 {
 215         log(DEBUG,"Size of extmodes vector is %d",EMode.size());
 216         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 217         {
 218                 log(DEBUG,"i->modechar==%c, modechar=%c, i->type=%d, type=%d",i->modechar,modechar,i->type,type);
 219                 if ((i->modechar == modechar) && (i->type == type) && (i->needsoper == true))
 220                 {
 221                         return true;
 222                 }
 223         }
 224         return false;
 225 }
 226
 227 // returns number of parameters for a custom mode when it is switched on
 228 int ModeDefinedOn(char modechar, int type)
 229 {
 230         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 231         {
 232                 if ((i->modechar == modechar) && (i->type == type))
 233                 {
 234                         return i->params_when_on;
 235                 }
 236         }
 237         return 0;
 238 }
 239
 240 // returns number of parameters for a custom mode when it is switched on
 241 int ModeDefinedOff(char modechar, int type)
 242 {
 243         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 244         {
 245                 if ((i->modechar == modechar) && (i->type == type))
 246                 {
 247                         return i->params_when_off;
 248                 }
 249         }
 250         return 0;
 251 }
 252
 253 // returns true if an extended mode character is in use
 254 bool DoAddExtendedMode(char modechar, int type, bool requires_oper, int params_on, int params_off)
 255 {
 256         if (ModeDefined(modechar,type)) {
 257                 return false;
 258         }
 259         EMode.push_back(ExtMode(modechar,type,requires_oper,params_on,params_off));
 260         return true;
 261 }
 262
 263 // turns a mode into a listmode
 264 void ModeMakeList(char modechar)
 265 {
 266         for (ExtModeListIter i = EMode.begin(); i < EMode.end(); i++)
 267         {
 268                 if ((i->modechar == modechar) && (i->type == MT_CHANNEL))
 269                 {
 270                         i->list = true;
 271                         return;
 272                 }
 273         }
 274         return;
 275 }
 276
 277 // version is a simple class for holding a modules version number
 278
 279 Version::Version(int major, int minor, int revision, int build) : Major(major), Minor(minor), Revision(revision), Build(build) { };
 280
 281 // admin is a simple class for holding a server's administrative info
 282
 283 Admin::Admin(std::string name, std::string email, std::string nick) : Name(name), Email(email), Nick(nick) { };
 284
 285 Module::Module() { }
 286 Module::~Module() { }
 287 void Module::OnUserConnect(userrec* user) { }
 288 void Module::OnUserQuit(userrec* user) { }
 289 void Module::OnUserJoin(userrec* user, chanrec* channel) { }
 290 void Module::OnUserPart(userrec* user, chanrec* channel) { }
 291 void Module::OnPacketTransmit(char *p) { }
 292 void Module::OnPacketReceive(char *p) { }
 293 void Module::OnRehash() { }
 294 void Module::OnServerRaw(std::string &raw, bool inbound, userrec* user) { }
 295 int Module::OnUserPreJoin(userrec* user, chanrec* chan, const char* cname) { return 0; }
 296 int Module::OnExtendedMode(userrec* user, void* target, char modechar, int type, bool mode_on, string_list &params) { return false; }
 297 Version Module::GetVersion() { return Version(1,0,0,0); }
 298 void Module::OnOper(userrec* user) { };
 299 void Module::OnInfo(userrec* user) { };
 300 void Module::OnWhois(userrec* source, userrec* dest) { };
 301 int Module::OnUserPreMessage(userrec* user,void* dest,int target_type, std::string text) { return 0; };
 302 int Module::OnUserPreNotice(userrec* user,void* dest,int target_type, std::string text) { return 0; };
 303 int Module::OnUserPreNick(userrec* user, std::string newnick) { return 0; };
 304 int Module::OnAccessCheck(userrec* source,userrec* dest,chanrec* channel,int access_type) { return ACR_DEFAULT; };
 305 string_list Module::OnUserSync(userrec* user) { string_list empty; return empty; }
 306 string_list Module::OnChannelSync(chanrec* chan) { string_list empty; return empty; }
 307
 308
 309 // server is a wrapper class that provides methods to all of the C-style
 310 // exports in the core
 311 //
 312
 313 Server::Server()
 314 {
 315 }
 316
 317 Server::~Server()
 318 {
 319 }
 320
 321 void Server::SendOpers(std::string s)
 322 {
 323         WriteOpers("%s",s.c_str());
 324 }
 325
 326 bool Server::MatchText(std::string sliteral, std::string spattern)
 327 {
 328         char literal[MAXBUF],pattern[MAXBUF];
 329         strncpy(literal,sliteral.c_str(),MAXBUF);
 330         strncpy(pattern,spattern.c_str(),MAXBUF);
 331         return match(literal,pattern);
 332 }
 333
 334 void Server::SendToModeMask(std::string modes, int flags, std::string text)
 335 {
 336         WriteMode(modes.c_str(),flags,"%s",text.c_str());
 337 }
 338
 339 chanrec* Server::JoinUserToChannel(userrec* user, std::string cname, std::string key)
 340 {
 341         return add_channel(user,cname.c_str(),key.c_str(),true);
 342 }
 343
 344 chanrec* Server::PartUserFromChannel(userrec* user, std::string cname, std::string reason)
 345 {
 346         return del_channel(user,cname.c_str(),reason.c_str(),false);
 347 }
 348
 349 chanuserlist Server::GetUsers(chanrec* chan)
 350 {
 351         chanuserlist userl;
 352         userl.clear();
 353         for (user_hash::const_iterator i = clientlist.begin(); i != clientlist.end(); i++)
 354         {
 355                 if (i->second)
 356                 {
 357                         if (has_channel(i->second,chan))
 358                         {
 359                                 if (isnick(i->second->nick))
 360                                 {
 361                                         userl.push_back(i->second);
 362                                 }
 363                         }
 364                 }
 365         }
 366         return userl;
 367 }
 368 void Server::ChangeUserNick(userrec* user, std::string nickname)
 369 {
 370         force_nickchange(user,nickname.c_str());
 371 }
 372
 373 void Server::QuitUser(userrec* user, std::string reason)
 374 {
 375         send_network_quit(user->nick,reason.c_str());
 376         kill_link(user,reason.c_str());
 377 }
 378
 379 bool Server::IsUlined(std::string server)
 380 {
 381         return is_uline(server.c_str());
 382 }
 383
 384 void Server::CallCommandHandler(std::string commandname, char** parameters, int pcnt, userrec* user)
 385 {
 386         call_handler(commandname.c_str(),parameters,pcnt,user);
 387 }
 388
 389 void Server::Log(int level, std::string s)
 390 {
 391         log(level,"%s",s.c_str());
 392 }
 393
 394 void Server::AddCommand(char* cmd, handlerfunc f, char flags, int minparams)
 395 {
 396         createcommand(cmd,f,flags,minparams);
 397 }
 398
 399 void Server::SendMode(char **parameters, int pcnt, userrec *user)
 400 {
 401         server_mode(parameters,pcnt,user);
 402 }
 403
 404 void Server::Send(int Socket, std::string s)
 405 {
 406         Write(Socket,"%s",s.c_str());
 407 }
 408
 409 void Server::SendServ(int Socket, std::string s)
 410 {
 411         WriteServ(Socket,"%s",s.c_str());
 412 }
 413
 414 void Server::SendFrom(int Socket, userrec* User, std::string s)
 415 {
 416         WriteFrom(Socket,User,"%s",s.c_str());
 417 }
 418
 419 void Server::SendTo(userrec* Source, userrec* Dest, std::string s)
 420 {
 421         if (!Source)
 422         {
 423                 // if source is NULL, then the message originates from the local server
 424                 Write(Dest->fd,":%s %s",this->GetServerName().c_str(),s.c_str());
 425         }
 426         else
 427         {
 428                 // otherwise it comes from the user specified
 429                 WriteTo(Source,Dest,"%s",s.c_str());
 430         }
 431 }
 432
 433 void Server::SendChannel(userrec* User, chanrec* Channel, std::string s,bool IncludeSender)
 434 {
 435         if (IncludeSender)
 436         {
 437                 WriteChannel(Channel,User,"%s",s.c_str());
 438         }
 439         else
 440         {
 441                 ChanExceptSender(Channel,User,"%s",s.c_str());
 442         }
 443 }
 444
 445 bool Server::CommonChannels(userrec* u1, userrec* u2)
 446 {
 447         return (common_channels(u1,u2) != 0);
 448 }
 449
 450 void Server::SendCommon(userrec* User, std::string text,bool IncludeSender)
 451 {
 452         if (IncludeSender)
 453         {
 454                 WriteCommon(User,"%s",text.c_str());
 455         }
 456         else
 457         {
 458                 WriteCommonExcept(User,"%s",text.c_str());
 459         }
 460 }
 461
 462 void Server::SendWallops(userrec* User, std::string text)
 463 {
 464         WriteWallOps(User,false,"%s",text.c_str());
 465 }
 466
 467 void Server::ChangeHost(userrec* user, std::string host)
 468 {
 469         ChangeDisplayedHost(user,host.c_str());
 470 }
 471
 472 void Server::ChangeGECOS(userrec* user, std::string gecos)
 473 {
 474         ChangeName(user,gecos.c_str());
 475 }
 476
 477 bool Server::IsNick(std::string nick)
 478 {
 479         return (isnick(nick.c_str()) != 0);
 480 }
 481
 482 userrec* Server::FindNick(std::string nick)
 483 {
 484         return Find(nick);
 485 }
 486
 487 chanrec* Server::FindChannel(std::string channel)
 488 {
 489         return FindChan(channel.c_str());
 490 }
 491
 492 std::string Server::ChanMode(userrec* User, chanrec* Chan)
 493 {
 494         return cmode(User,Chan);
 495 }
 496
 497 bool Server::IsOnChannel(userrec* User, chanrec* Chan)
 498 {
 499         return has_channel(User,Chan);
 500 }
 501
 502 std::string Server::GetServerName()
 503 {
 504         return getservername();
 505 }
 506
 507 std::string Server::GetNetworkName()
 508 {
 509         return getnetworkname();
 510 }
 511
 512 Admin Server::GetAdmin()
 513 {
 514         return Admin(getadminname(),getadminemail(),getadminnick());
 515 }
 516
 517
 518
 519 bool Server::AddExtendedMode(char modechar, int type, bool requires_oper, int params_when_on, int params_when_off)
 520 {
 521         if (type == MT_SERVER)
 522         {
 523                 log(DEBUG,"*** API ERROR *** Modes of type MT_SERVER are reserved for future expansion");
 524                 return false;
 525         }
 526         if (((params_when_on>0) || (params_when_off>0)) && (type == MT_CLIENT))
 527         {
 528                 log(DEBUG,"*** API ERROR *** Parameters on MT_CLIENT modes are not supported");
 529                 return false;
 530         }
 531         if ((params_when_on>1) || (params_when_off>1))
 532         {
 533                 log(DEBUG,"*** API ERROR *** More than one parameter for an MT_CHANNEL mode is not yet supported");
 534                 return false;
 535         }
 536         return DoAddExtendedMode(modechar,type,requires_oper,params_when_on,params_when_off);
 537 }
 538
 539 bool Server::AddExtendedListMode(char modechar)
 540 {
 541         bool res = DoAddExtendedMode(modechar,MT_CHANNEL,false,1,1);
 542         if (res)
 543                 ModeMakeList(modechar);
 544         return res;
 545 }
 546
 547 int Server::CountUsers(chanrec* c)
 548 {
 549         return usercount(c);
 550 }
 551
 552
 553 ConfigReader::ConfigReader()
 554 {
 555         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
 556         this->readerror = LoadConf(CONFIG_FILE,this->cache);
 557         if (!this->readerror)
 558                 this->error = CONF_FILE_NOT_FOUND;
 559 }
 560
 561
 562 ConfigReader::~ConfigReader()
 563 {
 564         if (this->cache)
 565                 delete this->cache;
 566 }
 567
 568
 569 ConfigReader::ConfigReader(std::string filename)
 570 {
 571         this->cache = new std::stringstream(std::stringstream::in | std::stringstream::out);
 572         this->readerror = LoadConf(filename.c_str(),this->cache);
 573         if (!this->readerror)
 574                 this->error = CONF_FILE_NOT_FOUND;
 575 };
 576
 577 std::string ConfigReader::ReadValue(std::string tag, std::string name, int index)
 578 {
 579         char val[MAXBUF];
 580         char t[MAXBUF];
 581         char n[MAXBUF];
 582         strncpy(t,tag.c_str(),MAXBUF);
 583         strncpy(n,name.c_str(),MAXBUF);
 584         int res = ReadConf(cache,t,n,index,val);
 585         if (!res)
 586         {
 587                 this->error = CONF_VALUE_NOT_FOUND;
 588                 return "";
 589         }
 590         return std::string(val);
 591 }
 592
 593 bool ConfigReader::ReadFlag(std::string tag, std::string name, int index)
 594 {
 595         char val[MAXBUF];
 596         char t[MAXBUF];
 597         char n[MAXBUF];
 598         strncpy(t,tag.c_str(),MAXBUF);
 599         strncpy(n,name.c_str(),MAXBUF);
 600         int res = ReadConf(cache,t,n,index,val);
 601         if (!res)
 602         {
 603                 this->error = CONF_VALUE_NOT_FOUND;
 604                 return false;
 605         }
 606         std::string s = val;
 607         return ((s == "yes") || (s == "YES") || (s == "true") || (s == "TRUE") || (s == "1"));
 608 }
 609
 610 long ConfigReader::ReadInteger(std::string tag, std::string name, int index, bool needs_unsigned)
 611 {
 612         char val[MAXBUF];
 613         char t[MAXBUF];
 614         char n[MAXBUF];
 615         strncpy(t,tag.c_str(),MAXBUF);
 616         strncpy(n,name.c_str(),MAXBUF);
 617         int res = ReadConf(cache,t,n,index,val);
 618         if (!res)
 619         {
 620                 this->error = CONF_VALUE_NOT_FOUND;
 621                 return 0;
 622         }
 623         for (int i = 0; i < strlen(val); i++)
 624         {
 625                 if (!isdigit(val[i]))
 626                 {
 627                         this->error = CONF_NOT_A_NUMBER;
 628                         return 0;
 629                 }
 630         }
 631         if ((needs_unsigned) && (atoi(val)<0))
 632         {
 633                 this->error = CONF_NOT_UNSIGNED;
 634                 return 0;
 635         }
 636         return atoi(val);
 637 }
 638
 639 long ConfigReader::GetError()
 640 {
 641         long olderr = this->error;
 642         this->error = 0;
 643         return olderr;
 644 }
 645
 646
 647 int ConfigReader::Enumerate(std::string tag)
 648 {
 649         return EnumConf(cache,tag.c_str());
 650 }
 651
 652 int ConfigReader::EnumerateValues(std::string tag, int index)
 653 {
 654         return EnumValues(cache, tag.c_str(), index);
 655 }
 656
 657 bool ConfigReader::Verify()
 658 {
 659         return this->readerror;
 660 }
 661
 662
 663 FileReader::FileReader(std::string filename)
 664 {
 665         file_cache c;
 666         readfile(c,filename.c_str());
 667         this->fc = c;
 668 }
 669
 670 FileReader::FileReader()
 671 {
 672 }
 673
 674 void FileReader::LoadFile(std::string filename)
 675 {
 676         file_cache c;
 677         readfile(c,filename.c_str());
 678         this->fc = c;
 679 }
 680
 681
 682 FileReader::~FileReader()
 683 {
 684 }
 685
 686 bool FileReader::Exists()
 687 {
 688         if (fc.size() == 0)
 689         {
 690                 return(false);
 691         }
 692         else
 693         {
 694                 return(true);
 695         }
 696 }
 697
 698 std::string FileReader::GetLine(int x)
 699 {
 700         if ((x<0) || (x>fc.size()))
 701                 return "";
 702         return fc[x];
 703 }
 704
 705 int FileReader::FileSize()
 706 {
 707         return fc.size();
 708 }
 709
 710
 711 std::vector<Module*> modules(255);
 712 std::vector<ircd_module*> factory(255);
 713
 714 int MODCOUNT  = -1;
 715
 716