X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Finspircd.cpp;h=98418a967c7fd81c012c41fc3b506a6d2876da14;hb=747ae4b7a56cf94562b5b339ab3adc88653aa337;hp=4055f2a380518668bc08ba808efad56c93897182;hpb=293df6a8b55e89c127e60e92711ef0ef1027bff8;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/inspircd.cpp b/src/inspircd.cpp index 4055f2a38..98418a967 100644 --- a/src/inspircd.cpp +++ b/src/inspircd.cpp @@ -2,7 +2,7 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * Inspire is copyright (C) 2002-2005 ChatSpike-Dev. + * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. * E-mail: * * @@ -21,11 +21,9 @@ using namespace std; #include "inspircd_config.h" #include "inspircd.h" #include "inspircd_io.h" -#include #include #include #include -#include #include #include #ifdef GCC3 @@ -67,25 +65,24 @@ int WHOWAS_MAX = 100; // default 100 people maximum in the WHOWAS list extern std::vector modules; extern std::vector factory; + std::vector module_sockets; std::vector local_users; extern int MODCOUNT; +extern char LOG_FILE[MAXBUF]; int openSockfd[MAXSOCKS]; sockaddr_in client,server; socklen_t length; -extern Module* IOHookModule; -extern InspSocket* socket_ref[65535]; +extern InspSocket* socket_ref[MAX_DESCRIPTORS]; time_t TIME = time(NULL), OLDTIME = time(NULL); -SocketEngine* SE = NULL; - // This table references users by file descriptor. // its an array to make it VERY fast, as all lookups are referenced // by an integer, meaning there is no need for a scan/search operation. -userrec* fd_ref_table[65536]; +userrec* fd_ref_table[MAX_DESCRIPTORS]; Server* MyServer = new Server; ServerConfig *Config = new ServerConfig; @@ -118,6 +115,16 @@ const char* FindServerNamePtr(std::string servername) return FindServerNamePtr(servername); } +bool FindServerName(std::string servername) +{ + for (servernamelist::iterator a = servernames.begin(); a < servernames.end(); a++) + { + if (*a == servername) + return true; + } + return false; +} + std::string InspIRCd::GetRevision() { /* w00t got me to replace a bunch of strtok_r @@ -129,6 +136,8 @@ std::string InspIRCd::GetRevision() * into the same variable twice, the first word * is discarded, and the second one returned. */ + + /* XXX - this revision ID is NOT bumping automatically -- w00t */ std::stringstream Revision("$Revision$"); std::string single; Revision >> single >> single; @@ -163,6 +172,7 @@ InspIRCd::InspIRCd(int argc, char** argv) printf("ERROR: Your config file is missing, this IRCd will self destruct in 10 seconds!\n"); Exit(ERROR); } + *LOG_FILE = 0; if (argc > 1) { for (int i = 1; i < argc; i++) { @@ -175,6 +185,18 @@ InspIRCd::InspIRCd(int argc, char** argv) if (!strcmp(argv[i],"-nolimit")) { Config->unlimitcore = true; } + if (!strcmp(argv[i],"-logfile")) { + if (argc > i+1) + { + strlcpy(LOG_FILE,argv[i+1],MAXBUF); + printf("LOG: Setting logfile to %s\n",LOG_FILE); + } + else + { + printf("ERROR: The -logfile parameter must be followed by a log file name and path.\n"); + Exit(ERROR); + } + } } } @@ -193,7 +215,13 @@ InspIRCd::InspIRCd(int argc, char** argv) CheckDie(); stats->BoundPortCount = BindPorts(); + for(int t = 0; t < 255; t++) + Config->global_implementation[t] = 0; + + memset(&Config->implement_lists,0,sizeof(Config->implement_lists)); + printf("\n"); + SetSignals(); if (!Config->nofork) { if (DaemonSeed() == ERROR) @@ -221,7 +249,14 @@ std::string InspIRCd::GetVersionString() #else char dnsengine[] = "singlethread"; #endif - snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s [FLAGS=%lu,%s,%s]",VERSION,GetRevision().c_str(),Config->ServerName,SYSTEM,(unsigned long)OPTIMISATION,SE->GetName().c_str(),dnsengine); + if (*Config->CustomVersion) + { + snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s",VERSION,GetRevision().c_str(),Config->ServerName,Config->CustomVersion); + } + else + { + snprintf(versiondata,MAXBUF,"%s Rev. %s %s :%s [FLAGS=%lu,%s,%s]",VERSION,GetRevision().c_str(),Config->ServerName,SYSTEM,(unsigned long)OPTIMISATION,SE->GetName().c_str(),dnsengine); + } return versiondata; } @@ -272,6 +307,106 @@ void InspIRCd::erase_module(int j) } +void InspIRCd::MoveTo(std::string modulename,int slot) +{ + unsigned int v2 = 256; + log(DEBUG,"Moving %s to slot %d",modulename.c_str(),slot); + for (unsigned int v = 0; v < Config->module_names.size(); v++) + { + if (Config->module_names[v] == modulename) + { + // found an instance, swap it with the item at MODCOUNT + v2 = v; + break; + } + } + if (v2 == (unsigned int)slot) + { + log(DEBUG,"Item %s already in slot %d!",modulename.c_str(),slot); + } + else if (v2 < 256) + { + // Swap the module names over + Config->module_names[v2] = Config->module_names[slot]; + Config->module_names[slot] = modulename; + // now swap the module factories + ircd_module* temp = factory[v2]; + factory[v2] = factory[slot]; + factory[slot] = temp; + // now swap the module objects + Module* temp_module = modules[v2]; + modules[v2] = modules[slot]; + modules[slot] = temp_module; + // now swap the implement lists (we dont + // need to swap the global or recount it) + for (int n = 0; n < 255; n++) + { + char x = Config->implement_lists[v2][n]; + Config->implement_lists[v2][n] = Config->implement_lists[slot][n]; + Config->implement_lists[slot][n] = x; + } + log(DEBUG,"Moved %s to slot successfully",modulename.c_str()); + } + else + { + log(DEBUG,"Move of %s to slot failed!",modulename.c_str()); + } +} + +void InspIRCd::MoveAfter(std::string modulename, std::string after) +{ + log(DEBUG,"Move %s after %s...",modulename.c_str(),after.c_str()); + for (unsigned int v = 0; v < Config->module_names.size(); v++) + { + if (Config->module_names[v] == after) + { + MoveTo(modulename, v); + return; + } + } +} + +void InspIRCd::MoveBefore(std::string modulename, std::string before) +{ + log(DEBUG,"Move %s before %s...",modulename.c_str(),before.c_str()); + for (unsigned int v = 0; v < Config->module_names.size(); v++) + { + if (Config->module_names[v] == before) + { + if (v > 0) + { + MoveTo(modulename, v-1); + } + else + { + MoveTo(modulename, v); + } + return; + } + } +} + +void InspIRCd::MoveToFirst(std::string modulename) +{ + MoveTo(modulename,0); +} + +void InspIRCd::MoveToLast(std::string modulename) +{ + MoveTo(modulename,MODCOUNT); +} + +void InspIRCd::BuildISupport() +{ + // the neatest way to construct the initial 005 numeric, considering the number of configure constants to go in it... + std::stringstream v; + v << "WALLCHOPS WALLVOICES MODES=" << MAXMODES << " CHANTYPES=# PREFIX=(ohv)@%+ MAP MAXCHANNELS=" << MAXCHANS << " MAXBANS=60 VBANLIST NICKLEN=" << NICKMAX-1; + v << " CASEMAPPING=rfc1459 STATUSMSG=@%+ CHARSET=ascii TOPICLEN=" << MAXTOPIC << " KICKLEN=" << MAXKICK << " MAXTARGETS=" << Config->MaxTargets << " AWAYLEN="; + v << MAXAWAY << " CHANMODES=b,k,l,psmnti FNC NETWORK=" << Config->Network << " MAXPARA=32"; + Config->data005 = v.str(); + FOREACH_MOD(I_On005Numeric,On005Numeric(Config->data005)); +} + bool InspIRCd::UnloadModule(const char* filename) { std::string filename_str = filename; @@ -294,7 +429,24 @@ bool InspIRCd::UnloadModule(const char* filename) { modules[j]->OnCleanup(TYPE_USER,u->second); } - FOREACH_MOD OnUnloadModule(modules[j],Config->module_names[j]); + + FOREACH_MOD(I_OnUnloadModule,OnUnloadModule(modules[j],Config->module_names[j])); + + for(int t = 0; t < 255; t++) + { + Config->global_implementation[t] -= Config->implement_lists[j][t]; + } + + /* We have to renumber implement_lists after unload because the module numbers change! + */ + for(int j2 = j; j2 < 254; j2++) + { + for(int t = 0; t < 255; t++) + { + Config->implement_lists[j2][t] = Config->implement_lists[j2+1][t]; + } + } + // found the module log(DEBUG,"Deleting module..."); erase_module(j); @@ -304,6 +456,7 @@ bool InspIRCd::UnloadModule(const char* filename) Parser->RemoveCommands(filename); log(DEFAULT,"Module %s unloaded",filename); MODCOUNT--; + BuildISupport(); return true; } } @@ -316,18 +469,20 @@ bool InspIRCd::LoadModule(const char* filename) { char modfile[MAXBUF]; #ifdef STATIC_LINK - snprintf(modfile,MAXBUF,"%s",filename); + strlcpy(modfile,filename,MAXBUF); #else snprintf(modfile,MAXBUF,"%s/%s",Config->ModPath,filename); #endif std::string filename_str = filename; #ifndef STATIC_LINK +#ifndef IS_CYGWIN if (!DirValid(modfile)) { log(DEFAULT,"Module %s is not within the modules directory.",modfile); snprintf(MODERR,MAXBUF,"Module %s is not within the modules directory.",modfile); return false; } +#endif #endif log(DEBUG,"Loading module: %s",modfile); #ifndef STATIC_LINK @@ -349,23 +504,46 @@ bool InspIRCd::LoadModule(const char* filename) { log(DEFAULT,"Unable to load %s: %s",modfile,factory[MODCOUNT+1]->LastError()); snprintf(MODERR,MAXBUF,"Loader/Linker error: %s",factory[MODCOUNT+1]->LastError()); - MODCOUNT--; return false; } - if (factory[MODCOUNT+1]->factory) - { - Module* m = factory[MODCOUNT+1]->factory->CreateModule(MyServer); - modules[MODCOUNT+1] = m; - /* save the module and the module's classfactory, if - * this isnt done, random crashes can occur :/ */ - Config->module_names.push_back(filename); - } - else - { - log(DEFAULT,"Unable to load %s",modfile); - snprintf(MODERR,MAXBUF,"Factory function failed!"); + try + { + if (factory[MODCOUNT+1]->factory) + { + Module* m = factory[MODCOUNT+1]->factory->CreateModule(MyServer); + modules[MODCOUNT+1] = m; + /* save the module and the module's classfactory, if + * this isnt done, random crashes can occur :/ */ + Config->module_names.push_back(filename); + + char* x = &Config->implement_lists[MODCOUNT+1][0]; + for(int t = 0; t < 255; t++) + x[t] = 0; + + modules[MODCOUNT+1]->Implements(x); + + for(int t = 0; t < 255; t++) + { + Config->global_implementation[t] += Config->implement_lists[MODCOUNT+1][t]; + if (Config->implement_lists[MODCOUNT+1][t]) + { + log(DEBUG,"Add global implementation: %d %d => %d",MODCOUNT+1,t,Config->global_implementation[t]); + } + } + } + else + { + log(DEFAULT,"Unable to load %s",modfile); + snprintf(MODERR,MAXBUF,"Factory function failed!"); + return false; + } + } + catch (ModuleException& modexcept) + { + log(DEFAULT,"Unable to load %s: ",modfile,modexcept.GetReason()); + snprintf(MODERR,MAXBUF,"Factory function threw an exception: %s",modexcept.GetReason()); return false; - } + } #ifndef STATIC_LINK } else @@ -376,24 +554,234 @@ bool InspIRCd::LoadModule(const char* filename) } #endif MODCOUNT++; - FOREACH_MOD OnLoadModule(modules[MODCOUNT],filename_str); + FOREACH_MOD(I_OnLoadModule,OnLoadModule(modules[MODCOUNT],filename_str)); + // now work out which modules, if any, want to move to the back of the queue, + // and if they do, move them there. + std::vector put_to_back; + std::vector put_to_front; + std::map put_before; + std::map put_after; + for (unsigned int j = 0; j < Config->module_names.size(); j++) + { + if (modules[j]->Prioritize() == PRIORITY_LAST) + { + put_to_back.push_back(Config->module_names[j]); + } + else if (modules[j]->Prioritize() == PRIORITY_FIRST) + { + put_to_front.push_back(Config->module_names[j]); + } + else if ((modules[j]->Prioritize() & 0xFF) == PRIORITY_BEFORE) + { + log(DEBUG,"Module %d wants PRIORITY_BEFORE",j); + put_before[Config->module_names[j]] = Config->module_names[modules[j]->Prioritize() >> 8]; + log(DEBUG,"Before: %s",Config->module_names[modules[j]->Prioritize() >> 8].c_str()); + } + else if ((modules[j]->Prioritize() & 0xFF) == PRIORITY_AFTER) + { + log(DEBUG,"Module %d wants PRIORITY_AFTER",j); + put_after[Config->module_names[j]] = Config->module_names[modules[j]->Prioritize() >> 8]; + log(DEBUG,"After: %s",Config->module_names[modules[j]->Prioritize() >> 8].c_str()); + } + } + for (unsigned int j = 0; j < put_to_back.size(); j++) + { + MoveToLast(put_to_back[j]); + } + for (unsigned int j = 0; j < put_to_front.size(); j++) + { + MoveToFirst(put_to_front[j]); + } + for (std::map::iterator j = put_before.begin(); j != put_before.end(); j++) + { + MoveBefore(j->first,j->second); + } + for (std::map::iterator j = put_after.begin(); j != put_after.end(); j++) + { + MoveAfter(j->first,j->second); + } + BuildISupport(); return true; } -int InspIRCd::Run() +void InspIRCd::DoOneIteration(bool process_module_sockets) { - bool expire_run = false; - std::vector activefds; - int incomingSockfd; - int in_port; - userrec* cu = NULL; - InspSocket* s = NULL; - InspSocket* s_del = NULL; - char* target; - unsigned int numberactive; + /*bool expire_run = false; + int activefds[MAX_DESCRIPTORS]; + int incomingSockfd; + int in_port; + userrec* cu = NULL; + InspSocket* s = NULL; + InspSocket* s_del = NULL; + unsigned int numberactive; sockaddr_in sock_us; // our port number - socklen_t uslen; // length of our port number + socklen_t uslen;*/ // length of our port number + + /* time() seems to be a pretty expensive syscall, so avoid calling it too much. + * Once per loop iteration is pleanty. + */ + OLDTIME = TIME; + TIME = time(NULL); + + /* Run background module timers every few seconds + * (the docs say modules shouldnt rely on accurate + * timing using this event, so we dont have to + * time this exactly). + */ + if (((TIME % 5) == 0) && (!expire_run)) + { + expire_lines(); + FOREACH_MOD(I_OnBackgroundTimer,OnBackgroundTimer(TIME)); + TickMissedTimers(TIME); + expire_run = true; + return; + } + else if ((TIME % 5) == 1) + { + expire_run = false; + } + + /* Once a second, do the background processing */ + if (TIME != OLDTIME) + { + if (TIME < OLDTIME) + WriteOpers("*** \002EH?!\002 -- Time is flowing BACKWARDS in this dimension! Clock drifted backwards %d secs.",abs(OLDTIME-TIME)); + DoBackgroundUserStuff(TIME); + } + + /* Process timeouts on module sockets each time around + * the loop. There shouldnt be many module sockets, at + * most, 20 or so, so this won't be much of a performance + * hit at all. + */ + if (process_module_sockets) + DoSocketTimeouts(TIME); + + TickTimers(TIME); + + /* Call the socket engine to wait on the active + * file descriptors. The socket engine has everything's + * descriptors in its list... dns, modules, users, + * servers... so its nice and easy, just one call. + */ + if (!(numberactive = SE->Wait(activefds))) + return; + + /** + * Now process each of the fd's. For users, we have a fast + * lookup table which can find a user by file descriptor, so + * processing them by fd isnt expensive. If we have a lot of + * listening ports or module sockets though, things could get + * ugly. + */ + for (unsigned int activefd = 0; activefd < numberactive; activefd++) + { + int socket_type = SE->GetType(activefds[activefd]); + switch (socket_type) + { + case X_ESTAB_CLIENT: + + cu = fd_ref_table[activefds[activefd]]; + if (cu) + ProcessUser(cu); + + break; + + case X_ESTAB_MODULE: + + if (!process_module_sockets) + return; + + /* Process module-owned sockets. + * Modules are encouraged to inherit their sockets from + * InspSocket so we can process them neatly like this. + */ + s = socket_ref[activefds[activefd]]; + + if ((s) && (!s->Poll())) + { + log(DEBUG,"Socket poll returned false, close and bail"); + SE->DelFd(s->GetFd()); + for (std::vector::iterator a = module_sockets.begin(); a < module_sockets.end(); a++) + { + s_del = (InspSocket*)*a; + if ((s_del) && (s_del->GetFd() == activefds[activefd])) + { + module_sockets.erase(a); + break; + } + } + s->Close(); + delete s; + } + break; + + case X_ESTAB_DNS: + /* When we are using single-threaded dns, + * the sockets for dns end up in our mainloop. + * When we are using multi-threaded dns, + * each thread has its own basic poll() loop + * within it, making them 'fire and forget' + * and independent of the mainloop. + */ +#ifndef THREADED_DNS + dns_poll(activefds[activefd]); +#endif + break; + + case X_LISTEN: + + /* It's a listener */ + uslen = sizeof(sock_us); + length = sizeof(client); + incomingSockfd = accept (activefds[activefd],(struct sockaddr*)&client,&length); + + if ((incomingSockfd > -1) && (!getsockname(incomingSockfd,(sockaddr*)&sock_us,&uslen))) + { + in_port = ntohs(sock_us.sin_port); + log(DEBUG,"Accepted socket %d",incomingSockfd); + /* Years and years ago, we used to resolve here + * using gethostbyaddr(). That is sucky and we + * don't do that any more... + */ + NonBlocking(incomingSockfd); + if (Config->GetIOHook(in_port)) + { + try + { + Config->GetIOHook(in_port)->OnRawSocketAccept(incomingSockfd, (char*)inet_ntoa(client.sin_addr), in_port); + } + catch (ModuleException& modexcept) + { + log(DEBUG,"Module exception cought: %s",modexcept.GetReason()); \ + } + } + stats->statsAccept++; + AddClient(incomingSockfd, in_port, false, client.sin_addr); + log(DEBUG,"Adding client on port %lu fd=%lu",(unsigned long)in_port,(unsigned long)incomingSockfd); + } + else + { + log(DEBUG,"Accept failed on fd %lu: %s",(unsigned long)incomingSockfd,strerror(errno)); + shutdown(incomingSockfd,2); + close(incomingSockfd); + stats->statsRefused++; + } + break; + + default: + /* Something went wrong if we're in here. + * In fact, so wrong, im not quite sure + * what we would do, so for now, its going + * to safely do bugger all. + */ + break; + } + } +} +int InspIRCd::Run() +{ /* Until THIS point, ServerInstance == NULL */ LoadAllModules(this); @@ -415,152 +803,11 @@ int InspIRCd::Run() WritePID(Config->PID); /* main loop, this never returns */ - for (;;) - { - /* time() seems to be a pretty expensive syscall, so avoid calling it too much. - * Once per loop iteration is pleanty. - */ - OLDTIME = TIME; - TIME = time(NULL); - - /* Run background module timers every few seconds - * (the docs say modules shouldnt rely on accurate - * timing using this event, so we dont have to - * time this exactly). - */ - if (((TIME % 8) == 0) && (!expire_run)) - { - expire_lines(); - FOREACH_MOD OnBackgroundTimer(TIME); - expire_run = true; - continue; - } - if ((TIME % 8) == 1) - expire_run = false; - - /* Once a second, do the background processing */ - if (TIME != OLDTIME) - while (DoBackgroundUserStuff(TIME)); - - /* Call the socket engine to wait on the active - * file descriptors. The socket engine has everything's - * descriptors in its list... dns, modules, users, - * servers... so its nice and easy, just one call. - */ - SE->Wait(activefds); - - /** - * Now process each of the fd's. For users, we have a fast - * lookup table which can find a user by file descriptor, so - * processing them by fd isnt expensive. If we have a lot of - * listening ports or module sockets though, things could get - * ugly. - */ - numberactive = activefds.size(); - for (unsigned int activefd = 0; activefd < numberactive; activefd++) - { - int socket_type = SE->GetType(activefds[activefd]); - switch (socket_type) - { - case X_ESTAB_CLIENT: - - cu = fd_ref_table[activefds[activefd]]; - if (cu) - ProcessUser(cu); - - break; - - case X_ESTAB_MODULE: - - /* Process module-owned sockets. - * Modules are encouraged to inherit their sockets from - * InspSocket so we can process them neatly like this. - */ - s = socket_ref[activefds[activefd]]; - - if ((s) && (!s->Poll())) - { - log(DEBUG,"Socket poll returned false, close and bail"); - SE->DelFd(s->GetFd()); - for (std::vector::iterator a = module_sockets.begin(); a < module_sockets.end(); a++) - { - s_del = (InspSocket*)*a; - if ((s_del) && (s_del->GetFd() == activefds[activefd])) - { - module_sockets.erase(a); - break; - } - } - s->Close(); - delete s; - } - - break; - - case X_ESTAB_DNS: - - /* When we are using single-threaded dns, - * the sockets for dns end up in our mainloop. - * When we are using multi-threaded dns, - * each thread has its own basic poll() loop - * within it, making them 'fire and forget' - * and independent of the mainloop. - */ -#ifndef THREADED_DNS - dns_poll(activefds[activefd]); -#endif - break; - - case X_LISTEN: - - /* It's a listener */ - uslen = sizeof(sock_us); - length = sizeof(client); - incomingSockfd = accept (activefds[activefd],(struct sockaddr*)&client,&length); - if (!getsockname(incomingSockfd,(sockaddr*)&sock_us,&uslen)) - { - in_port = ntohs(sock_us.sin_port); - log(DEBUG,"Accepted socket %d",incomingSockfd); - target = (char*)inet_ntoa(client.sin_addr); - /* Years and years ago, we used to resolve here - * using gethostbyaddr(). That is sucky and we - * don't do that any more... - */ - if (incomingSockfd >= 0) - { - if (IOHookModule) - { - IOHookModule->OnRawSocketAccept(incomingSockfd, target, in_port); - } - stats->statsAccept++; - AddClient(incomingSockfd, target, in_port, false, target); - log(DEBUG,"Adding client on port %lu fd=%lu",(unsigned long)in_port,(unsigned long)incomingSockfd); - } - else - { - WriteOpers("*** WARNING: accept() failed on port %lu (%s)",(unsigned long)in_port,target); - log(DEBUG,"accept failed: %lu",(unsigned long)in_port); - stats->statsRefused++; - } - } - else - { - log(DEBUG,"Couldnt look up the port number for fd %lu (OS BROKEN?!)",incomingSockfd); - shutdown(incomingSockfd,2); - close(incomingSockfd); - } - break; - - default: - /* Something went wrong if we're in here. - * In fact, so wrong, im not quite sure - * what we would do, so for now, its going - * to safely do bugger all. - */ - break; - } - } + expire_run = false; + while (true) + { + DoOneIteration(true); } /* This is never reached -- we hope! */ return 0;