* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
+ * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
* E-mail:
* <brain@chatspike.net>
* <Craig@chatspike.net>
#include <fstream>
#include "inspircd.h"
#include "inspircd_io.h"
-#include "inspircd_util.h"
#include "inspstring.h"
#include "helperfuncs.h"
+#include "userprocess.h"
+#include "xline.h"
extern ServerConfig *Config;
-extern int boundPortCount;
+extern InspIRCd* ServerInstance;
extern int openSockfd[MAXSOCKS];
extern time_t TIME;
-std::vector<std::string> include_stack;
+
ServerConfig::ServerConfig()
{
+ this->ClearStack();
*ServerName = *Network = *ServerDesc = *AdminName = '\0';
*AdminEmail = *AdminNick = *diepass = *restartpass = '\0';
- *motd = *rules = *PrefixQuit = *DieValue = *DNSServer = '\0';
- *ModPath = *MyExecutable = *DisabledCommands = *PID = '\0';
+ *CustomVersion = *motd = *rules = *PrefixQuit = *DieValue = *DNSServer = '\0';
+ *OperOnlyStats = *ModPath = *MyExecutable = *DisabledCommands = *PID = '\0';
log_file = NULL;
nofork = false;
unlimitcore = false;
DieDelay = 5;
}
+void ServerConfig::ClearStack()
+{
+ include_stack.clear();
+}
+
+Module* ServerConfig::GetIOHook(int port)
+{
+ std::map<int,Module*>::iterator x = IOHookModule.find(port);
+ return (x != IOHookModule.end() ? x->second : NULL);
+}
+
+bool ServerConfig::AddIOHook(int port, Module* iomod)
+{
+ if (!GetIOHook(port))
+ {
+ IOHookModule[port] = iomod;
+ return true;
+ }
+ return false;
+}
+
+bool ServerConfig::DelIOHook(int port)
+{
+ std::map<int,Module*>::iterator x = IOHookModule.find(port);
+ if (x != IOHookModule.end())
+ {
+ IOHookModule.erase(x);
+ return true;
+ }
+ return false;
+}
void ServerConfig::Read(bool bail, userrec* user)
{
ConfValue("disabled","commands",0,Config->DisabledCommands,&Config->config_f);
ConfValue("options","somaxconn",0,MCON,&Config->config_f);
ConfValue("options","softlimit",0,SLIMT,&Config->config_f);
+ ConfValue("options","operonlystats",0,Config->OperOnlyStats,&Config->config_f);
+ ConfValue("options","customversion",0,Config->CustomVersion,&Config->config_f);
Config->SoftLimit = atoi(SLIMT);
if ((Config->SoftLimit < 1) || (Config->SoftLimit > MAXCLIENTS))
Classes.clear();
for (int i = 0; i < ConfValueEnum("connect",&Config->config_f); i++)
{
- strcpy(Value,"");
+ *Value = 0;
ConfValue("connect","allow",i,Value,&Config->config_f);
ConfValue("connect","timeout",i,timeout,&Config->config_f);
ConfValue("connect","flood",i,flood,&Config->config_f);
ConfValue("connect","recvq",i,rqmax,&Config->config_f);
if (*Value)
{
- strlcpy(c.host,Value,MAXBUF);
+ c.host = Value;
c.type = CC_ALLOW;
strlcpy(Value,"",MAXBUF);
ConfValue("connect","password",i,Value,&Config->config_f);
- strlcpy(c.pass,Value,MAXBUF);
+ c.pass = Value;
c.registration_timeout = 90; // default is 2 minutes
c.pingtime = 120;
c.flood = atoi(flood);
else
{
ConfValue("connect","deny",i,Value,&Config->config_f);
- strlcpy(c.host,Value,MAXBUF);
+ c.host = Value;
c.type = CC_DENY;
Classes.push_back(c);
- log(DEBUG,"Read connect class type DENY, host=%s",c.host);
+ log(DEBUG,"Read connect class type DENY, host=%s",c.host.c_str());
}
}
if (!removed_modules.empty())
for (std::vector<std::string>::iterator removing = removed_modules.begin(); removing != removed_modules.end(); removing++)
{
- if (UnloadModule(removing->c_str()))
+ if (ServerInstance->UnloadModule(removing->c_str()))
{
WriteOpers("*** REHASH UNLOADED MODULE: %s",removing->c_str());
WriteServ(user->fd,"973 %s %s :Module %s successfully unloaded.",user->nick, removing->c_str(), removing->c_str());
}
else
{
- WriteServ(user->fd,"972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ModuleError());
+ WriteServ(user->fd,"972 %s %s :Failed to unload module %s: %s",user->nick, removing->c_str(), removing->c_str(), ServerInstance->ModuleError());
}
}
if (!added_modules.empty())
for (std::vector<std::string>::iterator adding = added_modules.begin(); adding != added_modules.end(); adding++)
{
- if (LoadModule(adding->c_str()))
+ if (ServerInstance->LoadModule(adding->c_str()))
{
WriteOpers("*** REHASH LOADED MODULE: %s",adding->c_str());
WriteServ(user->fd,"975 %s %s :Module %s successfully loaded.",user->nick, adding->c_str(), adding->c_str());
}
else
{
- WriteServ(user->fd,"974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ModuleError());
+ WriteServ(user->fd,"974 %s %s :Failed to load module %s: %s",user->nick, adding->c_str(), adding->c_str(), ServerInstance->ModuleError());
}
}
log(DEFAULT,"Successfully unloaded %lu of %lu modules and loaded %lu of %lu modules.",(unsigned long)rem,(unsigned long)removed_modules.size(),
}
-void WriteOpers(char* text, ...);
-
void Exit (int status)
{
if (Config->log_file)
void Rehash(int status)
{
WriteOpers("Rehashing config file %s due to SIGHUP",CONFIG_FILE);
+ fclose(Config->log_file);
+ OpenLog(NULL,NULL);
Config->Read(false,NULL);
}
}
}
-
-int DaemonSeed (void)
+void SetSignals()
{
- int childpid;
signal (SIGALRM, SIG_IGN);
signal (SIGHUP, Rehash);
signal (SIGPIPE, SIG_IGN);
signal (SIGTERM, Exit);
signal (SIGSEGV, Error);
+}
+
+
+int DaemonSeed (void)
+{
+ int childpid;
if ((childpid = fork ()) < 0)
return (ERROR);
else if (childpid > 0)
* Turns multiple spaces that are outside of quotes into single spaces
*/
-std::string ConfProcess(char* buffer, long linenumber, std::stringstream* errorstream, bool &error, std::string filename)
+std::string ServerConfig::ConfProcess(char* buffer, long linenumber, std::stringstream* errorstream, bool &error, std::string filename)
{
long number_of_quotes = 0;
long number_of_equals = 0;
return parsedata;
}
-int fgets_safe(char* buffer, size_t maxsize, FILE* &file)
+int ServerConfig::fgets_safe(char* buffer, size_t maxsize, FILE* &file)
{
char c_read = '\0';
unsigned int bufptr = 0;
return bufptr;
}
-bool LoadConf(const char* filename, std::stringstream *target, std::stringstream* errorstream)
+bool ServerConfig::LoadConf(const char* filename, std::stringstream *target, std::stringstream* errorstream)
{
target->str("");
errorstream->str("");
}
snprintf(newconf,10240,"%s/%s",confpath,buf);
}
- else snprintf(newconf,10240,"%s",buf);
+ else strlcpy(newconf,buf,10240);
std::stringstream merge(stringstream::in | stringstream::out);
// recursively call LoadConf and get the new data, use the same errorstream
if (LoadConf(newconf, &merge, errorstream))
else
{
bool error = false;
- std::string data = ConfProcess(buffer,linenumber++,errorstream,error,filename);
+ std::string data = this->ConfProcess(buffer,linenumber++,errorstream,error,filename);
if (error)
{
return false;
/* Counts the number of tags of a certain type within the config file, e.g. to enumerate opers */
-int EnumConf(std::stringstream *config, const char* tag)
+int ServerConfig::EnumConf(std::stringstream *config, const char* tag)
{
int ptr = 0;
char buffer[MAXBUF], c_tag[MAXBUF], c, lastc;
/* Counts the number of values within a certain tag */
-int EnumValues(std::stringstream *config, const char* tag, int index)
+int ServerConfig::EnumValues(std::stringstream *config, const char* tag, int index)
{
int ptr = 0;
char buffer[MAXBUF], c_tag[MAXBUF], c, lastc;
-int ConfValueEnum(char* tag, std::stringstream* config)
+int ServerConfig::ConfValueEnum(char* tag, std::stringstream* config)
{
return EnumConf(config,tag);
}
* ConfValue("oper","name",2,result);
*/
-int ReadConf(std::stringstream *config, const char* tag, const char* var, int index, char *result)
+int ServerConfig::ReadConf(std::stringstream *config, const char* tag, const char* var, int index, char *result)
{
int ptr = 0;
char buffer[65535], c_tag[MAXBUF], c, lastc;
if (!key)
{
/* value not found in tag */
- strcpy(result,"");
+ *result = 0;
return 0;
}
else
{
key+=strlen(var);
- while (key[0] !='"')
+ while (*key !='"')
{
- if (!strlen(key))
+ if (!*key)
{
/* missing quote */
- strcpy(result,"");
+ *result = 0;
return 0;
}
key++;
}
}
}
- strcpy(result,""); // value or its tag not found at all
+ *result = 0; // value or its tag not found at all
return 0;
}
-int ConfValue(char* tag, char* var, int index, char *result,std::stringstream *config)
+int ServerConfig::ConfValue(char* tag, char* var, int index, char *result,std::stringstream *config)
{
ReadConf(config, tag, var, index, result);
return 0;
return (sockfd);
}
}
+
+int BindPorts()
+{
+ char configToken[MAXBUF], Addr[MAXBUF], Type[MAXBUF];
+ sockaddr_in client,server;
+ int clientportcount = 0;
+ int BoundPortCount = 0;
+ for (int count = 0; count < Config->ConfValueEnum("bind",&Config->config_f); count++)
+ {
+ Config->ConfValue("bind","port",count,configToken,&Config->config_f);
+ Config->ConfValue("bind","address",count,Addr,&Config->config_f);
+ Config->ConfValue("bind","type",count,Type,&Config->config_f);
+ if (strcmp(Type,"servers"))
+ {
+ // modules handle server bind types now,
+ // its not a typo in the strcmp.
+ Config->ports[clientportcount] = atoi(configToken);
+ strlcpy(Config->addrs[clientportcount],Addr,256);
+ clientportcount++;
+ log(DEBUG,"InspIRCd: startup: read binding %s:%s [%s] from config",Addr,configToken, Type);
+ }
+ }
+ int PortCount = clientportcount;
+
+ for (int count = 0; count < PortCount; count++)
+ {
+ if ((openSockfd[BoundPortCount] = OpenTCPSocket()) == ERROR)
+ {
+ log(DEBUG,"InspIRCd: startup: bad fd %lu",(unsigned long)openSockfd[BoundPortCount]);
+ return(ERROR);
+ }
+ if (BindSocket(openSockfd[BoundPortCount],client,server,Config->ports[count],Config->addrs[count]) == ERROR)
+ {
+ log(DEFAULT,"InspIRCd: startup: failed to bind port %lu",(unsigned long)Config->ports[count]);
+ }
+ else /* well we at least bound to one socket so we'll continue */
+ {
+ BoundPortCount++;
+ }
+ }
+
+ /* if we didn't bind to anything then abort */
+ if (!BoundPortCount)
+ {
+ log(DEFAULT,"InspIRCd: startup: no ports bound, bailing!");
+ printf("\nERROR: Was not able to bind any of %lu ports! Please check your configuration.\n\n", (unsigned long)PortCount);
+ return (ERROR);
+ }
+
+ return BoundPortCount;
+}
+