return ret;
}
-User::User(const std::string& uid, Server* srv, int type)
+User::User(const std::string& uid, Server* srv, UserType type)
: age(ServerInstance->Time())
, signon(0)
, uuid(uid)
eh.SetFd(myfd);
memcpy(&client_sa, client, sizeof(irc::sockets::sockaddrs));
memcpy(&server_sa, servaddr, sizeof(irc::sockets::sockaddrs));
- dhost = host = GetIPString();
+ ChangeRealHost(GetIPString(), true);
}
User::~User()
return this->cached_makehost;
// XXX: Is there really a need to cache this?
- this->cached_makehost = ident + "@" + host;
+ this->cached_makehost = ident + "@" + GetRealHost();
return this->cached_makehost;
}
return this->cached_fullhost;
// XXX: Is there really a need to cache this?
- this->cached_fullhost = nick + "!" + ident + "@" + dhost;
+ this->cached_fullhost = nick + "!" + ident + "@" + GetDisplayedHost();
return this->cached_fullhost;
}
return this->cached_fullrealhost;
// XXX: Is there really a need to cache this?
- this->cached_fullrealhost = nick + "!" + ident + "@" + host;
+ this->cached_fullrealhost = nick + "!" + ident + "@" + GetRealHost();
return this->cached_fullrealhost;
}
return false;
}
- if (oper->AllowedOperCommands.find(command) != oper->AllowedOperCommands.end())
- return true;
- else if (oper->AllowedOperCommands.find("*") != oper->AllowedOperCommands.end())
- return true;
-
- return false;
+ return oper->AllowedOperCommands.Contains(command);
}
bool User::HasPrivPermission(const std::string &privstr, bool noisy)
return false;
}
- if (oper->AllowedPrivs.find(privstr) != oper->AllowedPrivs.end())
- {
+ if (oper->AllowedPrivs.Contains(privstr))
return true;
- }
- else if (oper->AllowedPrivs.find("*") != oper->AllowedPrivs.end())
- {
- return true;
- }
if (noisy)
this->WriteNotice("Oper type " + oper->name + " does not have access to priv " + privstr);
}
ServerInstance->SNO->WriteToSnoMask('o',"%s (%s@%s) is now an IRC operator of type %s (using oper '%s')",
- nick.c_str(), ident.c_str(), host.c_str(), oper->name.c_str(), opername.c_str());
+ nick.c_str(), ident.c_str(), GetRealHost().c_str(), oper->name.c_str(), opername.c_str());
this->WriteNumeric(RPL_YOUAREOPER, InspIRCd::Format("You are now %s %s", strchr("aeiouAEIOU", oper->name[0]) ? "an" : "a", oper->name.c_str()));
ServerInstance->Logs->Log("OPER", LOG_DEFAULT, "%s opered as type: %s", GetFullRealHost().c_str(), oper->name.c_str());
void OperInfo::init()
{
- AllowedOperCommands.clear();
- AllowedPrivs.clear();
+ AllowedOperCommands.Clear();
+ AllowedPrivs.Clear();
AllowedUserModes.reset();
AllowedChanModes.reset();
AllowedUserModes['o' - 'A'] = true; // Call me paranoid if you want.
for(std::vector<reference<ConfigTag> >::iterator iter = class_blocks.begin(); iter != class_blocks.end(); ++iter)
{
ConfigTag* tag = *iter;
- std::string mycmd, mypriv;
- /* Process commands */
- irc::spacesepstream CommandList(tag->getString("commands"));
- while (CommandList.GetToken(mycmd))
- {
- AllowedOperCommands.insert(mycmd);
- }
- irc::spacesepstream PrivList(tag->getString("privs"));
- while (PrivList.GetToken(mypriv))
- {
- AllowedPrivs.insert(mypriv);
- }
+ AllowedOperCommands.AddList(tag->getString("commands"));
+ AllowedPrivs.AddList(tag->getString("privs"));
std::string modes = tag->getString("usermodes");
for (std::string::const_iterator c = modes.begin(); c != modes.end(); ++c)
return cachedip;
}
+const std::string& User::GetHost(bool uncloak) const
+{
+ return uncloak ? GetRealHost() : GetDisplayedHost();
+}
+
+const std::string& User::GetDisplayedHost() const
+{
+ return displayhost.empty() ? realhost : displayhost;
+}
+
+const std::string& User::GetRealHost() const
+{
+ return realhost;
+}
+
irc::sockets::cidr_mask User::GetCIDRMask()
{
- int range = 0;
+ unsigned char range = 0;
switch (client_sa.sa.sa_family)
{
case AF_INET6:
void User::SetClientIP(const irc::sockets::sockaddrs& sa, bool recheck_eline)
{
- cachedip.clear();
- cached_hostip.clear();
+ this->InvalidateCache();
memcpy(&client_sa, &sa, sizeof(irc::sockets::sockaddrs));
}
bool User::ChangeDisplayedHost(const std::string& shost)
{
- if (dhost == shost)
+ if (GetDisplayedHost() == shost)
return true;
if (IS_LOCAL(this))
FOREACH_MOD(OnChangeHost, (this,shost));
- this->dhost.assign(shost, 0, ServerInstance->Config->Limits.MaxHost);
+ if (realhost == shost)
+ this->displayhost.clear();
+ else
+ this->displayhost.assign(shost, 0, ServerInstance->Config->Limits.MaxHost);
+
this->InvalidateCache();
if (IS_LOCAL(this))
- this->WriteNumeric(RPL_YOURDISPLAYEDHOST, this->dhost, "is now your displayed host");
+ this->WriteNumeric(RPL_YOURDISPLAYEDHOST, this->GetDisplayedHost(), "is now your displayed host");
return true;
}
+void User::ChangeRealHost(const std::string& host, bool resetdisplay)
+{
+ // If the real host is the new host and we are not resetting the
+ // display host then we have nothing to do.
+ const bool changehost = (realhost != host);
+ if (!changehost && !resetdisplay)
+ return;
+
+ // If the displayhost is not set and we are not resetting it then
+ // we need to copy it to the displayhost field.
+ if (displayhost.empty() && !resetdisplay)
+ displayhost = realhost;
+
+ // If the displayhost is the new host or we are resetting it then
+ // we clear its contents to save memory.
+ else if (displayhost == host || resetdisplay)
+ displayhost.clear();
+
+ // If we are just resetting the display host then we don't need to
+ // do anything else.
+ if (!changehost)
+ return;
+
+ realhost = host;
+ this->InvalidateCache();
+}
+
bool User::ChangeIdent(const std::string& newident)
{
if (this->ident == newident)
/* check if host matches.. */
if (!InspIRCd::MatchCIDR(this->GetIPString(), c->GetHost(), NULL) &&
- !InspIRCd::MatchCIDR(this->host, c->GetHost(), NULL))
+ !InspIRCd::MatchCIDR(this->GetRealHost(), c->GetHost(), NULL))
{
ServerInstance->Logs->Log("CONNECTCLASS", LOG_DEBUG, "No host match (for %s)", c->GetHost().c_str());
continue;
const std::string& FakeUser::GetFullHost()
{
- if (!ServerInstance->Config->HideWhoisServer.empty())
- return ServerInstance->Config->HideWhoisServer;
+ if (!ServerInstance->Config->HideServer.empty())
+ return ServerInstance->Config->HideServer;
return server->GetName();
}
const std::string& FakeUser::GetFullRealHost()
{
- if (!ServerInstance->Config->HideWhoisServer.empty())
- return ServerInstance->Config->HideWhoisServer;
+ if (!ServerInstance->Config->HideServer.empty())
+ return ServerInstance->Config->HideServer;
return server->GetName();
}
Update(&parent);
name = "unnamed";
type = t;
- config = tag;
+ host = mask;
+
+ // Connect classes can inherit from each other but this is problematic for modules which can't use
+ // ConnectClass::Update so we build a hybrid tag containing all of the values set on this class as
+ // well as the parent class.
+ ConfigItems* items = NULL;
+ config = ConfigTag::create(tag->tag, tag->src_name, tag->src_line, items);
+
+ const ConfigItems& parentkeys = parent.config->getItems();
+ for (ConfigItems::const_iterator piter = parentkeys.begin(); piter != parentkeys.end(); ++piter)
+ {
+ // The class name and parent name are not inherited
+ if (piter->first == "name" || piter->first == "parent")
+ continue;
+
+ // Store the item in the config tag. If this item also
+ // exists in the child it will be overwritten.
+ (*items)[piter->first] = piter->second;
+ }
+
+ const ConfigItems& childkeys = tag->getItems();
+ for (ConfigItems::const_iterator citer = childkeys.begin(); citer != childkeys.end(); ++citer)
+ {
+ // This will overwrite the parent value if present.
+ (*items)[citer->first] = citer->second;
+ }
}
void ConnectClass::Update(const ConnectClass* src)
projects / user / henk / code / inspircd.git / blobdiff