/** Instance we were created by
*/
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
/** Timeout class or NULL
*/
this->Timeout = NULL;
this->state = I_DISCONNECTED;
this->fd = -1;
- this->Instance = SI;
+ this->ServerInstance = SI;
}
BufferedSocket::BufferedSocket(InspIRCd* SI, int newfd, const char* ip)
this->fd = newfd;
this->state = I_CONNECTED;
strlcpy(this->IP,ip,MAXBUF);
- this->Instance = SI;
+ this->ServerInstance = SI;
if (this->fd > -1)
- this->Instance->SE->AddFd(this);
+ this->ServerInstance->SE->AddFd(this);
}
BufferedSocket::BufferedSocket(InspIRCd* SI, const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip)
{
this->cbindip = connectbindip;
this->fd = -1;
- this->Instance = SI;
+ this->ServerInstance = SI;
strlcpy(host,ipaddr.c_str(),MAXBUF);
this->Timeout = NULL;
}
if (!ipvalid)
{
- this->Instance->Logs->Log("SOCKET", DEBUG,"BUG: Hostname passed to BufferedSocket, rather than an IP address!");
+ this->ServerInstance->Logs->Log("SOCKET", DEBUG,"BUG: Hostname passed to BufferedSocket, rather than an IP address!");
this->OnError(I_ERR_CONNECT);
this->Close();
this->fd = -1;
int recvbuf = 32768;
if(setsockopt(this->fd,SOL_SOCKET,SO_SNDBUF,(const char *)&sendbuf,sizeof(sendbuf)) || setsockopt(this->fd,SOL_SOCKET,SO_RCVBUF,(const char *)&recvbuf,sizeof(sendbuf)))
{
- //this->Instance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd());
+ //this->ServerInstance->Log(DEFAULT, "Could not increase SO_SNDBUF/SO_RCVBUF for socket %u", GetFd());
; // do nothing. I'm a little sick of people trying to interpret this message as a result of why their incorrect setups don't work.
}
}
*/
bool BufferedSocket::BindAddr(const std::string &ip)
{
- ConfigReader Conf(this->Instance);
+ ConfigReader Conf(this->ServerInstance);
socklen_t size = sizeof(sockaddr_in);
#ifdef IPV6
bool v6 = false;
}
}
- if (Instance->SE->Bind(this->fd, s, size) < 0)
+ if (ServerInstance->SE->Bind(this->fd, s, size) < 0)
{
this->state = I_ERROR;
this->OnError(I_ERR_BIND);
}
j++;
}
- Instance->Logs->Log("SOCKET", DEBUG,"nothing in the config to bind()!");
+ ServerInstance->Logs->Log("SOCKET", DEBUG,"nothing in the config to bind()!");
return true;
}
}
}
- Instance->SE->NonBlocking(this->fd);
+ ServerInstance->SE->NonBlocking(this->fd);
- if (Instance->SE->Connect(this, (sockaddr*)addr, size) == -1)
+ if (ServerInstance->SE->Connect(this, (sockaddr*)addr, size) == -1)
{
if (errno != EINPROGRESS)
{
return false;
}
- this->Timeout = new SocketTimeout(this->GetFd(), this->Instance, this, maxtime, this->Instance->Time());
- this->Instance->Timers->AddTimer(this->Timeout);
+ this->Timeout = new SocketTimeout(this->GetFd(), this->ServerInstance, this, maxtime, this->ServerInstance->Time());
+ this->ServerInstance->Timers->AddTimer(this->Timeout);
}
this->state = I_CONNECTING;
if (this->fd > -1)
{
- if (!this->Instance->SE->AddFd(this))
+ if (!this->ServerInstance->SE->AddFd(this))
{
this->OnError(I_ERR_NOMOREFDS);
this->Close();
this->SetQueues();
}
- Instance->Logs->Log("SOCKET", DEBUG,"BufferedSocket::DoConnect success");
+ ServerInstance->Logs->Log("SOCKET", DEBUG,"BufferedSocket::DoConnect success");
return true;
}
}
catch (CoreException& modexcept)
{
- Instance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+ ServerInstance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
}
}
- Instance->SE->Shutdown(this, 2);
- if (Instance->SE->Close(this) != -1)
+ ServerInstance->SE->Shutdown(this, 2);
+ if (ServerInstance->SE->Close(this) != -1)
this->OnClose();
- if (Instance->SocketCull.find(this) == Instance->SocketCull.end())
- Instance->SocketCull[this] = this;
+ if (ServerInstance->SocketCull.find(this) == ServerInstance->SocketCull.end())
+ ServerInstance->SocketCull[this] = this;
}
errno = save;
}
const char* BufferedSocket::Read()
{
- if (!Instance->SE->BoundsCheckFd(this))
+ if (!ServerInstance->SE->BoundsCheckFd(this))
return NULL;
int n = 0;
- char* ReadBuffer = Instance->GetReadBuffer();
+ char* ReadBuffer = ServerInstance->GetReadBuffer();
if (this->GetIOHook())
{
int MOD_RESULT = 0;
try
{
- MOD_RESULT = this->GetIOHook()->OnRawSocketRead(this->fd, ReadBuffer, Instance->Config->NetBufferSize, result2);
+ MOD_RESULT = this->GetIOHook()->OnRawSocketRead(this->fd, ReadBuffer, ServerInstance->Config->NetBufferSize, result2);
}
catch (CoreException& modexcept)
{
- Instance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+ ServerInstance->Logs->Log("SOCKET", DEFAULT,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
}
if (MOD_RESULT < 0)
{
}
else
{
- n = recv(this->fd, ReadBuffer, Instance->Config->NetBufferSize, 0);
+ n = recv(this->fd, ReadBuffer, ServerInstance->Config->NetBufferSize, 0);
}
/*
outbuffer.push_back(data);
/* Mark ourselves as wanting write */
- this->Instance->SE->WantWrite(this);
+ this->ServerInstance->SE->WantWrite(this);
}
bool BufferedSocket::FlushWriteBuffer()
}
catch (CoreException& modexcept)
{
- Instance->Logs->Log("SOCKET", DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+ ServerInstance->Logs->Log("SOCKET", DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
return true;
}
}
while (outbuffer.size() && (errno != EAGAIN))
{
/* Send a line */
- int result = Instance->SE->Send(this, outbuffer[0].c_str(), outbuffer[0].length(), 0);
+ int result = ServerInstance->SE->Send(this, outbuffer[0].c_str(), outbuffer[0].length(), 0);
if (result > 0)
{
}
else if (result == 0)
{
- this->Instance->SE->DelFd(this);
+ this->ServerInstance->SE->DelFd(this);
this->Close();
return true;
}
{
this->OnError(I_ERR_WRITE);
this->state = I_ERROR;
- this->Instance->SE->DelFd(this);
+ this->ServerInstance->SE->DelFd(this);
this->Close();
return true;
}
if ((errno == EAGAIN) && (fd > -1))
{
- this->Instance->SE->WantWrite(this);
+ this->ServerInstance->SE->WantWrite(this);
}
return (fd < 0);
if (this->GetIOHook())
{
- Instance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
+ ServerInstance->Logs->Log("SOCKET",DEBUG,"Hook for raw connect");
try
{
this->GetIOHook()->OnRawSocketConnect(this->fd);
}
catch (CoreException& modexcept)
{
- Instance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
+ ServerInstance->Logs->Log("SOCKET",DEBUG,"%s threw an exception: %s", modexcept.GetSource(), modexcept.GetReason());
return false;
}
}
this->Close();
if (Timeout)
{
- Instance->Timers->DelTimer(Timeout);
+ ServerInstance->Timers->DelTimer(Timeout);
Timeout = NULL;
}
}
break;
}
- if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
- this->Instance->SocketCull[this] = this;
+ if (this->ServerInstance->SocketCull.find(this) == this->ServerInstance->SocketCull.end())
+ this->ServerInstance->SocketCull[this] = this;
return;
break;
}
{
if (!this->OnDataReady())
{
- if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
- this->Instance->SocketCull[this] = this;
+ if (this->ServerInstance->SocketCull.find(this) == this->ServerInstance->SocketCull.end())
+ this->ServerInstance->SocketCull[this] = this;
return;
}
break;
{
if (!this->InternalMarkConnected())
{
- if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
- this->Instance->SocketCull[this] = this;
+ if (this->ServerInstance->SocketCull.find(this) == this->ServerInstance->SocketCull.end())
+ this->ServerInstance->SocketCull[this] = this;
return;
}
return;
{
if (!this->OnWriteReady())
{
- if (this->Instance->SocketCull.find(this) == this->Instance->SocketCull.end())
- this->Instance->SocketCull[this] = this;
+ if (this->ServerInstance->SocketCull.find(this) == this->ServerInstance->SocketCull.end())
+ this->ServerInstance->SocketCull[this] = this;
return;
}
}
{
private:
ModuleMsSQL* Parent;
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
public:
QueryThread(InspIRCd* si, ModuleMsSQL* mod)
- : Thread(), Parent(mod), Instance(si)
+ : Thread(), Parent(mod), ServerInstance(si)
{
}
~QueryThread() { }
virtual bool OnDataReady()
{
char data = 0;
- if (Instance->SE->Recv(this, &data, 1, 0) > 0)
+ if (ServerInstance->SE->Recv(this, &data, 1, 0) > 0)
{
Dispatch();
return true;
{
private:
ResultQueue results;
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
Module* mod;
SQLhost host;
TDSLOGIN* login;
QueryQueue queue;
SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
- : Instance(SI), mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
+ : ServerInstance(SI), mod(m), host(hi), login(NULL), sock(NULL), context(NULL)
{
if (OpenDB())
{
if (tds_process_simple_query(sock) != TDS_SUCCEED)
{
LoggingMutex->Lock();
- Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
+ ServerInstance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
else
{
LoggingMutex->Lock();
- Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
+ ServerInstance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
else
{
LoggingMutex->Lock();
- Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);
+ ServerInstance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);
LoggingMutex->Unlock();
CloseDB();
}
char* msquery = strdup(req.query.q.data());
LoggingMutex->Lock();
- Instance->Logs->Log("m_mssql",DEBUG,"doing Query: %s",msquery);
+ ServerInstance->Logs->Log("m_mssql",DEBUG,"doing Query: %s",msquery);
LoggingMutex->Unlock();
if (tds_submit_query(sock, msquery) != TDS_SUCCEED)
{
int tds_res;
while (tds_process_tokens(sock, &tds_res, NULL, TDS_TOKEN_RESULTS) == TDS_SUCCEED)
{
- //Instance->Logs->Log("m_mssql",DEBUG,"<******> result type: %d", tds_res);
- //Instance->Logs->Log("m_mssql",DEBUG,"AFFECTED ROWS: %d", sock->rows_affected);
+ //ServerInstance->Logs->Log("m_mssql",DEBUG,"<******> result type: %d", tds_res);
+ //ServerInstance->Logs->Log("m_mssql",DEBUG,"AFFECTED ROWS: %d", sock->rows_affected);
switch (tds_res)
{
case TDS_ROWFMT_RESULT:
{
SQLConn* sc = (SQLConn*)pContext->parent;
LoggingMutex->Lock();
- sc->Instance->Logs->Log("m_mssql", DEBUG, "Message for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
+ sc->ServerInstance->Logs->Log("m_mssql", DEBUG, "Message for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
LoggingMutex->Unlock();
return 0;
}
{
SQLConn* sc = (SQLConn*)pContext->parent;
LoggingMutex->Lock();
- sc->Instance->Logs->Log("m_mssql", DEFAULT, "Error for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
+ sc->ServerInstance->Logs->Log("m_mssql", DEFAULT, "Error for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
LoggingMutex->Unlock();
return 0;
}
class SQLConn : public EventHandler
{
private:
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
SQLhost confhost; /* The <database> entry */
Module* us; /* Pointer to the SQL provider itself */
PGconn* sql; /* PgSQL database connection handle */
public:
SQLConn(InspIRCd* SI, Module* self, const SQLhost& hi)
- : EventHandler(), Instance(SI), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false)
+ : EventHandler(), ServerInstance(SI), confhost(hi), us(self), sql(NULL), status(CWRITE), qinprog(false)
{
- idle = this->Instance->Time();
+ idle = this->ServerInstance->Time();
if(!DoConnect())
{
- Instance->Logs->Log("m_pgsql",DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id));
+ ServerInstance->Logs->Log("m_pgsql",DEFAULT, "WARNING: Could not connect to database with id: " + ConvToStr(hi.id));
DelayReconnect();
}
}
if(this->fd <= -1)
return false;
- if (!this->Instance->SE->AddFd(this))
+ if (!this->ServerInstance->SE->AddFd(this))
{
- Instance->Logs->Log("m_pgsql",DEBUG, "BUG: Couldn't add pgsql socket to socket engine");
+ ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Couldn't add pgsql socket to socket engine");
return false;
}
switch(PQconnectPoll(sql))
{
case PGRES_POLLING_WRITING:
- Instance->SE->WantWrite(this);
+ ServerInstance->SE->WantWrite(this);
status = CWRITE;
return true;
case PGRES_POLLING_READING:
/* We just read stuff from the server, that counts as it being alive
* so update the idle-since time :p
*/
- idle = this->Instance->Time();
+ idle = this->ServerInstance->Time();
if (PQisBusy(sql))
{
switch(PQresetPoll(sql))
{
case PGRES_POLLING_WRITING:
- Instance->SE->WantWrite(this);
+ ServerInstance->SE->WantWrite(this);
status = CWRITE;
return DoPoll();
case PGRES_POLLING_READING:
#endif
if(error)
{
- Instance->Logs->Log("m_pgsql",DEBUG, "BUG: Apparently PQescapeStringConn() failed somehow...don't know how or what to do...");
+ ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Apparently PQescapeStringConn() failed somehow...don't know how or what to do...");
}
/* Incremenet queryend to the end of the newly escaped parameter */
}
else
{
- Instance->Logs->Log("m_pgsql",DEBUG, "BUG: Found a substitution location but no parameter to substitute :|");
+ ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Found a substitution location but no parameter to substitute :|");
break;
}
}
}
void Close() {
- if (!this->Instance->SE->DelFd(this))
+ if (!this->ServerInstance->SE->DelFd(this))
{
if (sql && PQstatus(sql) == CONNECTION_BAD)
{
- this->Instance->SE->DelFd(this, true);
+ this->ServerInstance->SE->DelFd(this, true);
}
else
{
- Instance->Logs->Log("m_pgsql",DEBUG, "BUG: PQsocket cant be removed from socket engine!");
+ ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: PQsocket cant be removed from socket engine!");
}
}
virtual bool OnDataReady()
{
char data = 0;
- if (Instance->SE->Recv(this, &data, 1, 0) > 0)
+ if (ServerInstance->SE->Recv(this, &data, 1, 0) > 0)
{
Dispatch();
return true;
{
private:
ResultQueue results;
- InspIRCd* Instance;
+ InspIRCd* ServerInstance;
Module* mod;
SQLhost host;
sqlite3* conn;
public:
SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
- : Instance(SI), mod(m), host(hi)
+ : ServerInstance(SI), mod(m), host(hi)
{
if (OpenDB() != SQLITE_OK)
{
- Instance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + host.id);
+ ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + host.id);
CloseDB();
}
}
this->Write(http_version + " "+ConvToStr(response)+" "+Response(response)+"\r\n");
- time_t local = this->Instance->Time();
+ time_t local = this->ServerInstance->Time();
struct tm *timeinfo = gmtime(&local);
char *date = asctime(timeinfo);
date[strlen(date) - 1] = '\0';
if (reqbuffer.length() >= 8192)
{
- Instance->Logs->Log("m_httpd",DEBUG, "m_httpd dropped connection due to an oversized request buffer");
+ ServerInstance->Logs->Log("m_httpd",DEBUG, "m_httpd dropped connection due to an oversized request buffer");
reqbuffer.clear();
return false;
}
claimed = false;
HTTPRequest httpr(request_type,uri,&headers,this,this->GetIP(),postdata);
Event acl((char*)&httpr, (Module*)HttpModule, "httpd_acl");
- acl.Send(this->Instance);
+ acl.Send(this->ServerInstance);
if (!claimed)
{
Event e((char*)&httpr, (Module*)HttpModule, "httpd_url");
- e.Send(this->Instance);
+ e.Send(this->ServerInstance);
if (!claimed)
{
SendHTTPError(404);
{
if (params.size() < 6)
{
- this->Instance->SNO->WriteToSnoMask('x',"%s sent me a malformed ADDLINE of type %s.",prefix.c_str(),params[0].c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('x',"%s sent me a malformed ADDLINE of type %s.",prefix.c_str(),params[0].c_str());
return true;
}
- XLineFactory* xlf = Instance->XLines->GetFactory(params[0]);
+ XLineFactory* xlf = ServerInstance->XLines->GetFactory(params[0]);
std::string setter = "<unknown>";
- User* usr = Instance->FindNick(prefix);
+ User* usr = ServerInstance->FindNick(prefix);
if (usr)
setter = usr->nick;
else
if (!xlf)
{
- this->Instance->SNO->WriteToSnoMask('x',"%s sent me an unknown ADDLINE type (%s).",setter.c_str(),params[0].c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('x',"%s sent me an unknown ADDLINE type (%s).",setter.c_str(),params[0].c_str());
return true;
}
XLine* xl = NULL;
try
{
- xl = xlf->Generate(Instance->Time(), atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
+ xl = xlf->Generate(ServerInstance->Time(), atoi(params[4].c_str()), params[2].c_str(), params[5].c_str(), params[1].c_str());
}
catch (ModuleException &e)
{
- this->Instance->SNO->WriteToSnoMask('x',"Unable to ADDLINE type %s from %s: %s", params[0].c_str(), setter.c_str(), e.GetReason());
+ this->ServerInstance->SNO->WriteToSnoMask('x',"Unable to ADDLINE type %s from %s: %s", params[0].c_str(), setter.c_str(), e.GetReason());
return true;
}
xl->SetCreateTime(atoi(params[3].c_str()));
- if (Instance->XLines->AddLine(xl,NULL))
+ if (ServerInstance->XLines->AddLine(xl,NULL))
{
if (xl->duration)
{
- this->Instance->SNO->WriteToSnoMask('x',"%s added %s%s on %s to expire on %s (%s).",setter.c_str(),params[0].c_str(),params[0].length() == 1 ? "LINE" : "",
- params[1].c_str(),Instance->TimeString(xl->expiry).c_str(),params[5].c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('x',"%s added %s%s on %s to expire on %s (%s).",setter.c_str(),params[0].c_str(),params[0].length() == 1 ? "LINE" : "",
+ params[1].c_str(),ServerInstance->TimeString(xl->expiry).c_str(),params[5].c_str());
}
else
{
- this->Instance->SNO->WriteToSnoMask('x',"%s added permanent %s%s on %s (%s).",setter.c_str(),params[0].c_str(),params[0].length() == 1 ? "LINE" : "",
+ this->ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent %s%s on %s (%s).",setter.c_str(),params[0].c_str(),params[0].length() == 1 ? "LINE" : "",
params[1].c_str(),params[5].c_str());
}
params[5] = ":" + params[5];
- User* u = Instance->FindNick(prefix);
+ User* u = ServerInstance->FindNick(prefix);
Utils->DoOneToAllButSender(prefix, "ADDLINE", params, u ? u->server : prefix);
TreeServer *remoteserver = Utils->FindServer(u ? u->server : prefix);
if (!remoteserver->bursting)
{
- Instance->XLines->ApplyLines();
+ ServerInstance->XLines->ApplyLines();
}
}
else
{
if (params.size() > 0)
{
- if (InspIRCd::Match(this->Instance->Config->ServerName, params[0]))
+ if (InspIRCd::Match(this->ServerInstance->Config->ServerName, params[0]))
{
/* It's for our server */
string_list results;
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
{
std::deque<std::string> par;
par.push_back(prefix);
par.push_back("");
- par[1] = std::string("::")+Instance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+Instance->Config->ServerName;
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
- par[1] = std::string("::")+Instance->Config->ServerName+" 257 "+source->nick+" :Name - "+Instance->Config->AdminName;
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
- par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+Instance->Config->AdminNick;
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
- par[1] = std::string("::")+Instance->Config->ServerName+" 258 "+source->nick+" :E-Mail - "+Instance->Config->AdminEmail;
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+ServerInstance->Config->ServerName;
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 257 "+source->nick+" :Name - "+ServerInstance->Config->AdminName;
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 258 "+source->nick+" :Nickname - "+ServerInstance->Config->AdminNick;
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 258 "+source->nick+" :E-Mail - "+ServerInstance->Config->AdminEmail;
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
}
}
else
{
/* Pass it on */
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
Utils->DoOneToOne(prefix, "ADMIN", params, params[0]);
}
std::string TreeSocket::MyCapabilities()
{
- std::vector<std::string> modlist = this->Instance->Modules->GetAllModuleNames(VF_COMMON);
+ std::vector<std::string> modlist = this->ServerInstance->Modules->GetAllModuleNames(VF_COMMON);
std::string capabilities;
sort(modlist.begin(),modlist.end());
for (unsigned int i = 0; i < modlist.size(); i++)
#endif
std::string extra;
/* Do we have sha256 available? If so, we send a challenge */
- if (Utils->ChallengeResponse && (Instance->Modules->Find("m_sha256.so")))
+ if (Utils->ChallengeResponse && (ServerInstance->Modules->Find("m_sha256.so")))
{
this->SetOurChallenge(RandString(20));
extra = " CHALLENGE=" + this->GetOurChallenge();
}
this->WriteLine("CAPAB CAPABILITIES " /* Preprocessor does this one. */
- ":NICKMAX="+ConvToStr(Instance->Config->Limits.NickMax)+
- " HALFOP="+ConvToStr(Instance->Config->AllowHalfop)+
- " CHANMAX="+ConvToStr(Instance->Config->Limits.ChanMax)+
- " MAXMODES="+ConvToStr(Instance->Config->Limits.MaxModes)+
- " IDENTMAX="+ConvToStr(Instance->Config->Limits.IdentMax)+
- " MAXQUIT="+ConvToStr(Instance->Config->Limits.MaxQuit)+
- " MAXTOPIC="+ConvToStr(Instance->Config->Limits.MaxTopic)+
- " MAXKICK="+ConvToStr(Instance->Config->Limits.MaxKick)+
- " MAXGECOS="+ConvToStr(Instance->Config->Limits.MaxGecos)+
- " MAXAWAY="+ConvToStr(Instance->Config->Limits.MaxAway)+
+ ":NICKMAX="+ConvToStr(ServerInstance->Config->Limits.NickMax)+
+ " HALFOP="+ConvToStr(ServerInstance->Config->AllowHalfop)+
+ " CHANMAX="+ConvToStr(ServerInstance->Config->Limits.ChanMax)+
+ " MAXMODES="+ConvToStr(ServerInstance->Config->Limits.MaxModes)+
+ " IDENTMAX="+ConvToStr(ServerInstance->Config->Limits.IdentMax)+
+ " MAXQUIT="+ConvToStr(ServerInstance->Config->Limits.MaxQuit)+
+ " MAXTOPIC="+ConvToStr(ServerInstance->Config->Limits.MaxTopic)+
+ " MAXKICK="+ConvToStr(ServerInstance->Config->Limits.MaxKick)+
+ " MAXGECOS="+ConvToStr(ServerInstance->Config->Limits.MaxGecos)+
+ " MAXAWAY="+ConvToStr(ServerInstance->Config->Limits.MaxAway)+
" IP6NATIVE="+ConvToStr(ip6)+
" IP6SUPPORT="+ConvToStr(ip6support)+
" PROTOCOL="+ConvToStr(ProtocolVersion)+extra+
- " PREFIX="+Instance->Modes->BuildPrefixes()+
- " CHANMODES="+Instance->Modes->ChanModes()+
+ " PREFIX="+ServerInstance->Modes->BuildPrefixes()+
+ " CHANMODES="+ServerInstance->Modes->ChanModes()+
" SVSPART=1");
this->WriteLine("CAPAB END");
reason = "Protocol version not specified";
}
- if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->Instance->Modes->BuildPrefixes())
+ if(this->CapKeys.find("PREFIX") != this->CapKeys.end() && this->CapKeys.find("PREFIX")->second != this->ServerInstance->Modes->BuildPrefixes())
reason = "One or more of the prefixes on the remote server are invalid on this server.";
- if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (Instance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(Instance->Config->AllowHalfop))))
+ if (((this->CapKeys.find("HALFOP") == this->CapKeys.end()) && (ServerInstance->Config->AllowHalfop)) || ((this->CapKeys.find("HALFOP") != this->CapKeys.end()) && (this->CapKeys.find("HALFOP")->second != ConvToStr(ServerInstance->Config->AllowHalfop))))
reason = "We don't both have halfop support enabled/disabled identically";
/* Challenge response, store their challenge for our password */
std::map<std::string,std::string>::iterator n = this->CapKeys.find("CHALLENGE");
- if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (Instance->Modules->Find("m_sha256.so")))
+ if (Utils->ChallengeResponse && (n != this->CapKeys.end()) && (ServerInstance->Modules->Find("m_sha256.so")))
{
/* Challenge-response is on now */
this->SetTheirChallenge(n->second);
if (!this->GetTheirChallenge().empty() && (this->LinkState == CONNECTING))
{
this->SendCapabilities();
- this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 "+
- Instance->Config->GetSID()+" :"+this->Instance->Config->ServerDesc);
+ this->WriteLine(std::string("SERVER ")+this->ServerInstance->Config->ServerName+" "+this->MakePass(OutboundPass, this->GetTheirChallenge())+" 0 "+
+ ServerInstance->Config->GetSID()+" :"+this->ServerInstance->Config->ServerDesc);
}
}
else
if (this->LinkState == CONNECTING)
{
this->SendCapabilities();
- this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+OutboundPass+" 0 "+Instance->Config->GetSID()+" :"+this->Instance->Config->ServerDesc);
+ this->WriteLine(std::string("SERVER ")+this->ServerInstance->Config->ServerName+" "+OutboundPass+" 0 "+ServerInstance->Config->GetSID()+" :"+this->ServerInstance->Config->ServerDesc);
}
}
std::string setter = "<unknown>";
- User* user = Instance->FindNick(prefix);
+ User* user = ServerInstance->FindNick(prefix);
if (user)
setter = user->nick;
else
/* NOTE: No check needed on 'user', this function safely handles NULL */
- if (Instance->XLines->DelLine(params[1].c_str(), params[0], user))
+ if (ServerInstance->XLines->DelLine(params[1].c_str(), params[0], user))
{
- this->Instance->SNO->WriteToSnoMask('x',"%s removed %s%s on %s.", setter.c_str(),
+ this->ServerInstance->SNO->WriteToSnoMask('x',"%s removed %s%s on %s.", setter.c_str(),
params[0].c_str(), params[0].length() == 1 ? "LINE" : "", params[1].c_str());
Utils->DoOneToAllButSender(prefix,"DELLINE", params, prefix);
}
{
if (params.size() > 1)
{
- if (InspIRCd::Match(Instance->Config->GetSID(), params[0]))
+ if (InspIRCd::Match(ServerInstance->Config->GetSID(), params[0]))
{
Event event((char*) ¶ms, (Module*)this->Utils->Creator, "encap_received");
- event.Send(Instance);
+ event.Send(ServerInstance);
}
if (params[0].find('*') != std::string::npos)
{
if (params.size() < 1)
return true;
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
if (params.size() < 3)
return true;
- irc::modestacker modestack(Instance, true); /* Modes to apply from the users in the user list */
+ irc::modestacker modestack(ServerInstance, true); /* Modes to apply from the users in the user list */
User* who = NULL; /* User we are currently checking */
std::string channel = params[0]; /* Channel name, as a string */
time_t TS = atoi(params[1].c_str()); /* Timestamp given to us for remote side */
irc::tokenstream users((params.size() > 3) ? params[params.size() - 1] : ""); /* users from the user list */
bool apply_other_sides_modes = true; /* True if we are accepting the other side's modes */
- Channel* chan = this->Instance->FindChan(channel); /* The channel we're sending joins to */
- time_t ourTS = chan ? chan->age : Instance->Time()+600; /* The TS of our side of the link */
+ Channel* chan = this->ServerInstance->FindChan(channel); /* The channel we're sending joins to */
+ time_t ourTS = chan ? chan->age : ServerInstance->Time()+600; /* The TS of our side of the link */
bool created = !chan; /* True if the channel doesnt exist here yet */
std::string item; /* One item in the list of nicks */
if (!TS)
{
- Instance->Logs->Log("m_spanningtree",DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped.");
- Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"*** BUG? *** TS of 0 sent to FJOIN. Are some services authors smoking craq, or is it 1970 again?. Dropped.");
+ ServerInstance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FJOIN with a TS of zero. Total craq. Command was dropped.", source.c_str());
return true;
}
if (created)
- chan = new Channel(Instance, channel, ourTS);
+ chan = new Channel(ServerInstance, channel, ourTS);
/* If our TS is less than theirs, we dont accept their modes */
if (ourTS < TS)
{
std::deque<std::string> param_list;
if (Utils->AnnounceTSChange && chan)
- chan->WriteChannelWithServ(Instance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name.c_str(), chan->name.c_str(), (unsigned long) ourTS, (unsigned long) TS);
+ chan->WriteChannelWithServ(ServerInstance->Config->ServerName, "NOTICE %s :TS for %s changed from %lu to %lu", chan->name.c_str(), chan->name.c_str(), (unsigned long) ourTS, (unsigned long) TS);
ourTS = TS;
if (!created)
{
chan->age = TS;
param_list.push_back(channel);
- this->RemoveStatus(Instance->Config->GetSID(), param_list);
+ this->RemoveStatus(ServerInstance->Config->GetSID(), param_list);
}
}
modelist.push_back(params[idx]);
}
- this->Instance->SendMode(modelist, this->Instance->FakeClient);
+ this->ServerInstance->SendMode(modelist, this->ServerInstance->FakeClient);
}
/* Now, process every 'modes,nick' pair */
/* Iterate through all modes for this user and check they are valid. */
while ((*unparsedmodes) && (*unparsedmodes != ','))
{
- ModeHandler *mh = Instance->Modes->FindMode(*unparsedmodes, MODETYPE_CHANNEL);
+ ModeHandler *mh = ServerInstance->Modes->FindMode(*unparsedmodes, MODETYPE_CHANNEL);
if (mh)
modes += *unparsedmodes;
else
usr++;
/* Check the user actually exists */
- who = this->Instance->FindUUID(usr);
+ who = this->ServerInstance->FindUUID(usr);
if (who)
{
/* Check that the user's 'direction' is correct */
for (std::string::iterator x = modes.begin(); x != modes.end(); ++x)
modestack.Push(*x, who->nick);
- Channel::JoinUser(this->Instance, who, channel.c_str(), true, "", true, TS);
+ Channel::JoinUser(this->ServerInstance, who, channel.c_str(), true, "", true, TS);
}
else
{
- Instance->Logs->Log("m_spanningtree",SPARSE, "Ignored nonexistant user %s in fjoin to %s (probably quit?)", usr, channel.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",SPARSE, "Ignored nonexistant user %s in fjoin to %s (probably quit?)", usr, channel.c_str());
continue;
}
}
{
mode_junk.push_back(stackresult[j]);
}
- Instance->SendMode(mode_junk, Instance->FakeClient);
+ ServerInstance->SendMode(mode_junk, ServerInstance->FakeClient);
}
}
if (params.size() < 1)
return true;
- Channel* c = Instance->FindChan(params[0]);
+ Channel* c = ServerInstance->FindChan(params[0]);
if (c)
{
- irc::modestacker stack(Instance, false);
+ irc::modestacker stack(ServerInstance, false);
std::deque<std::string> stackresult;
std::vector<std::string> mode_junk;
mode_junk.push_back(c->name);
for (char modeletter = 'A'; modeletter <= 'z'; ++modeletter)
{
- ModeHandler* mh = Instance->Modes->FindMode(modeletter, MODETYPE_CHANNEL);
+ ModeHandler* mh = ServerInstance->Modes->FindMode(modeletter, MODETYPE_CHANNEL);
/* Passing a pointer to a modestacker here causes the mode to be put onto the mode stack,
* rather than applied immediately. Module unloads require this to be done immediately,
for (size_t j = 0; j < stackresult.size(); j++)
mode_junk.push_back(stackresult[j]);
- Instance->SendMode(mode_junk, Instance->FakeClient);
+ ServerInstance->SendMode(mode_junk, ServerInstance->FakeClient);
}
}
return true;
std::string sourceserv;
/* Are we dealing with an FMODE from a user, or from a server? */
- User* who = this->Instance->FindNick(source);
+ User* who = this->ServerInstance->FindNick(source);
if (who)
{
/* FMODE from a user, set sourceserv to the users server name */
else
{
/* FMODE from a server, use a fake user to receive mode feedback */
- who = this->Instance->FakeClient;
+ who = this->ServerInstance->FakeClient;
smode = true; /* Setting this flag tells us it is a server mode*/
sourceserv = source; /* Set sourceserv to the actual source string */
}
}
/* Extract the TS value of the object, either User or Channel */
- User* dst = this->Instance->FindNick(params[0]);
+ User* dst = this->ServerInstance->FindNick(params[0]);
Channel* chan = NULL;
time_t ourTS = 0;
}
else
{
- chan = this->Instance->FindChan(params[0]);
+ chan = this->ServerInstance->FindChan(params[0]);
if (chan)
{
ourTS = chan->age;
if (!TS)
{
- Instance->Logs->Log("m_spanningtree",DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped.");
- Instance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"*** BUG? *** TS of 0 sent to FMODE. Are some services authors smoking craq, or is it 1970 again?. Dropped.");
+ ServerInstance->SNO->WriteToSnoMask('d', "WARNING: The server %s is sending FMODE with a TS of zero. Total craq. Mode was dropped.", sourceserv.c_str());
return true;
}
{
if (smode)
{
- this->Instance->SendMode(modelist, who);
+ this->ServerInstance->SendMode(modelist, who);
}
else
{
- this->Instance->CallCommandHandler("MODE", modelist, who);
+ this->ServerInstance->CallCommandHandler("MODE", modelist, who);
}
/* HOT POTATO! PASS IT ON! */
Utils->DoOneToAllButSender(source,"FMODE",params,sourceserv);
{
if (params.size() < 1)
return true;
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
u->ChangeName(params[0].c_str());
if (params.size() != 4)
return true;
time_t ts = atoi(params[1].c_str());
- Channel* c = this->Instance->FindChan(params[0]);
+ Channel* c = this->ServerInstance->FindChan(params[0]);
if (c)
{
if ((ts >= c->topicset) || (c->topic.empty()))
{
if (c->topic != params[3])
{
- User* user = this->Instance->FindNick(source);
+ User* user = this->ServerInstance->FindNick(source);
// Update topic only when it differs from current topic
- c->topic.assign(params[3], 0, Instance->Config->Limits.MaxTopic);
+ c->topic.assign(params[3], 0, ServerInstance->Config->Limits.MaxTopic);
if (!user)
{
- c->WriteChannelWithServ(Instance->Config->ServerName, "TOPIC %s :%s", c->name.c_str(), c->topic.c_str());
+ c->WriteChannelWithServ(ServerInstance->Config->ServerName, "TOPIC %s :%s", c->name.c_str(), c->topic.c_str());
}
else
{
* Note: If m_sha256.so is not loaded, we MUST fall back to plaintext with no
* HMAC challenge/response.
*/
- Module* sha256 = Instance->Modules->Find("m_sha256.so");
+ Module* sha256 = ServerInstance->Modules->Find("m_sha256.so");
if (Utils->ChallengeResponse && sha256 && !challenge.empty())
{
/* XXX: This is how HMAC is supposed to be done:
return "HMAC-SHA256:"+ hmac;
}
else if (!challenge.empty() && !sha256)
- Instance->Logs->Log("m_spanningtree",DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!");
+ ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"Not authenticating to server using SHA256/HMAC because we don't have m_sha256 loaded!");
return password;
}
{
#ifndef WINDOWS
if (read(f, randombuf, ilength) < 1)
- Instance->Logs->Log("m_spanningtree", DEFAULT, "There are crack smoking monkeys in your kernel (in other words, nonblocking /dev/urandom blocked.)");
+ ServerInstance->Logs->Log("m_spanningtree", DEFAULT, "There are crack smoking monkeys in your kernel (in other words, nonblocking /dev/urandom blocked.)");
close(f);
#endif
}
/* One or both of us specified hmac sha256, but we don't have sha256 module loaded!
* We can't allow this password as valid.
*/
- if (!Instance->Modules->Find("m_sha256.so") || !Utils->ChallengeResponse)
+ if (!ServerInstance->Modules->Find("m_sha256.so") || !Utils->ChallengeResponse)
return false;
else
/* Straight string compare of hashes */
if (params.size() != 2)
return true;
- User* who = this->Instance->FindNick(params[0]);
+ User* who = this->ServerInstance->FindNick(params[0]);
if (who)
{
// NOTE: This is safe with kill hiding on, as RemoteKill is only reached if we have a server prefix.
// in short this is not executed for USERS.
who->Write(":%s KILL %s :%s (%s)", prefix.c_str(), who->nick.c_str(), prefix.c_str(), reason.c_str());
- this->Instance->Users->QuitUser(who, reason);
+ this->ServerInstance->Users->QuitUser(who, reason);
}
return true;
}
{
if (params[0] == "*")
{
- FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2]));
+ FOREACH_MOD_I(this->ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_OTHER,NULL,params[1],params[2]));
}
else if (*(params[0].c_str()) == '#')
{
- Channel* c = this->Instance->FindChan(params[0]);
+ Channel* c = this->ServerInstance->FindChan(params[0]);
if (c)
{
- FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]));
+ FOREACH_MOD_I(this->ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_CHANNEL,c,params[1],params[2]));
}
}
else if (*(params[0].c_str()) != '#')
{
- User* u = this->Instance->FindNick(params[0]);
+ User* u = this->ServerInstance->FindNick(params[0]);
if (u)
{
- FOREACH_MOD_I(this->Instance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2]));
+ FOREACH_MOD_I(this->ServerInstance,I_OnDecodeMetaData,OnDecodeMetaData(TYPE_USER,u,params[1],params[2]));
}
}
}
if (params.empty())
return true;
- if (!InspIRCd::Match(this->Instance->Config->ServerName, params[0]))
+ if (!InspIRCd::Match(this->ServerInstance->Config->ServerName, params[0]))
{
/* Pass it on, not for us */
Utils->DoOneToOne(prefix, "MODULES", params, params[0]);
par.push_back(prefix);
par.push_back("");
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (!source)
return true;
- std::vector<std::string> module_names = Instance->Modules->GetAllModuleNames(0);
+ std::vector<std::string> module_names = ServerInstance->Modules->GetAllModuleNames(0);
for (unsigned int i = 0; i < module_names.size(); i++)
{
- Module* m = Instance->Modules->Find(module_names[i]);
+ Module* m = ServerInstance->Modules->Find(module_names[i]);
Version V = m->GetVersion();
if (IS_OPER(source))
if (!(V.Flags & mult))
flags[pos] = '-';
- snprintf(strbuf, MAXBUF, "::%s 702 %s :0x%08lx %s %s :%s", Instance->Config->ServerName, source->nick.c_str(),(unsigned long)m, module_names[i].c_str(), flags.c_str(), V.version.c_str());
+ snprintf(strbuf, MAXBUF, "::%s 702 %s :0x%08lx %s %s :%s", ServerInstance->Config->ServerName, source->nick.c_str(),(unsigned long)m, module_names[i].c_str(), flags.c_str(), V.version.c_str());
}
else
{
- snprintf(strbuf, MAXBUF, "::%s 702 %s :%s", Instance->Config->ServerName, source->nick.c_str(), module_names[i].c_str());
+ snprintf(strbuf, MAXBUF, "::%s 702 %s :%s", ServerInstance->Config->ServerName, source->nick.c_str(), module_names[i].c_str());
}
par[1] = strbuf;
- Utils->DoOneToOne(Instance->Config->GetSID(), "PUSH", par, source->server);
+ Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", par, source->server);
}
- snprintf(strbuf, MAXBUF, "::%s 703 %s :End of MODULES list", Instance->Config->ServerName, source->nick.c_str());
+ snprintf(strbuf, MAXBUF, "::%s 703 %s :End of MODULES list", ServerInstance->Config->ServerName, source->nick.c_str());
par[1] = strbuf;
- Utils->DoOneToOne(Instance->Config->GetSID(), "PUSH", par, source->server);
+ Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", par, source->server);
return true;
}
{
if (params.size() > 0)
{
- if (InspIRCd::Match(this->Instance->Config->ServerName, params[0]))
+ if (InspIRCd::Match(this->ServerInstance->Config->ServerName, params[0]))
{
/* It's for our server */
string_list results;
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
{
par.push_back(prefix);
par.push_back("");
- if (!Instance->Config->MOTD.size())
+ if (!ServerInstance->Config->MOTD.size())
{
- par[1] = std::string("::")+Instance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing.";
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 422 "+source->nick+" :Message of the day file is missing.";
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
return true;
}
- par[1] = std::string("::")+Instance->Config->ServerName+" 375 "+source->nick+" :"+Instance->Config->ServerName+" message of the day";
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 375 "+source->nick+" :"+ServerInstance->Config->ServerName+" message of the day";
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
- for (unsigned int i = 0; i < Instance->Config->MOTD.size(); i++)
+ for (unsigned int i = 0; i < ServerInstance->Config->MOTD.size(); i++)
{
- par[1] = std::string("::")+Instance->Config->ServerName+" 372 "+source->nick+" :- "+Instance->Config->MOTD[i];
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 372 "+source->nick+" :- "+ServerInstance->Config->MOTD[i];
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
}
- par[1] = std::string("::")+Instance->Config->ServerName+" 376 "+source->nick+" :End of message of the day.";
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ par[1] = std::string("::")+ServerInstance->Config->ServerName+" 376 "+source->nick+" :End of message of the day.";
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
}
}
else
{
/* Pass it on */
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
Utils->DoOneToOne(prefix, "MOTD", params, params[0]);
}
void TreeSocket::DoBurst(TreeServer* s)
{
std::string name = s->GetName();
- std::string burst = ":" + this->Instance->Config->GetSID() + " BURST " +ConvToStr(Instance->Time());
- std::string endburst = ":" + this->Instance->Config->GetSID() + " ENDBURST";
- this->Instance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response");
+ std::string burst = ":" + this->ServerInstance->Config->GetSID() + " BURST " +ConvToStr(ServerInstance->Time());
+ std::string endburst = ":" + this->ServerInstance->Config->GetSID() + " ENDBURST";
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Bursting to \2%s\2 (Authentication: %s).", name.c_str(), this->GetTheirChallenge().empty() ? "plaintext password" : "SHA256-HMAC challenge-response");
this->WriteLine(burst);
/* send our version string */
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" VERSION :"+this->Instance->GetVersionString());
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" VERSION :"+this->ServerInstance->GetVersionString());
/* Send server tree */
this->SendServers(Utils->TreeRoot,s,1);
/* Send users and their oper status */
/* Send everything else (channel modes, xlines etc) */
this->SendChannelModes(s);
this->SendXLines(s);
- FOREACH_MOD_I(this->Instance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this));
+ FOREACH_MOD_I(this->ServerInstance,I_OnSyncOtherMetaData,OnSyncOtherMetaData((Module*)Utils->Creator,(void*)this));
this->WriteLine(endburst);
- this->Instance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2.");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Finished bursting to \2"+name+"\2.");
}
/** Recursively send the server tree with distances as hops.
char list[MAXBUF];
size_t dlen, curlen;
- dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu +%s", this->Instance->Config->GetSID().c_str(), c->name.c_str(),(unsigned long)c->age, c->ChanModes(true));
+ dlen = curlen = snprintf(list,MAXBUF,":%s FJOIN %s %lu +%s", this->ServerInstance->Config->GetSID().c_str(), c->name.c_str(),(unsigned long)c->age, c->ChanModes(true));
int numusers = 0;
char* ptr = list + dlen;
bool looped_once = false;
for (CUList::iterator i = ulist->begin(); i != ulist->end(); i++)
{
size_t ptrlen = 0;
- std::string modestr = this->Instance->Modes->ModeString(i->first, c, false);
+ std::string modestr = this->ServerInstance->Modes->ModeString(i->first, c, false);
if ((curlen + modestr.length() + i->first->uuid.length() + 4) > 480)
{
buffer.append(list).append("\r\n");
- dlen = curlen = snprintf(list, MAXBUF, ":%s FJOIN %s %lu +%s", this->Instance->Config->GetSID().c_str(), c->name.c_str(), (unsigned long)c->age, c->ChanModes(true));
+ dlen = curlen = snprintf(list, MAXBUF, ":%s FJOIN %s %lu +%s", this->ServerInstance->Config->GetSID().c_str(), c->name.c_str(), (unsigned long)c->age, c->ChanModes(true));
ptr = list + dlen;
numusers = 0;
}
params.append(" ").append(b->data);
linesize += size;
}
- if ((params.length() >= Instance->Config->Limits.MaxModes) || (currsize > 350))
+ if ((params.length() >= ServerInstance->Config->Limits.MaxModes) || (currsize > 350))
{
/* Wrap at MAXMODES */
- buffer.append(":").append(this->Instance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n");
+ buffer.append(":").append(this->ServerInstance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params).append("\r\n");
modes.clear();
params.clear();
linesize = 1;
/* Only send these if there are any */
if (!modes.empty())
- buffer.append(":").append(this->Instance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params);
+ buffer.append(":").append(this->ServerInstance->Config->GetSID()).append(" FMODE ").append(c->name).append(" ").append(ConvToStr(c->age)).append(" +").append(modes).append(params);
this->WriteLine(buffer);
}
void TreeSocket::SendXLines(TreeServer* Current)
{
char data[MAXBUF];
- std::string n = this->Instance->Config->GetSID();
+ std::string n = this->ServerInstance->Config->GetSID();
const char* sn = n.c_str();
- std::vector<std::string> types = Instance->XLines->GetAllTypes();
+ std::vector<std::string> types = ServerInstance->XLines->GetAllTypes();
for (std::vector<std::string>::iterator it = types.begin(); it != types.end(); ++it)
{
- XLineLookup* lookup = Instance->XLines->GetAll(*it);
+ XLineLookup* lookup = ServerInstance->XLines->GetAll(*it);
if (lookup)
{
{
char data[MAXBUF];
std::deque<std::string> list;
- std::string n = this->Instance->Config->GetSID();
+ std::string n = this->ServerInstance->Config->GetSID();
const char* sn = n.c_str();
- for (chan_hash::iterator c = this->Instance->chanlist->begin(); c != this->Instance->chanlist->end(); c++)
+ for (chan_hash::iterator c = this->ServerInstance->chanlist->begin(); c != this->ServerInstance->chanlist->end(); c++)
{
SendFJoins(Current, c->second);
if (!c->second->topic.empty())
snprintf(data,MAXBUF,":%s FTOPIC %s %lu %s :%s", sn, c->second->name.c_str(), (unsigned long)c->second->topicset, c->second->setby.c_str(), c->second->topic.c_str());
this->WriteLine(data);
}
- FOREACH_MOD_I(this->Instance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)Utils->Creator,(void*)this));
+ FOREACH_MOD_I(this->ServerInstance,I_OnSyncChannel,OnSyncChannel(c->second,(Module*)Utils->Creator,(void*)this));
list.clear();
c->second->GetExtList(list);
for (unsigned int j = 0; j < list.size(); j++)
{
- FOREACH_MOD_I(this->Instance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)Utils->Creator,(void*)this,list[j]));
+ FOREACH_MOD_I(this->ServerInstance,I_OnSyncChannelMetaData,OnSyncChannelMetaData(c->second,(Module*)Utils->Creator,(void*)this,list[j]));
}
}
}
char data[MAXBUF];
std::deque<std::string> list;
std::string dataline;
- for (user_hash::iterator u = this->Instance->Users->clientlist->begin(); u != this->Instance->Users->clientlist->end(); u++)
+ for (user_hash::iterator u = this->ServerInstance->Users->clientlist->begin(); u != this->ServerInstance->Users->clientlist->end(); u++)
{
if (u->second->registered == REG_ALL)
{
}
}
- FOREACH_MOD_I(this->Instance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this));
+ FOREACH_MOD_I(this->ServerInstance,I_OnSyncUser,OnSyncUser(u->second,(Module*)Utils->Creator,(void*)this));
list.clear();
u->second->GetExtList(list);
for (unsigned int j = 0; j < list.size(); j++)
{
- FOREACH_MOD_I(this->Instance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j]));
+ FOREACH_MOD_I(this->ServerInstance,I_OnSyncUserMetaData,OnSyncUserMetaData(u->second,(Module*)Utils->Creator,(void*)this,list[j]));
}
}
}
* have 928AAAB's nick set to that.
* -- w00t
*/
- User *remote = this->Instance->FindUUID(remoteuid);
+ User *remote = this->ServerInstance->FindUUID(remoteuid);
if (remote)
{
else
{
/* user has not been introduced yet, just inform their server */
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" SVSNICK "+remoteuid+" " + remoteuid + " " + ConvToStr(remotets));
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" SVSNICK "+remoteuid+" " + remoteuid + " " + ConvToStr(remotets));
}
if (!bChangeLocal)
if (params.size() < 1)
return true;
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
if (params.size() != 1)
return true;
std::string opertype = params[0];
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
if (!u->IsModeSet('o'))
- this->Instance->Users->all_opers.push_back(u);
+ this->ServerInstance->Users->all_opers.push_back(u);
u->modes[UM_OPERATOR] = 1;
u->oper.assign(opertype, 0, 512);
Utils->DoOneToAllButSender(u->uuid, "OPERTYPE", params, u->server);
*/
if (
remoteserver->bursting ||
- this->Instance->SilentULine(this->Instance->FindServerNamePtr(u->server))
+ this->ServerInstance->SilentULine(this->ServerInstance->FindServerNamePtr(u->server))
)
{
dosend = false;
}
if (dosend)
- this->Instance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick.c_str(),u->ident.c_str(), u->host.c_str(), irc::Spacify(opertype.c_str()));
+ this->ServerInstance->SNO->WriteToSnoMask('o',"From %s: User %s (%s@%s) is now an IRC operator of type %s",u->server, u->nick.c_str(),u->ident.c_str(), u->host.c_str(), irc::Spacify(opertype.c_str()));
}
return true;
}
if (params.size() == 1)
{
std::string stufftobounce = params[0];
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" PONG "+stufftobounce);
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" PONG "+stufftobounce);
return true;
}
else
{
std::string forwardto = params[1];
- if (forwardto == this->Instance->Config->ServerName || forwardto == this->Instance->Config->GetSID())
+ if (forwardto == this->ServerInstance->Config->ServerName || forwardto == this->ServerInstance->Config->GetSID())
{
// this is a ping for us, send back PONG to the requesting server
params[1] = params[0];
else
{
std::string forwardto = params[1];
- if (forwardto == Instance->Config->GetSID() || forwardto == Instance->Config->ServerName)
+ if (forwardto == ServerInstance->Config->GetSID() || forwardto == ServerInstance->Config->ServerName)
{
/*
* this is a PONG for us
* dump the PONG reply back to their fd. If its a server, do nowt.
* Services might want to send these s->s, but we dont need to yet.
*/
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
u->WriteServ("PONG %s %s",params[0].c_str(),params[1].c_str());
const char* target = params[0].c_str();
std::string text = params[1].c_str();
- if (Instance->Modes->FindPrefix(*target))
+ if (ServerInstance->Modes->FindPrefix(*target))
{
status = *target;
target++;
}
- Channel* channel = Instance->FindChan(target);
+ Channel* channel = ServerInstance->FindChan(target);
if (channel)
{
if (messagetype == "PRIVMSG")
{
- FOREACH_MOD_I(Instance, I_OnUserMessage, OnUserMessage(NULL, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnUserMessage, OnUserMessage(NULL, channel, TYPE_CHANNEL, text, status, except_list));
}
else
{
- FOREACH_MOD_I(Instance, I_OnUserNotice, OnUserNotice(NULL, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnUserNotice, OnUserNotice(NULL, channel, TYPE_CHANNEL, text, status, except_list));
}
TreeServer* s = Utils->FindServer(prefix);
if (s)
{
- FOREACH_MOD_I(Instance, I_OnText, OnText(NULL, channel, TYPE_CHANNEL, text, status, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnText, OnText(NULL, channel, TYPE_CHANNEL, text, status, except_list));
channel->WriteChannelWithServ(s->GetName().c_str(), "%s %s :%s", messagetype.c_str(), channel->name.c_str(), text.c_str());
}
}
else
{
- User* user = Instance->FindNick(target);
+ User* user = ServerInstance->FindNick(target);
if (user)
{
if (messagetype == "PRIVMSG")
{
- FOREACH_MOD_I(Instance, I_OnUserMessage, OnUserMessage(NULL, user, TYPE_USER, text, 0, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnUserMessage, OnUserMessage(NULL, user, TYPE_USER, text, 0, except_list));
}
else
{
- FOREACH_MOD_I(Instance, I_OnUserNotice, OnUserNotice(NULL, user, TYPE_USER, text, 0, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnUserNotice, OnUserNotice(NULL, user, TYPE_USER, text, 0, except_list));
}
TreeServer* s = Utils->FindServer(prefix);
if (s)
{
- FOREACH_MOD_I(Instance, I_OnText, OnText(NULL, user, TYPE_USER, text, status, except_list));
+ FOREACH_MOD_I(ServerInstance, I_OnText, OnText(NULL, user, TYPE_USER, text, status, except_list));
user->Write(":%s %s %s :%s", s->GetName().c_str(), messagetype.c_str(), user->nick.c_str(), text.c_str());
}
{
if (params.size() < 2)
return true;
- User* u = this->Instance->FindNick(params[0]);
+ User* u = this->ServerInstance->FindNick(params[0]);
if (!u)
return true;
if (IS_LOCAL(u))
this->SendError("Protocol error - Introduced remote server from unknown server "+ParentOfThis->GetName());
return false;
}
- if (!this->Instance->IsSID(sid))
+ if (!this->ServerInstance->IsSID(sid))
{
this->SendError("Invalid format server ID: "+sid+"!");
return false;
if (CheckDupe)
{
this->SendError("Server "+CheckDupe->GetName()+" already exists!");
- this->Instance->SNO->WriteToSnoMask('l',"Server \2"+CheckDupe->GetName()+"\2 being introduced from \2" + ParentOfThis->GetName() + "\2 denied, already exists. Closing link with " + ParentOfThis->GetName());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \2"+CheckDupe->GetName()+"\2 being introduced from \2" + ParentOfThis->GetName() + "\2 denied, already exists. Closing link with " + ParentOfThis->GetName());
return false;
}
Link* lnk = Utils->FindLink(servername);
- TreeServer *Node = new TreeServer(this->Utils, this->Instance, servername, description, sid, ParentOfThis,NULL, lnk ? lnk->Hidden : false);
+ TreeServer *Node = new TreeServer(this->Utils, this->ServerInstance, servername, description, sid, ParentOfThis,NULL, lnk ? lnk->Hidden : false);
if (Node->DuplicateID())
{
this->SendError("Server ID "+servername+" already exists on the network!");
- this->Instance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + ParentOfThis->GetName() + "\2 denied, server ID already exists on the network. Closing link with " + ParentOfThis->GetName());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \2"+servername+"\2 being introduced from \2" + ParentOfThis->GetName() + "\2 denied, server ID already exists on the network. Closing link with " + ParentOfThis->GetName());
return false;
}
ParentOfThis->AddChild(Node);
params[4] = ":" + params[4];
Utils->DoOneToAllButSender(prefix,"SERVER",params,prefix);
- this->Instance->SNO->WriteToSnoMask('l',"Server \002"+ParentOfThis->GetName()+"\002 introduced server \002"+servername+"\002 ("+description+")");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \002"+ParentOfThis->GetName()+"\002 introduced server \002"+servername+"\002 ("+description+")");
return true;
}
if (hops)
{
this->SendError("Server too far away for authentication");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
- if (!this->Instance->IsSID(sid))
+ if (!this->ServerInstance->IsSID(sid))
{
this->SendError("Invalid format server ID: "+sid+"!");
return false;
if (!ComparePass(this->MakePass(x->RecvPass, this->GetOurChallenge()), password) &&
(x->RecvPass != password && this->GetTheirChallenge().empty()))
{
- this->Instance->SNO->WriteToSnoMask('l',"Invalid password on link: %s", x->Name.c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Invalid password on link: %s", x->Name.c_str());
continue;
}
if (CheckDupe)
{
this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
*/
this->LinkState = CONNECTED;
- TreeServer *Node = new TreeServer(this->Utils, this->Instance, sname, description, sid, Utils->TreeRoot, this, x->Hidden);
+ TreeServer *Node = new TreeServer(this->Utils, this->ServerInstance, sname, description, sid, Utils->TreeRoot, this, x->Hidden);
if (Node->DuplicateID())
{
this->SendError("Server ID "+sid+" already exists on the network!");
- this->Instance->SNO->WriteToSnoMask('l',"Server \2"+assign(servername)+"\2 being introduced denied, server ID already exists on the network. Closing link.");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \2"+assign(servername)+"\2 being introduced denied, server ID already exists on the network. Closing link.");
return false;
}
/* IMPORTANT: Take password/hmac hash OUT of here before we broadcast the introduction! */
params[1] = "*";
- Utils->DoOneToAllButSender(Instance->Config->GetSID(),"SERVER",params,sname);
+ Utils->DoOneToAllButSender(ServerInstance->Config->GetSID(),"SERVER",params,sname);
Node->bursting = true;
this->DoBurst(Node);
}
this->SendError("Invalid credentials (check the other server's linking snomask for more information)");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
if (hops)
{
this->SendError("Server too far away for authentication");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server is too far away for authentication");
return false;
}
- if (!this->Instance->IsSID(sid))
+ if (!this->ServerInstance->IsSID(sid))
{
this->SendError("Invalid format server ID: "+sid+"!");
return false;
if (!ComparePass(this->MakePass(x->RecvPass, this->GetOurChallenge()), password) &&
(x->RecvPass != password && this->GetTheirChallenge().empty()))
{
- this->Instance->SNO->WriteToSnoMask('l',"Invalid password on link: %s", x->Name.c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Invalid password on link: %s", x->Name.c_str());
continue;
}
/* Check for fully initialized instances of the server by id */
- Instance->Logs->Log("m_spanningtree",DEBUG,"Looking for dupe SID %s", sid.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG,"Looking for dupe SID %s", sid.c_str());
TreeServer* CheckDupeSID = Utils->FindServerID(sid);
if (CheckDupeSID)
{
this->SendError("Server ID "+CheckDupeSID->GetID()+" already exists on server "+CheckDupeSID->GetName()+"!");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server ID '"+CheckDupeSID->GetID()+
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, server ID '"+CheckDupeSID->GetID()+
"' already exists on server "+CheckDupeSID->GetName());
return false;
}
- /* Now check for fully initialized instances of the server by name */
+ /* Now check for fully initialized ServerInstances of the server by name */
TreeServer* CheckDupe = Utils->FindServer(sname);
if (CheckDupe)
{
this->SendError("Server "+sname+" already exists on server "+CheckDupe->GetParent()->GetName()+"!");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, already exists on server "+CheckDupe->GetParent()->GetName());
return false;
}
- this->Instance->SNO->WriteToSnoMask('l',"Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Verified incoming server connection from \002"+sname+"\002["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] ("+description+")");
if (this->Hook)
{
std::string name = BufferedSocketNameRequest((Module*)Utils->Creator, this->Hook).Send();
- this->Instance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] using transport \2"+name+"\2");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Connection from \2"+sname+"\2["+(x->HiddenFromStats ? "<hidden>" : this->GetIP())+"] using transport \2"+name+"\2");
}
// this is good. Send our details: Our server name and description and hopcount of 0,
// along with the sendpass from this block.
this->SendCapabilities();
- this->WriteLine(std::string("SERVER ")+this->Instance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 "+Instance->Config->GetSID()+" :"+this->Instance->Config->ServerDesc);
+ this->WriteLine(std::string("SERVER ")+this->ServerInstance->Config->ServerName+" "+this->MakePass(x->SendPass, this->GetTheirChallenge())+" 0 "+ServerInstance->Config->GetSID()+" :"+this->ServerInstance->Config->ServerDesc);
// move to the next state, we are now waiting for THEM.
this->LinkState = WAIT_AUTH_2;
return true;
}
this->SendError("Invalid credentials");
- this->Instance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server connection from \2"+sname+"\2 denied, invalid link credentials");
return false;
}
*/
if (params.size() > 1)
{
- if (InspIRCd::Match(this->Instance->Config->ServerName, params[1]))
+ if (InspIRCd::Match(this->ServerInstance->Config->ServerName, params[1]))
{
/* It's for our server */
string_list results;
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
{
std::deque<std::string> par;
par.push_back(prefix);
par.push_back("");
- DoStats(this->Instance, *(params[0].c_str()), source, results);
+ DoStats(this->ServerInstance, *(params[0].c_str()), source, results);
for (size_t i = 0; i < results.size(); i++)
{
par[1] = "::" + results[i];
- Utils->DoOneToOne(this->Instance->Config->GetSID(), "PUSH",par, source->server);
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(), "PUSH",par, source->server);
}
}
}
else
{
/* Pass it on */
- User* source = this->Instance->FindNick(prefix);
+ User* source = this->ServerInstance->FindNick(prefix);
if (source)
Utils->DoOneToOne(source->uuid, "STATS", params, params[1]);
}
if (params.size() < 2)
return true;
- User* u = this->Instance->FindNick(params[0]);
+ User* u = this->ServerInstance->FindNick(params[0]);
if (u)
{
/* only join if it's local, otherwise just pass it on! */
if (IS_LOCAL(u))
- Channel::JoinUser(this->Instance, u, params[1].c_str(), false, "", false, Instance->Time());
+ Channel::JoinUser(this->ServerInstance, u, params[1].c_str(), false, "", false, ServerInstance->Time());
Utils->DoOneToAllButSender(prefix,"SVSJOIN",params,prefix);
}
return true;
if (params.size() < 3)
return true;
- User* u = this->Instance->FindNick(params[0]);
+ User* u = this->ServerInstance->FindNick(params[0]);
if (u)
{
/* buh. UID them */
if (!u->ForceNickChange(u->uuid.c_str()))
{
- this->Instance->Users->QuitUser(u, "Nickname collision");
+ this->ServerInstance->Users->QuitUser(u, "Nickname collision");
return true;
}
}
if (params.size() == 3)
reason = params[2];
- User* u = this->Instance->FindNick(params[0]);
- Channel* c = this->Instance->FindChan(params[1]);
+ User* u = this->ServerInstance->FindNick(params[0]);
+ Channel* c = this->ServerInstance->FindChan(params[1]);
if (u)
{
if (params.size() == 2)
{
// someone querying our time?
- if (this->Instance->Config->ServerName == params[0] || this->Instance->Config->GetSID() == params[0])
+ if (this->ServerInstance->Config->ServerName == params[0] || this->ServerInstance->Config->GetSID() == params[0])
{
- User* u = this->Instance->FindNick(params[1]);
+ User* u = this->ServerInstance->FindNick(params[1]);
if (u)
{
- params.push_back(ConvToStr(Instance->Time()));
+ params.push_back(ConvToStr(ServerInstance->Time()));
params[0] = prefix;
- Utils->DoOneToOne(this->Instance->Config->GetSID(),"TIME",params,params[0]);
+ Utils->DoOneToOne(this->ServerInstance->Config->GetSID(),"TIME",params,params[0]);
}
}
else
{
// not us, pass it on
- User* u = this->Instance->FindNick(params[1]);
+ User* u = this->ServerInstance->FindNick(params[1]);
if (u)
Utils->DoOneToOne(prefix,"TIME",params,params[0]);
}
else if (params.size() == 3)
{
// a response to a previous TIME
- User* u = this->Instance->FindNick(params[1]);
+ User* u = this->ServerInstance->FindNick(params[1]);
if ((u) && (IS_LOCAL(u)))
{
time_t rawtime = atol(params[2].c_str());
if (Hook)
BufferedSocketHookRequest(this, (Module*)Utils->Creator, Hook).Send();
- Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(Utils->LinkBlocks[0]), this->Utils, 1));
+ ServerInstance->Timers->AddTimer(new HandshakeTimer(ServerInstance, this, &(Utils->LinkBlocks[0]), this->Utils, 1));
/* Fix by Brain - inbound sockets need a timeout, too. 30 secs should be pleanty */
Utils->timeoutlist[this] = std::pair<std::string, int>("<unknown>", 30);
/* found who we're supposed to be connecting to, send the neccessary gubbins. */
if (this->GetHook())
- Instance->Timers->AddTimer(new HandshakeTimer(Instance, this, &(*x), this->Utils, 1));
+ ServerInstance->Timers->AddTimer(new HandshakeTimer(ServerInstance, this, &(*x), this->Utils, 1));
else
this->SendCapabilities();
if ((Current) && (Current != Utils->TreeRoot))
{
Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server");
- rmode.Send(Instance);
+ rmode.Send(ServerInstance);
std::deque<std::string> params;
params.push_back(Current->GetName());
Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
if (Current->GetParent() == Utils->TreeRoot)
{
- this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason);
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split: "+reason);
}
else
{
- this->Instance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \002"+Current->GetName()+"\002 split from server \002"+Current->GetParent()->GetName()+"\002 with reason: "+reason);
}
num_lost_servers = 0;
num_lost_users = 0;
Current->Tidy();
Current->GetParent()->DelChild(Current);
delete Current;
- this->Instance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Netsplit complete, lost \002%d\002 users on \002%d\002 servers.", num_lost_users, num_lost_servers);
}
else
- Instance->Logs->Log("m_spanningtree",DEFAULT,"Squit from unknown server");
+ ServerInstance->Logs->Log("m_spanningtree",DEFAULT,"Squit from unknown server");
}
/** This function is called when we receive data from a remote
void TreeSocket::WriteLine(std::string line)
{
- Instance->Logs->Log("m_spanningtree",DEBUG, "S[%d] O %s", this->GetFd(), line.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG, "S[%d] O %s", this->GetFd(), line.c_str());
line.append("\r\n");
this->Write(line);
}
{
if (params.size() < 1)
return false;
- this->Instance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('l',"ERROR from %s: %s",(!InboundServerName.empty() ? InboundServerName.c_str() : myhost.c_str()),params[0].c_str());
/* we will return false to cause the socket to close. */
return false;
}
if (line.empty())
return true;
- Instance->Logs->Log("m_spanningtree",DEBUG, "S[%d] I %s", this->GetFd(), line.c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG, "S[%d] I %s", this->GetFd(), line.c_str());
this->Split(line.c_str(),params);
if (params.size())
{
time_t them = atoi(params[0].c_str());
- time_t delta = them - Instance->Time();
+ time_t delta = them - ServerInstance->Time();
if ((delta < -600) || (delta > 600))
{
- Instance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs((long)delta));
+ ServerInstance->SNO->WriteToSnoMask('l',"\2ERROR\2: Your clocks are out by %d seconds (this is more than five minutes). Link aborted, \2PLEASE SYNC YOUR CLOCKS!\2",abs((long)delta));
SendError("Your clocks are out by "+ConvToStr(abs((long)delta))+" seconds (this is more than five minutes). Link aborted, PLEASE SYNC YOUR CLOCKS!");
return false;
}
else if ((delta < -30) || (delta > 30))
{
- Instance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs((long)delta));
+ ServerInstance->SNO->WriteToSnoMask('l',"\2WARNING\2: Your clocks are out by %d seconds. Please consider synching your clocks.", abs((long)delta));
}
}
this->LinkState = CONNECTED;
Utils->timeoutlist.erase(this);
- Node = new TreeServer(this->Utils, this->Instance, InboundServerName, InboundDescription, InboundSID, Utils->TreeRoot, this, lnk ? lnk->Hidden : false);
+ Node = new TreeServer(this->Utils, this->ServerInstance, InboundServerName, InboundDescription, InboundSID, Utils->TreeRoot, this, lnk ? lnk->Hidden : false);
if (Node->DuplicateID())
{
this->SendError("Server ID "+InboundSID+" already exists on the network!");
- this->Instance->SNO->WriteToSnoMask('l',"Server \2"+InboundServerName+"\2 being introduced from \2" + prefix + "\2 denied, server ID already exists on the network. Closing link.");
+ this->ServerInstance->SNO->WriteToSnoMask('l',"Server \2"+InboundServerName+"\2 being introduced from \2" + prefix + "\2 denied, server ID already exists on the network. Closing link.");
return false;
}
params.push_back("1");
params.push_back(InboundSID);
params.push_back(":"+InboundDescription);
- Utils->DoOneToAllButSender(Instance->Config->GetSID(),"SERVER",params,InboundServerName);
+ Utils->DoOneToAllButSender(ServerInstance->Config->GetSID(),"SERVER",params,InboundServerName);
Node->bursting = true;
this->DoBurst(Node);
}
*/
std::string direction = prefix;
- User *t = this->Instance->FindUUID(prefix);
+ User *t = this->ServerInstance->FindUUID(prefix);
if (t)
{
direction = t->server;
if ((!route_back_again) || (route_back_again->GetSocket() != this))
{
if (route_back_again)
- Instance->Logs->Log("m_spanningtree",DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG,"Protocol violation: Fake direction in command '%s' from connection '%s'",line.c_str(),this->GetName().c_str());
return true;
}
/* Fix by brain:
* When there is activity on the socket, reset the ping counter so
* that we're not wasting bandwidth pinging an active server.
*/
- route_back_again->SetNextPingTime(Instance->Time() + Utils->PingFreq);
+ route_back_again->SetNextPingTime(ServerInstance->Time() + Utils->PingFreq);
route_back_again->SetPingFlag();
}
else
}
else if (command == "MAP")
{
- User* user = Instance->FindNick(prefix);
+ User* user = ServerInstance->FindNick(prefix);
if (user)
{
std::vector<std::string> p(params.begin(), params.end());
TreeServer *s = Utils->FindServer(prefix);
if (s && s->bursting)
{
- Instance->SNO->WriteToSnoMask('l',"Server \002%s\002 has not finished burst, forcing end of burst (send ENDBURST!)", prefix.c_str());
+ ServerInstance->SNO->WriteToSnoMask('l',"Server \002%s\002 has not finished burst, forcing end of burst (send ENDBURST!)", prefix.c_str());
s->FinishBurst();
}
return this->LocalPong(prefix,params);
if (params.size() == 3)
{
TreeServer* pf = Utils->FindServer(prefix);
- User* user = this->Instance->FindNick(params[1]);
- Channel* chan = this->Instance->FindChan(params[0]);
+ User* user = this->ServerInstance->FindNick(params[1]);
+ Channel* chan = this->ServerInstance->FindChan(params[0]);
if (pf && user && chan)
{
if (!chan->ServerKickUser(user, params[2].c_str(), false, pf->GetName().c_str()))
if (params.size() >= 2)
{
if (ServerSource)
- Instance->Users->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()), params[1].c_str());
+ ServerInstance->Users->WriteMode(params[0].c_str(), WM_AND, "*** From %s: %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()), params[1].c_str());
}
return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params);
}
{
if (params.size() >= 2)
{
- Instance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + (ServerSource ? ServerSource->GetName().c_str() : prefix) + ": "+ params[1]);
+ ServerInstance->SNO->WriteToSnoMask(*(params[0].c_str()), "From " + (ServerSource ? ServerSource->GetName().c_str() : prefix) + ": "+ params[1]);
return Utils->DoOneToAllButSenderRaw(line, sourceserv, prefix, command, params);
}
// Set prefix server as bursting
if (!ServerSource)
{
- this->Instance->SNO->WriteToSnoMask('l', "WTF: Got BURST from a nonexistant server(?): %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()));
+ this->ServerInstance->SNO->WriteToSnoMask('l', "WTF: Got BURST from a nonexistant server(?): %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()));
return false;
}
{
if (!ServerSource)
{
- this->Instance->SNO->WriteToSnoMask('l', "WTF: Got ENDBURST from a nonexistant server(?): %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()));
+ this->ServerInstance->SNO->WriteToSnoMask('l', "WTF: Got ENDBURST from a nonexistant server(?): %s", (ServerSource ? ServerSource->GetName().c_str() : prefix.c_str()));
return false;
}
{
return this->Encap(prefix, params);
}
- else if (command == "MODE" && !this->Instance->FindUUID(prefix)) // XXX we should check for no such serv?
+ else if (command == "MODE" && !this->ServerInstance->FindUUID(prefix)) // XXX we should check for no such serv?
{
// Server-prefix MODE.
std::vector<std::string> modelist(params.begin(), params.end());
/* We don't support this for channel mode changes any more! */
if (params.size() >= 1)
{
- if (Instance->FindChan(params[0]))
+ if (ServerInstance->FindChan(params[0]))
{
this->SendError("Protocol violation by '"+(ServerSource ? ServerSource->GetName().c_str() : prefix)+"'! MODE for channel mode changes is not supported by the InspIRCd 1.2 protocol. You must use FMODE to preserve channel timestamps.");
return false;
}
// Insert into the parser
- this->Instance->SendMode(modelist, this->Instance->FakeClient);
+ this->ServerInstance->SendMode(modelist, this->ServerInstance->FakeClient);
// Pass out to the network
return Utils->DoOneToAllButSenderRaw(line,sourceserv,prefix,command,params);
* Not a special s2s command. Emulate the user doing it.
* This saves us having a huge ugly command parser again.
*/
- User *who = this->Instance->FindUUID(prefix);
+ User *who = this->ServerInstance->FindUUID(prefix);
if (!who)
{
* On nick messages, check that the nick doesnt already exist here.
* If it does, perform collision logic.
*/
- User* x = this->Instance->FindNickOnly(params[0]);
+ User* x = this->ServerInstance->FindNickOnly(params[0]);
if ((x) && (x != who))
{
int collideret = 0;
// its a user
std::vector<std::string> strparams(params.begin(), params.end());
- switch (this->Instance->CallCommandHandler(command.c_str(), strparams, who))
+ switch (this->ServerInstance->CallCommandHandler(command.c_str(), strparams, who))
{
case CMD_INVALID:
/*
if (!quitserver.empty())
{
Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' failed.",quitserver.c_str());
- time_t server_uptime = Instance->Time() - this->age;
+ time_t server_uptime = ServerInstance->Time() - this->age;
if (server_uptime)
Utils->Creator->RemoteMessage(NULL,"Connection to '\2%s\2' was established for %s", quitserver.c_str(), Utils->Creator->TimeToStr(server_uptime).c_str());
}
if (params.size() < 10)
{
if (!params.empty())
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction ("+params[0]+" with only "+
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction ("+params[0]+" with only "+
ConvToStr(params.size())+" of 10 or more parameters?)");
return true;
}
if (!remoteserver)
{
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Unknown server "+source+")");
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Unknown server "+source+")");
return true;
}
/* Check parameters for validity before introducing the client, discovered by dmb */
if (!age_t)
{
- this->WriteLine(std::string(":")+this->Instance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Invalid TS?)");
+ this->WriteLine(std::string(":")+this->ServerInstance->Config->GetSID()+" KILL "+params[0]+" :Invalid client introduction (Invalid TS?)");
return true;
}
/* check for collision */
- user_hash::iterator iter = this->Instance->Users->clientlist->find(params[2]);
+ user_hash::iterator iter = this->ServerInstance->Users->clientlist->find(params[2]);
- if (iter != this->Instance->Users->clientlist->end())
+ if (iter != this->ServerInstance->Users->clientlist->end())
{
/*
* Nick collision.
*/
- Instance->Logs->Log("m_spanningtree",DEBUG,"*** Collision on %s", params[2].c_str());
+ ServerInstance->Logs->Log("m_spanningtree",DEBUG,"*** Collision on %s", params[2].c_str());
int collide = this->DoCollision(iter->second, age_t, params[5], params[8], params[0]);
if (collide == 2)
User* _new = NULL;
try
{
- _new = new User(this->Instance, params[0]);
+ _new = new User(this->ServerInstance, params[0]);
}
catch (...)
{
SendError("Protocol violation - Duplicate UUID '" + params[0] + "' on introduction of new user");
return false;
}
- (*(this->Instance->Users->clientlist))[params[2]] = _new;
+ (*(this->ServerInstance->Users->clientlist))[params[2]] = _new;
_new->SetFd(FD_MAGIC_NUMBER);
_new->nick.assign(params[2], 0, MAXBUF);
_new->host.assign(params[3], 0, 64);
_new->dhost.assign(params[4], 0, 64);
- _new->server = this->Instance->FindServerNamePtr(remoteserver->GetName().c_str());
+ _new->server = this->ServerInstance->FindServerNamePtr(remoteserver->GetName().c_str());
_new->ident.assign(params[5], 0, MAXBUF);
_new->fullname.assign(params[params.size() - 1], 0, MAXBUF);
_new->registered = REG_ALL;
continue;
/* For each mode thats set, increase counter */
- ModeHandler* mh = Instance->Modes->FindMode(*v, MODETYPE_USER);
+ ModeHandler* mh = ServerInstance->Modes->FindMode(*v, MODETYPE_USER);
if (mh)
{
if (paramptr < params.size() - 1)
mh->OnModeChange(_new, _new, NULL, params[paramptr++], true);
else
- Instance->Logs->Log("m_spanningtree", DEBUG, "Warning: Broken UID command, expected a parameter for user mode '%c' but there aren't enough parameters in the command!", *v);
+ ServerInstance->Logs->Log("m_spanningtree", DEBUG, "Warning: Broken UID command, expected a parameter for user mode '%c' but there aren't enough parameters in the command!", *v);
}
else
mh->OnModeChange(_new, _new, NULL, empty, true);
mh->ChangeCount(1);
}
else
- Instance->Logs->Log("m_spanningtree", DEBUG, "Warning: Broken UID command, unknown user mode '%c' in the mode string!", *v);
+ ServerInstance->Logs->Log("m_spanningtree", DEBUG, "Warning: Broken UID command, unknown user mode '%c' in the mode string!", *v);
}
//_new->ProcessNoticeMasks(params[7].c_str());
#endif
_new->SetSockAddr(AF_INET, params[6].c_str(), 0);
- Instance->Users->AddGlobalClone(_new);
+ ServerInstance->Users->AddGlobalClone(_new);
bool dosend = true;
- if ((this->Utils->quiet_bursts && remoteserver->bursting) || this->Instance->SilentULine(_new->server))
+ if ((this->Utils->quiet_bursts && remoteserver->bursting) || this->ServerInstance->SilentULine(_new->server))
dosend = false;
if (dosend)
- this->Instance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]", _new->server, _new->nick.c_str(), _new->ident.c_str(), _new->host.c_str(), _new->GetIPString(), _new->fullname.c_str());
+ this->ServerInstance->SNO->WriteToSnoMask('C',"Client connecting at %s: %s!%s@%s [%s] [%s]", _new->server, _new->nick.c_str(), _new->ident.c_str(), _new->host.c_str(), _new->GetIPString(), _new->fullname.c_str());
params[params.size() - 1] = ":" + params[params.size() - 1];
Utils->DoOneToAllButSender(source, "UID", params, source);
- Instance->PI->Introduce(_new);
- FOREACH_MOD_I(Instance,I_OnPostConnect,OnPostConnect(_new));
+ ServerInstance->PI->Introduce(_new);
+ FOREACH_MOD_I(ServerInstance,I_OnPostConnect,OnPostConnect(_new));
return true;
}
{
if (params.size() < 1)
return true;
- User* u = this->Instance->FindNick(prefix);
+ User* u = this->ServerInstance->FindNick(prefix);
if (u)
{
// an incoming request
if (params.size() == 1)
{
- User* x = this->Instance->FindNick(params[0]);
+ User* x = this->ServerInstance->FindNick(params[0]);
if ((x) && (IS_LOCAL(x)))
{
char signon[MAXBUF];
char idle[MAXBUF];
snprintf(signon, MAXBUF, "%lu", (unsigned long)x->signon);
- snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((long)((x->idle_lastmsg) - Instance->Time())));
+ snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((long)((x->idle_lastmsg) - ServerInstance->Time())));
std::deque<std::string> par;
par.push_back(prefix);
par.push_back(signon);
else if (params.size() == 3)
{
std::string who_did_the_whois = params[0];
- User* who_to_send_to = this->Instance->FindNick(who_did_the_whois);
+ User* who_to_send_to = this->ServerInstance->FindNick(who_did_the_whois);
if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
{
// an incoming reply to a whois we sent out
unsigned long idle = atoi(params[2].c_str());
if ((who_to_send_to) && (IS_LOCAL(who_to_send_to)))
{
- do_whois(this->Instance, who_to_send_to, u, signon, idle, nick_whoised.c_str());
+ do_whois(this->ServerInstance, who_to_send_to, u, signon, idle, nick_whoised.c_str());
}
}
else
projects / user / henk / code / inspircd.git / commitdiff