*/
int TranslateUIDs(TranslateType to, const std::string &source, std::string &dest);
- int TranslateUIDs(const std::deque<TranslateType> to, const std::deque<std::string> &source, std::string &dest);
+ int TranslateUIDs(const std::vector<TranslateType> to, const std::vector<std::string> &source, std::string &dest);
};
/** Command handler class for the RELOAD command.
* characters. As specified below, this function
* should be called in a loop until it returns zero,
* indicating there are no more modes to return.
- * @param result The deque to populate. This will
+ * @param result The vector to populate. This will not
* be cleared before it is used.
* @param max_line_size The maximum size of the line
* to build, in characters, seperate to MAXMODES.
* returns 0, in case there are multiple lines of
* mode changes to be obtained.
*/
- int GetStackedLine(std::deque<std::string> &result, int max_line_size = 360);
+ int GetStackedLine(std::vector<std::string> &result, int max_line_size = 360);
+
+ /** deprecated compatability interface - TODO remove */
+ int GetStackedLine(std::deque<std::string> &result, int max_line_size = 360) {
+ std::vector<std::string> r;
+ int n = GetStackedLine(r, max_line_size);
+ result.clear();
+ result.insert(result.end(), r.begin(), r.end());
+ return n;
+ }
};
/** irc::tokenstream reads a string formatted as per RFC1459 and RFC2812.
* Use GetLastParse() to get this value, to be used for display purposes.
*/
std::string LastParse;
- std::deque<std::string> LastParseParams;
- std::deque<TranslateType> LastParseTranslate;
+ std::vector<std::string> LastParseParams;
+ std::vector<TranslateType> LastParseTranslate;
unsigned int sent[256];
* @return Last parsed string, as seen by users.
*/
const std::string& GetLastParse();
- const std::deque<std::string>& GetLastParseParams() { return LastParseParams; }
- const std::deque<TranslateType>& GetLastParseTranslate() { return LastParseTranslate; }
+ const std::vector<std::string>& GetLastParseParams() { return LastParseParams; }
+ const std::vector<TranslateType>& GetLastParseTranslate() { return LastParseTranslate; }
/** Add a mode to the mode parser.
* @return True if the mode was successfully added.
*/
* @param text The actual modes and their parameters if any
* @param translate The translation types of the mode parameters
*/
- virtual void OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate);
+ virtual void OnMode(User* user, void* dest, int target_type, const std::vector<std::string> &text, const std::vector<TranslateType> &translate);
/** Allows modules to alter or create server descriptions
* Whenever a module requires a server description, for example for display in
* @param modeline The modes and parameters to be sent
* @param translate The translation types of the mode parameters
*/
- virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate);
+ virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::vector<std::string> &modeline, const std::vector<TranslateType> &translate);
/** Implemented by modules which provide the ability to link servers.
* These modules will implement this method, which allows metadata (extra data added to
class InspIRCd;
class User;
-typedef std::deque<std::string> parameterlist;
+typedef std::vector<std::string> parameterlist;
class ProtoServer
{
* @param target The channel name or user to send mode changes for.
* @param The mode changes to send.
*/
- virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &translate) { }
+ virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::vector<TranslateType> &translate) { }
/** Convenience function, string wrapper around the above.
*/
{
irc::spacesepstream x(modeline);
parameterlist n;
- std::deque<TranslateType> types;
+ std::vector<TranslateType> types;
std::string v;
while (x.GetToken(v))
{
if (el)
{
irc::modestacker modestack(ServerInstance, false);
- std::deque<std::string> stackresult;
- std::vector<std::string> mode_junk;
- mode_junk.push_back(channel->name);
for (modelist::iterator it = el->begin(); it != el->end(); it++)
{
if (stack)
return;
+ std::vector<std::string> stackresult;
+ stackresult.push_back(channel->name);
while (modestack.GetStackedLine(stackresult))
{
- mode_junk.insert(mode_junk.end(), stackresult.begin(), stackresult.end());
- ServerInstance->SendMode(mode_junk, ServerInstance->FakeClient);
- mode_junk.erase(mode_junk.begin() + 1, mode_junk.end());
+ ServerInstance->SendMode(stackresult, ServerInstance->FakeClient);
+ stackresult.clear();
+ stackresult.push_back(channel->name);
}
}
}
modelist* mlist;
chan->GetExt(infokey, mlist);
irc::modestacker modestack(ServerInstance, true);
- std::deque<std::string> stackresult;
- std::deque<TranslateType> types;
+ std::vector<std::string> stackresult;
+ std::vector<TranslateType> types;
types.push_back(TR_TEXT);
if (mlist)
{
{
types.assign(stackresult.size(), this->GetTranslateType());
proto->ProtoSendMode(opaque, TYPE_CHANNEL, chan, stackresult, types);
+ stackresult.clear();
}
}
this->CreateCommand(new CommandReload(ServerInstance));
}
-int CommandParser::TranslateUIDs(const std::deque<TranslateType> to, const std::deque<std::string> &source, std::string &dest)
+int CommandParser::TranslateUIDs(const std::vector<TranslateType> to, const std::vector<std::string> &source, std::string &dest)
{
- std::deque<std::string>::const_iterator items = source.begin();
- std::deque<TranslateType>::const_iterator types = to.begin();
+ std::vector<std::string>::const_iterator items = source.begin();
+ std::vector<TranslateType>::const_iterator types = to.begin();
User* user = NULL;
int translations = 0;
dest.clear();
this->Push('-',"");
}
-int irc::modestacker::GetStackedLine(std::deque<std::string> &result, int max_line_size)
+int irc::modestacker::GetStackedLine(std::vector<std::string> &result, int max_line_size)
{
if (sequence.empty())
{
- result.clear();
return 0;
}
- int n = 0;
+ unsigned int n = 0;
int size = 1; /* Account for initial +/- char */
int nextsize = 0;
- result.clear();
- result.push_back(adding ? "+" : "-");
+ int start = result.size();
+ std::string modeline = adding ? "+" : "-";
+ result.push_back(modeline);
if (sequence.size() > 1)
nextsize = sequence[1].length() + 2;
- while (!sequence[0].empty() && (sequence.size() > 1) && (result.size() < ServerInstance->Config->Limits.MaxModes) && ((size + nextsize) < max_line_size))
+ while (!sequence[0].empty() && (sequence.size() > 1) && (n < ServerInstance->Config->Limits.MaxModes) && ((size + nextsize) < max_line_size))
{
- result[0] += *(sequence[0].begin());
+ modeline += *(sequence[0].begin());
if (!sequence[1].empty())
{
result.push_back(sequence[1]);
n++;
}
+ result[start] = modeline;
return n;
}
unsigned int parameter_counter = 2; /* Index of first parameter */
unsigned int parameter_count = 0;
bool last_successful_state_change = false;
+ LastParseParams.push_back(output_sequence);
LastParseTranslate.push_back(TR_TEXT);
/* A mode sequence that doesnt start with + or -. Assume +. - Thanks for the suggestion spike (bug#132) */
/* Was there at least one valid mode in the sequence? */
if (!output_sequence.empty())
{
- LastParseParams.push_front(output_sequence);
+ LastParseParams[0] = output_sequence;
if (!user)
{
if (type == MODETYPE_CHANNEL)
void Module::OnModuleRehash(User*, const std::string&) { }
void Module::OnRehash(User*) { }
int Module::OnUserPreJoin(User*, Channel*, const char*, std::string&, const std::string&) { return 0; }
-void Module::OnMode(User*, void*, int, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
+void Module::OnMode(User*, void*, int, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
Version Module::GetVersion() { return Version("Misconfigured", VF_VENDOR, -1); }
void Module::OnOper(User*, const std::string&) { }
void Module::OnPostOper(User*, const std::string&, const std::string &) { }
void Module::OnGetServerDescription(const std::string&, std::string&) { }
void Module::OnSyncUser(User*, Module*, void*) { }
void Module::OnSyncChannel(Channel*, Module*, void*) { }
-void Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::deque<std::string>&, const std::deque<TranslateType>&) { }
+void Module::ProtoSendMode(void*, TargetTypeFlags, void*, const std::vector<std::string>&, const std::vector<TranslateType>&) { }
void Module::OnSyncChannelMetaData(Channel*, Module*, void*, const std::string&, bool) { }
void Module::OnSyncUserMetaData(User*, Module*, void*, const std::string&, bool) { }
void Module::OnSyncOtherMetaData(Module*, void*, bool) { }
irc::string hashtype;
hashymodules hashers;
bool diduseiface;
- std::deque<std::string> names;
+ parameterlist names;
public:
ModuleSQLOper(InspIRCd* Me)
{
this->user->Extend("sasl_authenticator", this);
- std::deque<std::string> params;
+ parameterlist params;
params.push_back("*");
params.push_back("SASL");
params.push_back(user->uuid);
}
/* checks for and deals with a state change. */
- SaslState ProcessInboundMessage(std::deque<std::string> &msg)
+ SaslState ProcessInboundMessage(parameterlist &msg)
{
switch (this->state)
{
if (this->state != SASL_COMM)
return true;
- std::deque<std::string> params;
+ parameterlist params;
params.push_back("*");
params.push_back("SASL");
params.push_back(this->user->uuid);
if (ev->GetEventID() == "encap_received")
{
- std::deque<std::string>* parameters = (std::deque<std::string>*)ev->GetData();
+ parameterlist* parameters = (parameterlist*)ev->GetData();
if ((*parameters)[1] != "SASL")
return;
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::AddLine(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::AddLine(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 6)
{
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
/** remote ADMIN. leet, huh? */
-bool TreeSocket::Admin(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Admin(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() > 0)
{
User* source = this->ServerInstance->FindNick(prefix);
if (source)
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(prefix);
par.push_back("");
par[1] = std::string("::")+ServerInstance->Config->ServerName+" 256 "+source->nick+" :Administrative info for "+ServerInstance->Config->ServerName;
return result;
}
-bool TreeSocket::Capab(const std::deque<std::string> ¶ms)
+bool TreeSocket::Capab(const parameterlist ¶ms)
{
if (params.size() < 1)
{
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::DelLine(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::DelLine(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 2)
return true;
/** remote MOTD. leet, huh? */
-bool TreeSocket::Encap(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Encap(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() > 1)
{
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::ChangeHost(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ChangeHost(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
/** FJOIN, almost identical to TS6 SJOIN, except for nicklist handling. */
-bool TreeSocket::ForceJoin(const std::string &source, std::deque<std::string> ¶ms)
+bool TreeSocket::ForceJoin(const std::string &source, parameterlist ¶ms)
{
/* 1.1 FJOIN works as follows:
*
{
/* Our TS greater than theirs, clear all our modes from the channel, accept theirs. */
ServerInstance->SNO->WriteToSnoMask('d', "Removing our modes, accepting remote");
- std::deque<std::string> param_list;
+ parameterlist param_list;
if (Utils->AnnounceTSChange && chan)
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;
/* Flush mode stacker if we lost the FJOIN or had equal TS */
if (apply_other_sides_modes)
{
- std::deque<std::string> stackresult;
- std::vector<std::string> mode_junk;
- mode_junk.push_back(channel);
+ parameterlist stackresult;
+ stackresult.push_back(channel);
while (modestack.GetStackedLine(stackresult))
{
- mode_junk.insert(mode_junk.end(), stackresult.begin(), stackresult.end());
- ServerInstance->SendMode(mode_junk, Utils->ServerUser);
- mode_junk.erase(mode_junk.begin() + 1, mode_junk.end());
+ ServerInstance->SendMode(stackresult, Utils->ServerUser);
+ stackresult.erase(stackresult.begin() + 1, stackresult.end());
}
}
return true;
}
-bool TreeSocket::RemoveStatus(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::RemoveStatus(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
if (c)
{
irc::modestacker stack(ServerInstance, false);
- std::deque<std::string> stackresult;
- std::vector<std::string> mode_junk;
- mode_junk.push_back(c->name);
+ parameterlist stackresult;
+ stackresult.push_back(c->name);
for (char modeletter = 'A'; modeletter <= 'z'; ++modeletter)
{
while (stack.GetStackedLine(stackresult))
{
- mode_junk.insert(mode_junk.end(), stackresult.begin(), stackresult.end());
- ServerInstance->SendMode(mode_junk, Utils->ServerUser);
- mode_junk.erase(mode_junk.begin() + 1, mode_junk.end());
+ ServerInstance->SendMode(stackresult, Utils->ServerUser);
+ stackresult.erase(stackresult.begin() + 1, stackresult.end());
}
}
return true;
/** FMODE command - server mode with timestamp checks */
-bool TreeSocket::ForceMode(const std::string &source, std::deque<std::string> ¶ms)
+bool TreeSocket::ForceMode(const std::string &source, parameterlist ¶ms)
{
/* Chances are this is a 1.0 FMODE without TS */
if (params.size() < 3)
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::ChangeName(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ChangeName(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
/** FTOPIC command */
-bool TreeSocket::ForceTopic(const std::string &source, std::deque<std::string> ¶ms)
+bool TreeSocket::ForceTopic(const std::string &source, parameterlist ¶ms)
{
if (params.size() != 4)
return true;
-bool TreeSocket::RemoteKill(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::RemoteKill(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() != 2)
return true;
{
if (IS_LOCAL(source))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(dest->uuid);
params.push_back(channel->name);
params.push_back(ConvToStr(expiry));
void ModuleSpanningTree::OnPostLocalTopicChange(User* user, Channel* chan, const std::string &topic)
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(chan->name);
params.push_back(":"+topic);
Utils->DoOneToMany(user->uuid,"TOPIC",params);
{
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(":"+text);
Utils->DoOneToMany(user->uuid,"WALLOPS",params);
}
User* d = (User*)dest;
if ((d->GetFd() < 0) && (IS_LOCAL(user)))
{
- std::deque<std::string> params;
- params.clear();
+ parameterlist params;
params.push_back(d->uuid);
params.push_back(":"+text);
Utils->DoOneToOne(user->uuid,"NOTICE",params,d->server);
if (IS_LOCAL(user))
{
char* target = (char*)dest;
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(target);
par.push_back(":"+text);
Utils->DoOneToMany(user->uuid,"NOTICE",par);
User* d = (User*)dest;
if ((d->GetFd() < 0) && (IS_LOCAL(user)))
{
- std::deque<std::string> params;
- params.clear();
+ parameterlist params;
params.push_back(d->uuid);
params.push_back(":"+text);
Utils->DoOneToOne(user->uuid,"PRIVMSG",params,d->server);
if (IS_LOCAL(user))
{
char* target = (char*)dest;
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(target);
par.push_back(":"+text);
Utils->DoOneToMany(user->uuid,"PRIVMSG",par);
// Only do this for local users
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
// set up their permissions and the channel TS with FJOIN.
// All users are FJOINed now, because a module may specify
// new joining permissions for the user.
if (user->registered != REG_ALL)
return 0;
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(newhost);
Utils->DoOneToMany(user->uuid,"FHOST",params);
return 0;
if (user->registered != REG_ALL)
return;
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(gecos);
Utils->DoOneToMany(user->uuid,"FNAME",params);
}
{
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(channel->name);
if (!partmessage.empty())
params.push_back(":"+partmessage);
{
if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
{
- std::deque<std::string> params;
+ parameterlist params;
if (oper_message != reason)
{
{
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(user->nick);
/** IMPORTANT: We don't update the TS if the oldnick is just a case change of the newnick!
void ModuleSpanningTree::OnUserKick(User* source, User* user, Channel* chan, const std::string &reason, bool &silent)
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(chan->name);
params.push_back(user->uuid);
params.push_back(":"+reason);
if (!IS_LOCAL(source))
return; // Only start routing if we're origin.
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(":"+reason);
Utils->DoOneToMany(dest->uuid,"OPERQUIT",params);
params.clear();
// Send out to other servers
if (!parameter.empty() && parameter[0] != '-')
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameter);
Utils->DoOneToAllButSender(user ? user->uuid : ServerInstance->Config->GetSID(), "REHASH", params, user ? user->server : ServerInstance->Config->ServerName);
}
{
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(opertype);
Utils->DoOneToMany(user->uuid,"OPERTYPE",params);
}
char data[MAXBUF];
snprintf(data,MAXBUF,"%s %s %s %lu %lu :%s", x->type.c_str(), x->Displayable(),
ServerInstance->Config->ServerName, (unsigned long)x->set_time, (unsigned long)x->duration, x->reason);
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(data);
if (!user)
char data[MAXBUF];
snprintf(data,MAXBUF,"%s %s", x->type.c_str(), x->Displayable());
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(data);
if (!user)
}
}
-void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate)
+void ModuleSpanningTree::OnMode(User* user, void* dest, int target_type, const parameterlist &text, const std::vector<TranslateType> &translate)
{
if ((IS_LOCAL(user)) && (user->registered == REG_ALL))
{
- std::deque<std::string> params;
+ parameterlist params;
std::string command;
std::string output_text;
{
if (awaymsg.empty())
{
- std::deque<std::string> params;
+ parameterlist params;
params.clear();
Utils->DoOneToMany(user->uuid,"AWAY",params);
}
else
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(":" + awaymsg);
Utils->DoOneToMany(user->uuid,"AWAY",params);
}
return 0;
}
-void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate)
+void ModuleSpanningTree::ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const parameterlist &modeline, const std::vector<TranslateType> &translate)
{
TreeSocket* s = (TreeSocket*)opaque;
std::string output_text;
void OnLine(User* source, const std::string &host, bool adding, char linetype, long duration, const std::string &reason);
virtual void OnAddLine(User *u, XLine *x);
virtual void OnDelLine(User *u, XLine *x);
- virtual void OnMode(User* user, void* dest, int target_type, const std::deque<std::string> &text, const std::deque<TranslateType> &translate);
+ virtual void OnMode(User* user, void* dest, int target_type, const std::vector<std::string> &text, const std::vector<TranslateType> &translate);
virtual int OnStats(char statschar, User* user, string_list &results);
virtual int OnSetAway(User* user, const std::string &awaymsg);
- virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::deque<std::string> &modeline, const std::deque<TranslateType> &translate);
+ virtual void ProtoSendMode(void* opaque, TargetTypeFlags target_type, void* target, const std::vector<std::string> &modeline, const std::vector<TranslateType> &translate);
virtual void ProtoSendMetaData(void* opaque, TargetTypeFlags target_type, void* target, const std::string &extname, const std::string &extdata);
virtual void OnEvent(Event* event);
virtual void OnLoadModule(Module* mod,const std::string &name);
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::MetaData(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::MetaData(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 2)
return true;
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::Modules(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Modules(const std::string &prefix, parameterlist ¶ms)
{
if (params.empty())
return true;
}
char strbuf[MAXBUF];
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(prefix);
par.push_back("");
/** remote MOTD. leet, huh? */
-bool TreeSocket::Motd(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Motd(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() > 0)
{
if (source)
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(prefix);
par.push_back("");
* Local-side nick needs to change. Just in case we are hub, and
* this "local" nick is actually behind us, send an SVSNICK out.
*/
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(u->uuid);
params.push_back(u->uuid);
params.push_back(ConvToStr(u->age));
/* $ModDep: m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::OperQuit(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::OperQuit(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
/** Because the core won't let users or even SERVERS set +o,
* we use the OPERTYPE command to do this.
*/
-bool TreeSocket::OperType(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::OperType(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() != 1)
return true;
return 0;
/* Remote ADMIN, the server is within the 1st parameter */
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameters[0]);
/* Send it out remotely, generate no reply yet */
TreeServer* s = Utils->FindServerMask(parameters[0]);
}
else if (s && s != Utils->TreeRoot)
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameters[0]);
params[0] = s->GetName();
if (InspIRCd::Match(ServerInstance->Config->ServerName, parameters[0]))
return 0;
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameters[0]);
TreeServer* s = Utils->FindServerMask(parameters[0].c_str());
if (s)
return 0;
/* Remote MOTD, the server is within the 1st parameter */
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameters[0]);
/* Send it out remotely, generate no reply yet */
TreeServer* s = Utils->FindServerMask(parameters[0]);
return 0;
/* Remote STATS, the server is within the 2nd parameter */
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(parameters[0]);
params.push_back(parameters[1]);
/* Send it out remotely, generate no reply yet */
if (found == Utils->TreeRoot)
return 0;
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(found->GetName());
params.push_back(user->uuid);
Utils->DoOneToOne(ServerInstance->Config->GetSID(),"TIME",params,found->GetName());
User* remote = ServerInstance->FindNick(parameters[1]);
if ((remote) && (remote->GetFd() < 0))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(remote->uuid);
Utils->DoOneToOne(user->uuid,"IDLE",params,remote->server);
return 1;
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::LocalPing(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::LocalPing(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::LocalPong(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::LocalPong(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
// can just handle commands locally, without having
// to have any special provision in place for remote
// commands and linking protocols.
- std::deque<std::string> params;
+ parameterlist params;
params.clear();
unsigned int n_translate = thiscmd->translation.size();
TranslateType translate_to;
/** remote MOTD. leet, huh? */
-bool TreeSocket::ServerMessage(const std::string &messagetype, const std::string &prefix, std::deque<std::string> ¶ms, const std::string &sourceserv)
+bool TreeSocket::ServerMessage(const std::string &messagetype, const std::string &prefix, parameterlist ¶ms, const std::string &sourceserv)
{
if (params.size() >= 2)
{
Utils->DoOneToMany(ServerInstance->Config->GetSID(),"FTOPIC", params);
}
-void SpanningTreeProtocolInterface::SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &translate)
+void SpanningTreeProtocolInterface::SendMode(const std::string &target, const parameterlist &modedata, const std::vector<TranslateType> &translate)
{
if (modedata.empty())
return;
return;
if (IS_LOCAL(user))
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(user->uuid);
params.push_back(ConvToStr(user->age));
params.push_back(user->nick);
virtual void SendEncapsulatedData(parameterlist &encap);
virtual void SendMetaData(void* target, TargetTypeFlags type, const std::string &key, const std::string &data);
virtual void SendTopic(Channel* channel, std::string &topic);
- virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::deque<TranslateType> &types);
+ virtual void SendMode(const std::string &target, const parameterlist &modedata, const std::vector<TranslateType> &types);
virtual void SendModeNotice(const std::string &modes, const std::string &text);
virtual void SendSNONotice(const std::string &snomask, const std::string &text);
virtual void PushToClient(User* target, const std::string &rawline);
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::Push(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Push(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 2)
return true;
}
else
{
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(user->nick);
params.push_back("NOTICE "+ConvToStr(user->nick)+" :"+msg);
Utils->DoOneToOne(ServerInstance->Config->GetSID(), "PUSH", params, user->server);
* Some server somewhere in the network introducing another server.
* -- w
*/
-bool TreeSocket::RemoteServer(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::RemoteServer(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 5)
{
* This is used after the other side of a connection has accepted our credentials.
* They are then introducing themselves to us, BEFORE either of us burst. -- w
*/
-bool TreeSocket::Outbound_Reply_Server(std::deque<std::string> ¶ms)
+bool TreeSocket::Outbound_Reply_Server(parameterlist ¶ms)
{
if (params.size() < 5)
{
* Someone else is attempting to connect to us if this is called. Validate their credentials etc.
* -- w
*/
-bool TreeSocket::Inbound_Server(std::deque<std::string> ¶ms)
+bool TreeSocket::Inbound_Server(parameterlist ¶ms)
{
if (params.size() < 5)
{
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h */
-bool TreeSocket::Stats(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Stats(const std::string &prefix, parameterlist ¶ms)
{
/* Get the reply to a STATS query if it matches this servername,
* and send it back as a load of PUSH queries
User* source = this->ServerInstance->FindNick(prefix);
if (source)
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(prefix);
par.push_back("");
DoStats(this->ServerInstance, *(params[0].c_str()), source, results);
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::ServiceJoin(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ServiceJoin(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 2)
return true;
/** Because Andy insists that services-compatible servers must
* implement SVSNICK and SVSJOIN, that's exactly what we do :p
*/
-bool TreeSocket::ForceNick(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ForceNick(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 3)
return true;
if (IS_LOCAL(u))
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(params[1]);
if (!u->ForceNickChange(params[1].c_str()))
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::ServicePart(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ServicePart(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 2)
return true;
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::Time(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Time(const std::string &prefix, parameterlist ¶ms)
{
// :source.server TIME remote.server sendernick
// :remote.server TIME source.server sendernick TS
/* Isolate and return the elements that are different between two comma seperated lists */
std::string ListDifference(const std::string &one, const std::string &two);
- bool Capab(const std::deque<std::string> ¶ms);
+ bool Capab(const parameterlist ¶ms);
/** This function forces this server to quit, removing this server
* and any users on it (and servers and users below that, etc etc).
void Squit(TreeServer* Current, const std::string &reason);
/** FMODE command - server mode with timestamp checks */
- bool ForceMode(const std::string &source, std::deque<std::string> ¶ms);
+ bool ForceMode(const std::string &source, parameterlist ¶ms);
/** FTOPIC command */
- bool ForceTopic(const std::string &source, std::deque<std::string> ¶ms);
+ bool ForceTopic(const std::string &source, parameterlist ¶ms);
/** FJOIN, similar to TS6 SJOIN, but not quite. */
- bool ForceJoin(const std::string &source, std::deque<std::string> ¶ms);
+ bool ForceJoin(const std::string &source, parameterlist ¶ms);
/* Used on nick collision ... XXX ugly function HACK */
int DoCollision(User *u, time_t remotets, const std::string &remoteident, const std::string &remoteip, const std::string &remoteuid);
/** UID command */
- bool ParseUID(const std::string &source, std::deque<std::string> ¶ms);
+ bool ParseUID(const std::string &source, parameterlist ¶ms);
/** Send one or more FJOINs for a channel of users.
* If the length of a single line is more than 480-NICKMAX
void WriteLine(std::string line);
/** Handle ERROR command */
- bool Error(std::deque<std::string> ¶ms);
+ bool Error(parameterlist ¶ms);
/** remote MOTD. leet, huh? */
- bool Motd(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Motd(const std::string &prefix, parameterlist ¶ms);
/** remote ADMIN. leet, huh? */
- bool Admin(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Admin(const std::string &prefix, parameterlist ¶ms);
/** Remote MODULES */
- bool Modules(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Modules(const std::string &prefix, parameterlist ¶ms);
- bool Stats(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Stats(const std::string &prefix, parameterlist ¶ms);
/** Because the core won't let users or even SERVERS set +o,
* we use the OPERTYPE command to do this.
*/
- bool OperType(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool OperType(const std::string &prefix, parameterlist ¶ms);
/** Because Andy insists that services-compatible servers must
* implement SVSNICK and SVSJOIN, that's exactly what we do :p
*/
- bool ForceNick(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ForceNick(const std::string &prefix, parameterlist ¶ms);
/** PRIVMSG or NOTICE with server origin ONLY
*/
- bool ServerMessage(const std::string &messagetype, const std::string &prefix, std::deque<std::string> ¶ms, const std::string &sourceserv);
+ bool ServerMessage(const std::string &messagetype, const std::string &prefix, parameterlist ¶ms, const std::string &sourceserv);
/** ENCAP command
*/
- bool Encap(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Encap(const std::string &prefix, parameterlist ¶ms);
/** OPERQUIT command
*/
- bool OperQuit(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool OperQuit(const std::string &prefix, parameterlist ¶ms);
/** SVSJOIN
*/
- bool ServiceJoin(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ServiceJoin(const std::string &prefix, parameterlist ¶ms);
/** SVSPART
*/
- bool ServicePart(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ServicePart(const std::string &prefix, parameterlist ¶ms);
/** KILL
*/
- bool RemoteKill(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool RemoteKill(const std::string &prefix, parameterlist ¶ms);
/** PONG
*/
- bool LocalPong(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool LocalPong(const std::string &prefix, parameterlist ¶ms);
/** METADATA
*/
- bool MetaData(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool MetaData(const std::string &prefix, parameterlist ¶ms);
/** VERSION
*/
- bool ServerVersion(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ServerVersion(const std::string &prefix, parameterlist ¶ms);
/** CHGHOST
*/
- bool ChangeHost(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ChangeHost(const std::string &prefix, parameterlist ¶ms);
/** ADDLINE
*/
- bool AddLine(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool AddLine(const std::string &prefix, parameterlist ¶ms);
/** DELLINE
*/
- bool DelLine(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool DelLine(const std::string &prefix, parameterlist ¶ms);
/** CHGNAME
*/
- bool ChangeName(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool ChangeName(const std::string &prefix, parameterlist ¶ms);
/** WHOIS
*/
- bool Whois(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Whois(const std::string &prefix, parameterlist ¶ms);
/** PUSH
*/
- bool Push(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Push(const std::string &prefix, parameterlist ¶ms);
/** TIME
*/
- bool Time(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool Time(const std::string &prefix, parameterlist ¶ms);
/** PING
*/
- bool LocalPing(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool LocalPing(const std::string &prefix, parameterlist ¶ms);
/** Remove all modes from a channel, including statusmodes (+qaovh etc), simplemodes, parameter modes.
* This does not update the timestamp of the target channel, this must be done seperately.
*/
- bool RemoveStatus(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool RemoveStatus(const std::string &prefix, parameterlist ¶ms);
/** <- (remote) <- SERVER
*/
- bool RemoteServer(const std::string &prefix, std::deque<std::string> ¶ms);
+ bool RemoteServer(const std::string &prefix, parameterlist ¶ms);
/** (local) -> SERVER
*/
- bool Outbound_Reply_Server(std::deque<std::string> ¶ms);
+ bool Outbound_Reply_Server(parameterlist ¶ms);
/** (local) <- SERVER
*/
- bool Inbound_Server(std::deque<std::string> ¶ms);
+ bool Inbound_Server(parameterlist ¶ms);
/** Handle netsplit
*/
- void Split(const std::string &line, std::deque<std::string> &n);
+ void Split(const std::string &line, parameterlist &n);
/** Process complete line from buffer
*/
Event rmode((char*)Current->GetName().c_str(), (Module*)Utils->Creator, "lost_server");
rmode.Send(ServerInstance);
- std::deque<std::string> params;
+ parameterlist params;
params.push_back(Current->GetName());
params.push_back(":"+reason);
Utils->DoOneToAllButSender(Current->GetParent()->GetName(),"SQUIT",params,Current->GetName());
/* Handle ERROR command */
-bool TreeSocket::Error(std::deque<std::string> ¶ms)
+bool TreeSocket::Error(parameterlist ¶ms)
{
if (params.size() < 1)
return false;
return false;
}
-void TreeSocket::Split(const std::string &line, std::deque<std::string> &n)
+void TreeSocket::Split(const std::string &line, parameterlist &n)
{
n.clear();
irc::tokenstream tokens(line);
bool TreeSocket::ProcessLine(std::string &line)
{
- std::deque<std::string> params;
+ parameterlist params;
irc::string command;
std::string prefix;
if ((params[0][0] == ':') && (params.size() > 1))
{
prefix = params[0].substr(1);
- params.pop_front();
if (prefix.empty())
{
this->SendError("BUG (?) Empty prefix recieved: " + line);
return false;
}
+ command = params[1].c_str();
+ params.erase(params.begin(), params.begin() + 2);
+ }
+ else
+ {
+ command = params[0].c_str();
+ params.erase(params.begin());
}
-
- command = params[0].c_str();
- params.pop_front();
switch (this->LinkState)
{
/* $ModDep: m_spanningtree/resolvers.h m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/link.h m_spanningtree/treesocket.h m_hash.h m_spanningtree/handshaketimer.h */
-bool TreeSocket::ParseUID(const std::string &source, std::deque<std::string> ¶ms)
+bool TreeSocket::ParseUID(const std::string &source, parameterlist ¶ms)
{
/** Do we have enough parameters:
* 0 1 2 3 4 5 6 7 8 9 (n-1)
return;
}
-bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque<std::string> ¶ms)
+bool SpanningTreeUtilities::DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, parameterlist ¶ms)
{
char pfx = 0;
TreeServer* omitroute = this->BestRouteTo(omit);
User* d = ServerInstance->FindNick(params[0]);
if (d)
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(params[0]);
par.push_back(":"+params[1]);
this->DoOneToOne(prefix,command.c_str(),par,d->server);
}
else if (*(params[0].c_str()) == '$')
{
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(params[0]);
par.push_back(":"+params[1]);
this->DoOneToAllButSender(prefix,command.c_str(),par,omitroute->GetName());
return true;
}
-bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms, std::string omit)
+bool SpanningTreeUtilities::DoOneToAllButSender(const std::string &prefix, const std::string &command, parameterlist ¶ms, std::string omit)
{
TreeServer* omitroute = this->BestRouteTo(omit);
std::string FullLine = ":" + prefix + " " + command;
return true;
}
-bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms)
+bool SpanningTreeUtilities::DoOneToMany(const std::string &prefix, const std::string &command, parameterlist ¶ms)
{
std::string FullLine = ":" + prefix + " " + command;
unsigned int words = params.size();
return true;
}
-bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, std::deque<std::string> ¶ms)
+bool SpanningTreeUtilities::DoOneToMany(const char* prefix, const char* command, parameterlist ¶ms)
{
std::string spfx = prefix;
std::string scmd = command;
return this->DoOneToMany(spfx, scmd, params);
}
-bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> ¶ms, std::string omit)
+bool SpanningTreeUtilities::DoOneToAllButSender(const char* prefix, const char* command, parameterlist ¶ms, std::string omit)
{
std::string spfx = prefix;
std::string scmd = command;
return this->DoOneToAllButSender(spfx, scmd, params, omit);
}
-bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms, std::string target)
+bool SpanningTreeUtilities::DoOneToOne(const std::string &prefix, const std::string &command, parameterlist ¶ms, std::string target)
{
TreeServer* Route = this->BestRouteTo(target);
if (Route)
/** Send a message from this server to one other local or remote
*/
- bool DoOneToOne(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms, std::string target);
+ bool DoOneToOne(const std::string &prefix, const std::string &command, parameterlist ¶ms, std::string target);
/** Send a message from this server to all but one other, local or remote
*/
- bool DoOneToAllButSender(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms, std::string omit);
+ bool DoOneToAllButSender(const std::string &prefix, const std::string &command, parameterlist ¶ms, std::string omit);
/** Send a message from this server to all but one other, local or remote
*/
- bool DoOneToAllButSender(const char* prefix, const char* command, std::deque<std::string> ¶ms, std::string omit);
+ bool DoOneToAllButSender(const char* prefix, const char* command, parameterlist ¶ms, std::string omit);
/** Send a message from this server to all others
*/
- bool DoOneToMany(const std::string &prefix, const std::string &command, std::deque<std::string> ¶ms);
+ bool DoOneToMany(const std::string &prefix, const std::string &command, parameterlist ¶ms);
/** Send a message from this server to all others
*/
- bool DoOneToMany(const char* prefix, const char* command, std::deque<std::string> ¶ms);
+ bool DoOneToMany(const char* prefix, const char* command, parameterlist ¶ms);
/** Send a message from this server to all others, without doing any processing on the command (e.g. send it as-is with colons and all)
*/
- bool DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, std::deque<std::string> ¶ms);
+ bool DoOneToAllButSenderRaw(const std::string &data, const std::string &omit, const std::string &prefix, const irc::string &command, parameterlist ¶ms);
/** Read the spanningtree module's tags from the config file
*/
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::ServerVersion(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::ServerVersion(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
/* $ModDep: m_spanningtree/main.h m_spanningtree/utils.h m_spanningtree/treeserver.h m_spanningtree/treesocket.h */
-bool TreeSocket::Whois(const std::string &prefix, std::deque<std::string> ¶ms)
+bool TreeSocket::Whois(const std::string &prefix, parameterlist ¶ms)
{
if (params.size() < 1)
return true;
char idle[MAXBUF];
snprintf(signon, MAXBUF, "%lu", (unsigned long)x->signon);
snprintf(idle, MAXBUF, "%lu", (unsigned long)abs((long)((x->idle_lastmsg) - ServerInstance->Time())));
- std::deque<std::string> par;
+ parameterlist par;
par.push_back(prefix);
par.push_back(signon);
par.push_back(idle);
projects / user / henk / code / inspircd.git / commitdiff