/* +------------------------------------+
* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
* InspIRCd: (C) 2002-2011 InspIRCd Development Team
* See: http://wiki.inspircd.org/Credits
*
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
*/
#include "inspircd.h"
#include "account.h"
static dynamic_reference<AccountProvider> accounts("account");
static dynamic_reference<AccountDBProvider> db("accountdb");
typedef std::map<irc::string, AccountDBEntry*> NickMap;
static NickMap nickinfo;
struct NickTSItem
{
irc::string nick;
time_t ts;
NickTSItem(const irc::string& newnick, time_t newTS) : nick(newnick), ts(newTS)
{
}
};
typedef std::vector<NickTSItem> NicksOwned;
class NicksOwnedExtItem : public TSGenericExtItem<NicksOwned>
{
bool CheckCollision(irc::string accountname, irc::string nick, time_t ts)
{
AccountDBEntry* owner = db->GetAccount(nick, false);
if(owner)
{
if(owner->ts > ts)
{
db->RemoveAccount(false, owner);
return false;
}
return true;
}
NickMap::iterator i = nickinfo.find(nick);
if(i == nickinfo.end()) return false;
AccountDBEntry* entry = i->second;
NicksOwned* ext = get_value(entry);
if(ext)
for(NicksOwned::iterator iter = ext->begin(); iter != ext->end(); ++iter)
if(iter->nick == nick)
{
if(iter->ts < ts || (iter->ts == ts && entry->name < accountname))
return true;
ext->erase(iter);
nickinfo.erase(i);
return false;
}
throw ModuleException("An entry in nickinfo is incorrect");
}
protected:
virtual std::string value_serialize(SerializeFormat format, const NicksOwned* value) const
{
std::ostringstream str;
if(format == FORMAT_USER)
{
for(NicksOwned::const_iterator i = value->begin(); i != value->end(); ++i)
{
str << i->nick << " ";
}
std::string retval = str.str();
return retval.empty() ? "-none-" : retval;
}
for(NicksOwned::const_iterator i = value->begin(); i != value->end(); ++i)
{
str << i->nick << "," << i->ts << " ";
}
return str.str();
}
private:
virtual NicksOwned* value_unserialize(SerializeFormat, const std::string&)
{
throw ModuleException("Called NicksOwnedExtItem::value_unserialize");
}
virtual void value_resolve_conflict(NicksOwned*, NicksOwned*)
{
throw ModuleException("Called NicksOwnedExtItem::value_resolve_conflict");
}
public:
NicksOwnedExtItem(const std::string& Key, Module* parent) : TSGenericExtItem<NicksOwned>(Key, NicksOwned(), parent)
{
}
virtual void unserialize(SerializeFormat format, Extensible* container, const std::string& value)
{
std::string::size_type delim = value.find_first_of(' ');
time_t ts = atol(value.substr(0, delim).c_str());
std::string item;
if(delim != std::string::npos)
item = value.substr(delim + 1);
value_pair* p = get(container);
if(!p || ts > p->first || (ts == p->first && item < value_serialize(format, p->second)))
{
if(p)
for(NicksOwned::const_iterator i = p->second->begin(); i != p->second->end(); ++i)
nickinfo.erase(i->nick);
std::string token;
irc::string nick;
time_t nickTS;
irc::spacesepstream sep(item);
std::vector<std::pair<irc::string, AccountDBEntry*> > newinfo;
NicksOwned* ptr = new NicksOwned;
while(sep.GetToken(token))
{
delim = token.find_first_of(',');
if(delim == std::string::npos)
continue;
nick = token.substr(0, delim);
nickTS = atol(token.substr(delim + 1).c_str());
if(!CheckCollision(static_cast<AccountDBEntry*>(container)->name, nick, nickTS))
{
newinfo.push_back(std::make_pair(nick, static_cast<AccountDBEntry*>(container)));
ptr->push_back(NickTSItem(nick, nickTS));
}
}
set(container, ts, ptr);
nickinfo.insert(newinfo.begin(), newinfo.end());
}
}
virtual void free(void* item)
{
if(!item) return;
NicksOwned* value = static_cast<value_pair*>(item)->second;
for(NicksOwned::const_iterator i = value->begin(); i != value->end(); ++i)
nickinfo.erase(i->nick);
this->TSGenericExtItem<NicksOwned>::free(item);
}
};
static NicksOwnedExtItem* nicks_ext;
static void RemoveNick(const irc::string& nick)
{
NickMap::iterator i = nickinfo.find(nick);
NicksOwned* ext = nicks_ext->get_value(i->second);
if(ext)
for(NicksOwned::iterator iter = ext->begin(); iter != ext->end(); ++iter)
if(iter->nick == nick)
{
ext->erase(iter);
nickinfo.erase(i);
return;
}
throw ModuleException("An entry in nickinfo is incorrect");
}
class CommandAddnick : public Command
{
public:
unsigned int limit;
CommandAddnick(Module* parent) : Command(parent, "ADDNICK", 0, 0)
{
}
CmdResult Handle(const std::vector<std::string>& parameters, User* user)
{
AccountDBEntry* entry;
if(!accounts || !accounts->IsRegistered(user) || !(entry = db->GetAccount(accounts->GetAccountName(user), false)))
{
user->WriteServ("NOTICE %s :You are not logged in", user->nick.c_str());
return CMD_FAILURE;
}
if (!ServerInstance->IsNick(user->nick.c_str(), ServerInstance->Config->Limits.NickMax))
{
user->WriteServ("NOTICE %s :You may not register your UID", user->nick.c_str());
return CMD_FAILURE;
}
if(db->GetAccount(user->nick, true))
{
user->WriteServ("NOTICE %s :Nick %s is already registered", user->nick.c_str(), user->nick.c_str());
return CMD_FAILURE;
}
NicksOwnedExtItem::value_pair* p = nicks_ext->get(entry);
if(!p)
{
NicksOwned* value = new NicksOwned;
value->push_back(NickTSItem(user->nick, ServerInstance->Time()));
nicks_ext->set(entry, value);
}
else if(limit && p->second->size() >= limit)
{
user->WriteServ("NOTICE %s :You already have the maximum number of nicks registered", user->nick.c_str());
return CMD_FAILURE;
}
else
{
p->first = ServerInstance->Time();
p->second->push_back(NickTSItem(user->nick, ServerInstance->Time()));
}
nickinfo.insert(std::make_pair(user->nick, entry));
db->SendUpdate(entry, "Nicks_owned");
ServerInstance->SNO->WriteGlobalSno('u', "%s used ADDNICK to register their nick to %s", user->nick.c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Nick %s has been registered to account %s", user->nick.c_str(), user->nick.c_str(), entry->name.c_str());
return CMD_SUCCESS;
}
};
class CommandDelnick : public Command
{
public:
CommandDelnick(Module* parent) : Command(parent, "DELNICK", 0, 1)
{
syntax = "[nick]";
}
CmdResult Handle(const std::vector<std::string>& parameters, User* user)
{
AccountDBEntry* entry;
irc::string nick = parameters.size() ? parameters[0] : user->nick;
if(!accounts || !accounts->IsRegistered(user) || !(entry = db->GetAccount(accounts->GetAccountName(user), false)))
{
user->WriteServ("NOTICE %s :You are not logged in", user->nick.c_str());
return CMD_FAILURE;
}
AccountDBEntry* owner = db->GetAccount(nick, false);
NickMap::iterator iter = nickinfo.find(nick);
if(owner == entry)
{
user->WriteServ("NOTICE %s :Nick %s is your primary nick and may not be deleted", user->nick.c_str(), nick.c_str());
return CMD_FAILURE;
}
else if(owner || iter == nickinfo.end() || iter->second != entry)
{
user->WriteServ("NOTICE %s :Nick %s is not registered to you", user->nick.c_str(), nick.c_str());
return CMD_FAILURE;
}
NicksOwnedExtItem::value_pair* p = nicks_ext->get(entry);
if(p)
for(NicksOwned::iterator i = p->second->begin(); i != p->second->end(); ++i)
if(i->nick == nick)
{
p->first = ServerInstance->Time();
p->second->erase(i);
nickinfo.erase(iter);
db->SendUpdate(entry, "Nicks_owned");
ServerInstance->SNO->WriteGlobalSno('u', "%s used DELNICK to unregister nick %s from %s", user->nick.c_str(), nick.c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Nick %s has been unregistered", user->nick.c_str(), nick.c_str());
return CMD_SUCCESS;
}
throw ModuleException("An entry in nickinfo is incorrect");
}
};
class CommandFdelnick : public Command
{
public:
CommandFdelnick(Module* Creator) : Command(Creator,"FDELNICK", 2, 2)
{
flags_needed = 'o'; syntax = "<account> <nick>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
AccountDBEntry* entry = db->GetAccount(parameters[0], false);
if(!entry)
{
user->WriteServ("NOTICE %s :No such account", user->nick.c_str());
return CMD_FAILURE;
}
if(entry->name == parameters[1])
{
user->WriteServ("NOTICE %s :Nick %s is %s's primary nick and may not be deleted", user->nick.c_str(), entry->name.c_str(), entry->name.c_str());
return CMD_FAILURE;
}
NickMap::iterator iter = nickinfo.find(parameters[1]);
if(iter == nickinfo.end() || iter->second != entry)
{
user->WriteServ("NOTICE %s :Nick %s is not registered to them", user->nick.c_str(), parameters[1].c_str());
return CMD_FAILURE;
}
NicksOwnedExtItem::value_pair* p = nicks_ext->get(entry);
if(p)
for(NicksOwned::iterator i = p->second->begin(); i != p->second->end(); ++i)
if(i->nick == parameters[1])
{
p->first = ServerInstance->Time();
p->second->erase(i);
nickinfo.erase(iter);
db->SendUpdate(entry, "Nicks_owned");
ServerInstance->SNO->WriteGlobalSno('a', "%s used FDELNICK to unregister nick %s from account %s", user->nick.c_str(), parameters[1].c_str(), entry->name.c_str());
user->WriteServ("NOTICE %s :Nick %s has been unregistered from account %s", user->nick.c_str(), parameters[1].c_str(), entry->name.c_str());
return CMD_SUCCESS;
}
throw ModuleException("An entry in nickinfo is incorrect");
}
};
/** Handle /SETENFORCE
*/
class CommandSetenforce : public Command
{
public:
TSBoolExtItem enforce;
CommandSetenforce(Module* Creator) : Command(Creator,"SETENFORCE", 1, 1), enforce("Automatically_enforce_nicks", false, true, Creator)
{
syntax = "OFF|ON";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
AccountDBEntry* entry;
if(!accounts || !accounts->IsRegistered(user) || !(entry = db->GetAccount(accounts->GetAccountName(user), false)))
{
user->WriteServ("NOTICE %s :You are not logged in", user->nick.c_str());
return CMD_FAILURE;
}
bool newsetting;
if(irc::string(parameters[0]) == "ON")
newsetting = true;
else if(irc::string(parameters[0]) == "OFF")
newsetting = false;
else
{
user->WriteServ("NOTICE %s :Unknown setting", user->nick.c_str());
return CMD_FAILURE;
}
enforce.set(entry, newsetting);
db->SendUpdate(entry, "Automatically_enforce_nicks");
user->WriteServ("NOTICE %s :Nick enforcement for account %s %s successfully", user->nick.c_str(), entry->name.c_str(), newsetting ? "enabled" : "disabled");
return CMD_SUCCESS;
}
};
/** Handle /ENFORCE
*/
class CommandEnforce : public Command
{
public:
CommandEnforce(Module* Creator) : Command(Creator,"ENFORCE", 1, 1)
{
syntax = "<nick>";
}
CmdResult Handle (const std::vector<std::string>& parameters, User *user)
{
if(IS_LOCAL(user))
{
AccountDBEntry* entry;
if(!accounts || !accounts->IsRegistered(user) || !(entry = db->GetAccount(accounts->GetAccountName(user), false)))
{
user->WriteServ("NOTICE %s :You are not logged in", user->nick.c_str());
return CMD_FAILURE;
}
NickMap::iterator iter = nickinfo.find(parameters[0]);
if(entry->name != parameters[0] && (iter == nickinfo.end() || iter->second != entry))
{
user->WriteServ("NOTICE %s :Nick %s is not registered to you", user->nick.c_str(), parameters[0].c_str());
return CMD_FAILURE;
}
}
User* target = ServerInstance->FindNick(parameters[0]);
if(!target)
{
user->WriteNumeric(ERR_NOSUCHNICK, "%s %s :No such nick/channel", user->nick.c_str(), parameters[0].c_str());
return CMD_FAILURE;
}
if(IS_LOCAL(user))
user->WriteServ("NOTICE %s :Nick %s enforced successfully", user->nick.c_str(), parameters[0].c_str());
if(IS_LOCAL(target))
{
target->WriteNumeric(433, "%s %s :Nickname overruled: ENFORCE command used",
target->nick.c_str(), target->nick.c_str());
target->ChangeNick(target->uuid, true);
if(user->registered != REG_ALL)
user->registered &= ~REG_NICK;
}
return CMD_SUCCESS;
}
RouteDescriptor GetRouting(User* user, const std::vector<std::string>& parameters)
{
User* dest = ServerInstance->FindNick(parameters[0]);
if (dest)
return ROUTE_OPT_UCAST(dest->server);
return ROUTE_LOCALONLY;
}
};
class ModuleAccountNickOwnership : public Module
{
public:
NicksOwnedExtItem nicks;
CommandAddnick cmd_addnick;
CommandDelnick cmd_delnick;
CommandFdelnick cmd_fdelnick;
CommandSetenforce cmd_setenforce;
CommandEnforce cmd_enforce;
ModuleAccountNickOwnership() : nicks("Nicks_owned", this), cmd_addnick(this), cmd_delnick(this), cmd_fdelnick(this), cmd_setenforce(this), cmd_enforce(this)
{
nicks_ext = &nicks;
}
void init()
{
ServerInstance->Modules->AddService(nicks);
ServerInstance->Modules->AddService(cmd_addnick);
ServerInstance->Modules->AddService(cmd_delnick);
ServerInstance->Modules->AddService(cmd_fdelnick);
ServerInstance->Modules->AddService(cmd_setenforce);
ServerInstance->Modules->AddService(cmd_setenforce.enforce);
ServerInstance->Modules->AddService(cmd_enforce);
Implementation eventlist[] = { I_OnUserPreNick, I_OnCheckReady, I_OnUserConnect, I_OnEvent };
ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation));
}
void ReadConfig(ConfigReadStatus&)
{
ConfigTag *tag = ServerInstance->Config->GetTag ("nickownership");
cmd_addnick.limit = tag->getInt ("limit", 5);
}
ModResult OnUserPreNick(User* user, const std::string& nick)
{
if (ServerInstance->NICKForced.get(user))
return MOD_RES_PASSTHRU;
// check the new nick
AccountDBEntry* owner = db->GetAccount(nick, true);
if(!owner || (accounts && accounts->GetAccountName(user) == owner->name))
return MOD_RES_PASSTHRU;
bool* enforce = cmd_setenforce.enforce.get_value(owner);
if (!enforce || !*enforce)
{
if(user->registered == REG_ALL)
user->WriteServ("NOTICE %s :Nick %s is registered to the account '%s'", user->nick.c_str(), nick.c_str(), owner->name.c_str());
return MOD_RES_PASSTHRU;
}
else if (user->registered == REG_ALL)
{
user->WriteNumeric(433, "%s %s :You must be identified to the account '%s' to use this nick",
user->nick.c_str(), nick.c_str(), owner->name.c_str());
return MOD_RES_DENY;
}
else
{
// allow through to give things like SASL or SQLauth time to return before denying
// sending a 437 here makes both irssi and xchat auto-select a different nick, so we'll send a NOTICE instead
user->WriteServ("NOTICE %s :Nick %s requires you to identify to the account '%s'", user->nick.c_str(), nick.c_str(), owner->name.c_str());
return MOD_RES_PASSTHRU;
}
}
ModResult OnCheckReady(LocalUser* user)
{
AccountDBEntry* owner = db->GetAccount(user->nick, true);
if(!owner)
return MOD_RES_PASSTHRU;
bool* enforce = cmd_setenforce.enforce.get_value(owner);
if (enforce && *enforce && (!accounts || owner->name != accounts->GetAccountName(user)))
{
user->WriteNumeric(433, "%s %s :Nickname overruled: requires login to the account '%s'",
user->nick.c_str(), user->nick.c_str(), owner->name.c_str());
user->ChangeNick(user->uuid, true);
user->registered &= ~REG_NICK;
return MOD_RES_DENY;
}
return MOD_RES_PASSTHRU;
}
virtual void OnUserConnect(LocalUser* user)
{
AccountDBEntry* owner = db->GetAccount(user->nick, true);
if(!owner)
return;
bool* enforce = cmd_setenforce.enforce.get_value(owner);
if ((!enforce || !*enforce) && (!accounts || owner->name != accounts->GetAccountName(user)))
user->WriteServ("NOTICE %s :Nick %s is registered to the account '%s'", user->nick.c_str(), user->nick.c_str(), owner->name.c_str());
}
void OnEvent(Event& event)
{
if(event.id == "get_account_by_alias"){
GetAccountByAliasEvent& e = static_cast<GetAccountByAliasEvent&>(event);
if(e.entry)
return; // Some other module already populated the event
NickMap::iterator iter = nickinfo.find(e.account);
if(iter != nickinfo.end())
{
e.entry = iter->second;
NicksOwned* ext = nicks.get_value(iter->second);
if(ext)
for(NicksOwned::const_iterator i = ext->begin(); i != ext->end(); ++i)
if(i->nick == e.account)
{
e.alias_ts = i->ts;
e.RemoveAliasImpl = &RemoveNick;
return;
}
throw ModuleException("An entry in nickinfo is incorrect");
}
}
}
void Prioritize()
{
ServerInstance->Modules->SetPriority(this, I_ModuleInit, PRIORITY_AFTER, ServerInstance->Modules->Find("m_account.so"));
// need to be after all modules that might deny the ready check
ServerInstance->Modules->SetPriority(this, I_OnCheckReady, PRIORITY_LAST);
}
Version GetVersion()
{
return Version("Nick registration tracking", VF_VENDOR | VF_OPTCOMMON);
}
};
MODULE_INIT(ModuleAccountNickOwnership)
