From 6302f980fe6dad83aab7d2dc1046dadea5ffd939 Mon Sep 17 00:00:00 2001 From: Adam Date: Mon, 14 Dec 2015 16:52:24 -0500 Subject: New source tree structure for modules. From commands/cs_access => chanserv/access etc. --- modules/nickserv/main/CMakeLists.txt | 1 + modules/nickserv/main/account.cpp | 129 ++++++ modules/nickserv/main/account.h | 35 ++ modules/nickserv/main/accounttype.cpp | 42 ++ modules/nickserv/main/accounttype.h | 23 + modules/nickserv/main/identifyrequest.cpp | 51 +++ modules/nickserv/main/identifyrequest.h | 13 + modules/nickserv/main/mode.cpp | 23 + modules/nickserv/main/mode.h | 14 + modules/nickserv/main/modetype.h | 14 + modules/nickserv/main/nick.cpp | 192 +++++++++ modules/nickserv/main/nick.h | 46 ++ modules/nickserv/main/nickserv.cpp | 686 ++++++++++++++++++++++++++++++ modules/nickserv/main/nicktype.cpp | 45 ++ modules/nickserv/main/nicktype.h | 32 ++ 15 files changed, 1346 insertions(+) create mode 100644 modules/nickserv/main/CMakeLists.txt create mode 100644 modules/nickserv/main/account.cpp create mode 100644 modules/nickserv/main/account.h create mode 100644 modules/nickserv/main/accounttype.cpp create mode 100644 modules/nickserv/main/accounttype.h create mode 100644 modules/nickserv/main/identifyrequest.cpp create mode 100644 modules/nickserv/main/identifyrequest.h create mode 100644 modules/nickserv/main/mode.cpp create mode 100644 modules/nickserv/main/mode.h create mode 100644 modules/nickserv/main/modetype.h create mode 100644 modules/nickserv/main/nick.cpp create mode 100644 modules/nickserv/main/nick.h create mode 100644 modules/nickserv/main/nickserv.cpp create mode 100644 modules/nickserv/main/nicktype.cpp create mode 100644 modules/nickserv/main/nicktype.h (limited to 'modules/nickserv/main') diff --git a/modules/nickserv/main/CMakeLists.txt b/modules/nickserv/main/CMakeLists.txt new file mode 100644 index 000000000..781f0ef1f --- /dev/null +++ b/modules/nickserv/main/CMakeLists.txt @@ -0,0 +1 @@ +build_subdir(${CMAKE_CURRENT_SOURCE_DIR}) diff --git a/modules/nickserv/main/account.cpp b/modules/nickserv/main/account.cpp new file mode 100644 index 000000000..85adf1a33 --- /dev/null +++ b/modules/nickserv/main/account.cpp @@ -0,0 +1,129 @@ +/* + * + * (C) 2003-2014 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + +#include "module.h" +#include "accounttype.h" +#include "modules/ns_access.h" + +AccountImpl::~AccountImpl() +{ + NickServ::nickcore_map& map = NickServ::service->GetAccountMap(); + map.erase(this->GetDisplay()); +} + +void AccountImpl::Delete() +{ + Event::OnDelCore(&Event::DelCore::OnDelCore, this); + + for (unsigned i = users.size(); i > 0; --i) + users[i - 1]->Logout(); + + return Serialize::Object::Delete(); +} + +Anope::string AccountImpl::GetDisplay() +{ + return Get(&AccountType::display); +} + +void AccountImpl::SetDisplay(const Anope::string &disp) +{ + Set(&AccountType::display, disp); +} + +Anope::string AccountImpl::GetPassword() +{ + return Get(&AccountType::pass); +} + +void AccountImpl::SetPassword(const Anope::string &pass) +{ + Set(&AccountType::pass, pass); +} + +Anope::string AccountImpl::GetEmail() +{ + return Get(&AccountType::email); +} + +void AccountImpl::SetEmail(const Anope::string &email) +{ + Set(&AccountType::email, email); +} + +Anope::string AccountImpl::GetLanguage() +{ + return Get(&AccountType::language); +} + +void AccountImpl::SetLanguage(const Anope::string &lang) +{ + Set(&AccountType::language, lang); +} + +MemoServ::MemoInfo *AccountImpl::GetMemos() +{ + return GetRef(MemoServ::memoinfo); +} + +void AccountImpl::SetDisplay(NickServ::Nick *na) +{ + if (na->GetAccount() != this || na->GetNick() == this->GetDisplay()) + return; + + Event::OnChangeCoreDisplay(&Event::ChangeCoreDisplay::OnChangeCoreDisplay, this, na->GetNick()); + + NickServ::nickcore_map& map = NickServ::service->GetAccountMap(); + + /* Remove the core from the list */ + map.erase(this->GetDisplay()); + + this->SetDisplay(na->GetNick()); + + NickServ::Account* &nc = map[this->GetDisplay()]; + if (nc) + Log(LOG_DEBUG) << "Duplicate account " << this->GetDisplay() << " in nickcore table?"; + + nc = this; +} + +bool AccountImpl::IsServicesOper() const +{ + return this->o != NULL; +} + +bool AccountImpl::IsOnAccess(User *u) +{ + Anope::string buf = u->GetIdent() + "@" + u->host, buf2, buf3; + if (!u->vhost.empty()) + buf2 = u->GetIdent() + "@" + u->vhost; + if (!u->GetCloakedHost().empty()) + buf3 = u->GetIdent() + "@" + u->GetCloakedHost(); + + for (NickAccess *access : GetRefs(nsaccess)) + { + Anope::string a = access->GetMask(); + if (Anope::Match(buf, a) || (!buf2.empty() && Anope::Match(buf2, a)) || (!buf3.empty() && Anope::Match(buf3, a))) + return true; + } + return false; +} + +unsigned int AccountImpl::GetChannelCount() +{ + unsigned int i = 0; + for (ChanServ::Channel *c : GetRefs(ChanServ::channel)) + if (c->GetFounder() == this) + ++i; + return i; +} + diff --git a/modules/nickserv/main/account.h b/modules/nickserv/main/account.h new file mode 100644 index 000000000..584548563 --- /dev/null +++ b/modules/nickserv/main/account.h @@ -0,0 +1,35 @@ +#include "modules/nickserv.h" + +class AccountImpl : public NickServ::Account +{ + public: + AccountImpl(Serialize::TypeBase *type) : NickServ::Account(type) { } + AccountImpl(Serialize::TypeBase *type, Serialize::ID id) : NickServ::Account(type, id) { } + ~AccountImpl(); + void Delete() override; + + Anope::string GetDisplay() override; + void SetDisplay(const Anope::string &) override; + + Anope::string GetPassword() override; + void SetPassword(const Anope::string &) override; + + Anope::string GetEmail() override; + void SetEmail(const Anope::string &) override; + + Anope::string GetLanguage() override; + void SetLanguage(const Anope::string &) override; + + MemoServ::MemoInfo *GetMemos() override; + + void SetDisplay(NickServ::Nick *na) override; + bool IsServicesOper() const override; + /*void AddAccess(const Anope::string &entry) override; + Anope::string GetAccess(unsigned entry) const override; + unsigned GetAccessCount() const override; + bool FindAccess(const Anope::string &entry) override; + void EraseAccess(const Anope::string &entry) override; + void ClearAccess() override;*/ + bool IsOnAccess(User *u) override; + unsigned int GetChannelCount() override; +}; diff --git a/modules/nickserv/main/accounttype.cpp b/modules/nickserv/main/accounttype.cpp new file mode 100644 index 000000000..3dad436b4 --- /dev/null +++ b/modules/nickserv/main/accounttype.cpp @@ -0,0 +1,42 @@ +#include "module.h" +#include "accounttype.h" +//#include "account.h" + +AccountType::AccountType(Module *me) : Serialize::Type(me, "NickCore") + , display(this, "display") + , pass(this, "pass") + , email(this, "email") + , language(this, "language") +{ + +} + +void AccountType::Display::SetField(AccountImpl *acc, const Anope::string &disp) +{ + NickServ::nickcore_map& map = NickServ::service->GetAccountMap(); + + if (!acc->GetDisplay().empty()) + map.erase(acc->GetDisplay()); + + Serialize::Field::SetField(acc, disp); + + if (!disp.empty()) + map[disp] = acc; + + acc->o = Oper::Find(disp); +} + +NickServ::Account *AccountType::FindAccount(const Anope::string &acc) +{ + Serialize::ID id; + EventReturn result = Event::OnSerialize(&Event::SerializeEvents::OnSerializeFind, this, &this->display, acc, id); + if (result == EVENT_ALLOW) + return RequireID(id); + + NickServ::nickcore_map &map = NickServ::service->GetAccountMap(); + auto it = map.find(acc); + if (it != map.end()) + return it->second; + return nullptr; +} + diff --git a/modules/nickserv/main/accounttype.h b/modules/nickserv/main/accounttype.h new file mode 100644 index 000000000..792629877 --- /dev/null +++ b/modules/nickserv/main/accounttype.h @@ -0,0 +1,23 @@ +#include "account.h" + +class AccountType : public Serialize::Type +{ + public: + /* Name of the account */ + struct Display : Serialize::Field + { + using Serialize::Field::Field; + + void SetField(AccountImpl *s, const Anope::string &) override; + } display; + /* User password in form of hashm:data */ + Serialize::Field pass; + Serialize::Field email; + /* Locale name of the language of the user. Empty means default language */ + Serialize::Field language; + + + AccountType(Module *); + + NickServ::Account *FindAccount(const Anope::string &nick); +}; diff --git a/modules/nickserv/main/identifyrequest.cpp b/modules/nickserv/main/identifyrequest.cpp new file mode 100644 index 000000000..4fc2f9989 --- /dev/null +++ b/modules/nickserv/main/identifyrequest.cpp @@ -0,0 +1,51 @@ +#include "identifyrequest.h" + +IdentifyRequestImpl::IdentifyRequestImpl(NickServ::IdentifyRequestListener *li, Module *o, const Anope::string &acc, const Anope::string &pass) : NickServ::IdentifyRequest(li, o, acc, pass) +{ + std::set &requests = NickServ::service->GetIdentifyRequests(); + requests.insert(this); +} + +IdentifyRequestImpl::~IdentifyRequestImpl() +{ + std::set &requests = NickServ::service->GetIdentifyRequests(); + requests.erase(this); + delete l; +} + +void IdentifyRequestImpl::Hold(Module *m) +{ + holds.insert(m); +} + +void IdentifyRequestImpl::Release(Module *m) +{ + holds.erase(m); + if (holds.empty() && dispatched) + { + if (!success) + l->OnFail(this); + delete this; + } +} + +void IdentifyRequestImpl::Success(Module *m) +{ + if (!success) + { + l->OnSuccess(this); + success = true; + } +} + +void IdentifyRequestImpl::Dispatch() +{ + if (holds.empty()) + { + if (!success) + l->OnFail(this); + delete this; + } + else + dispatched = true; +} diff --git a/modules/nickserv/main/identifyrequest.h b/modules/nickserv/main/identifyrequest.h new file mode 100644 index 000000000..e74d3129e --- /dev/null +++ b/modules/nickserv/main/identifyrequest.h @@ -0,0 +1,13 @@ +#include "modules/nickserv.h" + +class IdentifyRequestImpl : public NickServ::IdentifyRequest +{ + public: + IdentifyRequestImpl(NickServ::IdentifyRequestListener *, Module *o, const Anope::string &acc, const Anope::string &pass); + virtual ~IdentifyRequestImpl(); + + void Hold(Module *m) override; + void Release(Module *m) override; + void Success(Module *m) override; + void Dispatch() override; +}; diff --git a/modules/nickserv/main/mode.cpp b/modules/nickserv/main/mode.cpp new file mode 100644 index 000000000..61fe551c1 --- /dev/null +++ b/modules/nickserv/main/mode.cpp @@ -0,0 +1,23 @@ +#include "modules/nickserv.h" +#include "modetype.h" + +NickServ::Account *ModeImpl::GetAccount() +{ + return Get(&NSModeType::account); +} + +void ModeImpl::SetAccount(NickServ::Account *a) +{ + Set(&NSModeType::account, a); +} + +Anope::string ModeImpl::GetMode() +{ + return Get(&NSModeType::mode); +} + +void ModeImpl::SetMode(const Anope::string &m) +{ + Set(&NSModeType::mode, m); +} + diff --git a/modules/nickserv/main/mode.h b/modules/nickserv/main/mode.h new file mode 100644 index 000000000..9fc4c331e --- /dev/null +++ b/modules/nickserv/main/mode.h @@ -0,0 +1,14 @@ + +class ModeImpl : public NickServ::Mode +{ + public: + ModeImpl(Serialize::TypeBase *type) : NickServ::Mode(type) { } + ModeImpl(Serialize::TypeBase *type, Serialize::ID id) : NickServ::Mode(type, id) { } + + NickServ::Account *GetAccount() override; + void SetAccount(NickServ::Account *) override; + + Anope::string GetMode() override; + void SetMode(const Anope::string &) override; +}; + diff --git a/modules/nickserv/main/modetype.h b/modules/nickserv/main/modetype.h new file mode 100644 index 000000000..0c4aefecc --- /dev/null +++ b/modules/nickserv/main/modetype.h @@ -0,0 +1,14 @@ +#include "mode.h" + +class NSModeType : public Serialize::Type +{ + public: + Serialize::ObjectField account; + Serialize::Field mode; + + NSModeType(Module *creator) : Serialize::Type(creator, "NSKeepMode") + , account(this, "account", true) + , mode(this, "mode") + { + } +}; diff --git a/modules/nickserv/main/nick.cpp b/modules/nickserv/main/nick.cpp new file mode 100644 index 000000000..0ac55ff93 --- /dev/null +++ b/modules/nickserv/main/nick.cpp @@ -0,0 +1,192 @@ +/* + * + * (C) 2003-2014 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + * + */ + +#include "module.h" +#include "nicktype.h" + +NickImpl::~NickImpl() +{ + /* Remove us from the aliases list */ + NickServ::nickalias_map &map = NickServ::service->GetNickMap(); + map.erase(GetNick()); +} + +void NickImpl::Delete() +{ + Event::OnDelNick(&Event::DelNick::OnDelNick, this); + + if (this->GetAccount()) + { + /* Next: see if our core is still useful. */ + std::vector aliases = this->GetAccount()->GetRefs(NickServ::nick); + + auto it = std::find(aliases.begin(), aliases.end(), this); + if (it != aliases.end()) + aliases.erase(it); + + if (aliases.empty()) + { + /* just me */ + this->GetAccount()->Delete(); + } + else + { + /* Display updating stuff */ + if (GetNick().equals_ci(this->GetAccount()->GetDisplay())) + this->GetAccount()->SetDisplay(aliases[0]); + } + } + + return Serialize::Object::Delete(); +} + +Anope::string NickImpl::GetNick() +{ + return Get(&NickType::nick); +} + +void NickImpl::SetNick(const Anope::string &nick) +{ + Set(&NickType::nick, nick); +} + +Anope::string NickImpl::GetLastQuit() +{ + return Get(&NickType::last_quit); +} + +void NickImpl::SetLastQuit(const Anope::string &lq) +{ + Set(&NickType::last_quit, lq); +} + +Anope::string NickImpl::GetLastRealname() +{ + return Get(&NickType::last_realname); +} + +void NickImpl::SetLastRealname(const Anope::string &lr) +{ + Set(&NickType::last_realname, lr); +} + +Anope::string NickImpl::GetLastUsermask() +{ + return Get(&NickType::last_usermask); +} + +void NickImpl::SetLastUsermask(const Anope::string &lu) +{ + Set(&NickType::last_usermask, lu); +} + +Anope::string NickImpl::GetLastRealhost() +{ + return Get(&NickType::last_realhost); +} + +void NickImpl::SetLastRealhost(const Anope::string &lr) +{ + Set(&NickType::last_realhost, lr); +} + +time_t NickImpl::GetTimeRegistered() +{ + return Get(&NickType::time_registered); +} + +void NickImpl::SetTimeRegistered(const time_t &tr) +{ + Set(&NickType::time_registered, tr); +} + +time_t NickImpl::GetLastSeen() +{ + return Get(&NickType::last_seen); +} + +void NickImpl::SetLastSeen(const time_t &ls) +{ + Set(&NickType::last_seen, ls); +} + +NickServ::Account *NickImpl::GetAccount() +{ + return Get(&NickType::nc); +} + +void NickImpl::SetAccount(NickServ::Account *acc) +{ + Set(&NickType::nc, acc); +} + +void NickImpl::SetVhost(const Anope::string &ident, const Anope::string &host, const Anope::string &creator, time_t created) +{ + Set(&NickType::vhost_ident, ident); + Set(&NickType::vhost_host, host); + Set(&NickType::vhost_creator, creator); + Set(&NickType::vhost_created, created); +} + +void NickImpl::RemoveVhost() +{ + Anope::string e; + Set(&NickType::vhost_ident, e); + Set(&NickType::vhost_host, e); + Set(&NickType::vhost_creator, e); + Set(&NickType::vhost_created, 0); +} + +bool NickImpl::HasVhost() +{ + return !GetVhostHost().empty(); +} + +Anope::string NickImpl::GetVhostIdent() +{ + return Get(&NickType::vhost_ident); +} + +void NickImpl::SetVhostIdent(const Anope::string &i) +{ + Set(&NickType::vhost_ident, i); +} + +Anope::string NickImpl::GetVhostHost() +{ + return Get(&NickType::vhost_host); +} + +void NickImpl::SetVhostHost(const Anope::string &h) +{ + Set(&NickType::vhost_host, h); +} + +Anope::string NickImpl::GetVhostCreator() +{ + return Get(&NickType::vhost_creator); +} + +void NickImpl::SetVhostCreator(const Anope::string &c) +{ + Set(&NickType::vhost_creator, c); +} + +time_t NickImpl::GetVhostCreated() +{ + return Get(&NickType::vhost_created); +} + +void NickImpl::SetVhostCreated(const time_t &cr) +{ + Set(&NickType::vhost_created, cr); +} diff --git a/modules/nickserv/main/nick.h b/modules/nickserv/main/nick.h new file mode 100644 index 000000000..043d7c052 --- /dev/null +++ b/modules/nickserv/main/nick.h @@ -0,0 +1,46 @@ + +class NickImpl : public NickServ::Nick +{ + public: + NickImpl(Serialize::TypeBase *type) : NickServ::Nick(type) { } + NickImpl(Serialize::TypeBase *type, Serialize::ID id) : NickServ::Nick(type, id) { } + ~NickImpl(); + void Delete() override; + + Anope::string GetNick() override; + void SetNick(const Anope::string &) override; + + Anope::string GetLastQuit() override; + void SetLastQuit(const Anope::string &) override; + + Anope::string GetLastRealname() override; + void SetLastRealname(const Anope::string &) override; + + Anope::string GetLastUsermask() override; + void SetLastUsermask(const Anope::string &) override; + + Anope::string GetLastRealhost() override; + void SetLastRealhost(const Anope::string &) override; + + time_t GetTimeRegistered() override; + void SetTimeRegistered(const time_t &) override; + + time_t GetLastSeen() override; + void SetLastSeen(const time_t &) override; + + NickServ::Account *GetAccount() override; + void SetAccount(NickServ::Account *acc) override; + + void SetVhost(const Anope::string &ident, const Anope::string &host, const Anope::string &creator, time_t created = Anope::CurTime) override; + void RemoveVhost() override; + bool HasVhost() override; + + Anope::string GetVhostIdent() override; + void SetVhostIdent(const Anope::string &) override; + Anope::string GetVhostHost() override; + void SetVhostHost(const Anope::string &) override; + Anope::string GetVhostCreator() override; + void SetVhostCreator(const Anope::string &) override; + time_t GetVhostCreated() override; + void SetVhostCreated(const time_t &) override; +}; diff --git a/modules/nickserv/main/nickserv.cpp b/modules/nickserv/main/nickserv.cpp new file mode 100644 index 000000000..26f1457cc --- /dev/null +++ b/modules/nickserv/main/nickserv.cpp @@ -0,0 +1,686 @@ +/* NickServ core functions + * + * (C) 2003-2014 Anope Team + * Contact us at team@anope.org + * + * Please read COPYING and README for further details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + */ + +#include "module.h" +#include "modules/ns_info.h" +#include "modules/ns_group.h" +#include "modules/ns_update.h" +#include "modules/help.h" +#include "modules/nickserv.h" +#include "identifyrequest.h" +#include "nicktype.h" +#include "accounttype.h" +#include "modetype.h" + +class NickServCollide; +static std::set collides; + +/** Timer for colliding nicks to force people off of nicknames + */ +class NickServCollide : public Timer +{ + NickServ::NickServService *service; + Reference u; + time_t ts; + Reference na; + + public: + NickServCollide(Module *me, NickServ::NickServService *nss, User *user, NickServ::Nick *nick, time_t delay) : Timer(me, delay), service(nss), u(user), ts(user->timestamp), na(nick) + { + collides.insert(this); + } + + ~NickServCollide() + { + collides.erase(this); + } + + NickServ::Nick *GetNick() + { + return na; + } + + User *GetUser() + { + return u; + } + + void Tick(time_t t) override + { + if (!u || !na) + return; + /* If they identified or don't exist anymore, don't kill them. */ + if (u->Account() == na->GetAccount() || u->timestamp > ts) + return; + + service->Collide(u, na); + } +}; + +/** Timer for removing HELD status from nicks. + */ +class NickServHeld : public Timer +{ + Reference na; + Anope::string nick; + public: + NickServHeld(Module *me, NickServ::Nick *n, long l) : Timer(me, l), na(n), nick(na->GetNick()) + { + n->SetS("HELD", true); + } + + void Tick(time_t) + { + if (na) + na->UnsetS("HELD"); + } +}; + +class NickServRelease; +static Anope::map NickServReleases; + +/** Timer for releasing nicks to be available for use + */ +class NickServRelease : public User, public Timer +{ + Anope::string nick; + + public: + NickServRelease(Module *me, NickServ::Nick *na, time_t delay) : User(na->GetNick(), Config->GetModule("nickserv")->Get("enforceruser", "user"), + Config->GetModule("nickserv")->Get("enforcerhost", "services.localhost.net"), "", "", Me, "Services Enforcer", Anope::CurTime, "", IRCD->UID_Retrieve(), NULL), Timer(me, delay), nick(na->GetNick()) + { + /* Erase the current release timer and use the new one */ + Anope::map::iterator nit = NickServReleases.find(this->nick); + if (nit != NickServReleases.end()) + { + IRCD->SendQuit(nit->second, ""); + delete nit->second; + } + + NickServReleases.insert(std::make_pair(this->nick, this)); + + IRCD->SendClientIntroduction(this); + } + + ~NickServRelease() + { + IRCD->SendQuit(this, ""); + NickServReleases.erase(this->nick); + } + + void Tick(time_t t) override { } +}; + +class NickServCore : public Module, public NickServ::NickServService + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook + , public EventHook +{ + Reference NickServ; + std::vector defaults; + ExtensibleItem held, collided; + EventHandlers onprenickexpire; + EventHandlers onnickexpire; + EventHandlers onnickregister; + EventHandlers onnickvalidate; + std::set identifyrequests; + NickServ::nickalias_map NickList; + NickServ::nickcore_map AccountList; + NickType nick_type; + AccountType account_type; + NSModeType mode_type; + + void OnCancel(User *u, NickServ::Nick *na) + { + if (collided.HasExt(na)) + { + collided.Unset(na); + + new NickServHeld(this, na, Config->GetModule("nickserv")->Get("releasetimeout", "1m")); + + if (IRCD->CanSVSHold) + IRCD->SendSVSHold(na->GetNick(), Config->GetModule("nickserv")->Get("releasetimeout", "1m")); + else + new NickServRelease(this, na, Config->GetModule("nickserv")->Get("releasetimeout", "1m")); + } + } + + public: + NickServCore(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, PSEUDOCLIENT | VENDOR) + , NickServ::NickServService(this) + , held(this, "HELD") + , collided(this, "COLLIDED") + , onprenickexpire(this) + , onnickexpire(this) + , onnickregister(this) + , onnickvalidate(this) + , nick_type(this) + , account_type(this) + , mode_type(this) + { + } + + ~NickServCore() + { + OnShutdown(); + } + + void OnShutdown() override + { + /* On shutdown, restart, or mod unload, remove all of our holds for nicks (svshold or qlines) + * because some IRCds do not allow us to have these automatically expire + */ + for (NickServ::Nick *na : nick_type.List()) + this->Release(na); + } + + void OnRestart() override + { + OnShutdown(); + } + + void Validate(User *u) override + { + NickServ::Nick *na = NickServ::FindNick(u->nick); + if (!na) + return; + + EventReturn MOD_RESULT = this->onnickvalidate(&NickServ::Event::NickValidate::OnNickValidate, u, na); + if (MOD_RESULT == EVENT_STOP) + { + this->Collide(u, na); + return; + } + else if (MOD_RESULT == EVENT_ALLOW) + return; + + if (!na->GetAccount()->HasFieldS("NS_SECURE") && u->IsRecognized()) + { + na->SetLastSeen(Anope::CurTime); + na->SetLastUsermask(u->GetIdent() + "@" + u->GetDisplayedHost()); + na->SetLastRealname(u->realname); + return; + } + + if (Config->GetModule("nickserv")->Get("nonicknameownership")) + return; + + bool on_access = u->IsRecognized(false); + + if (on_access || !na->GetAccount()->HasFieldS("KILL_IMMED")) + { + if (na->GetAccount()->HasFieldS("NS_SECURE")) + u->SendMessage(*NickServ, _("This nickname is registered and protected. If this is your nickname, type \002{0}{1} IDENTIFY \037password\037\002. Otherwise, please choose a different nickname."), Config->StrictPrivmsg, NickServ->nick); // XXX + else + u->SendMessage(*NickServ, _("This nickname is owned by someone else. If this is your nickname, type \002{0}{1} IDENTIFY \037password\037\002. Otherwise, please choose a different nickname."), Config->StrictPrivmsg, NickServ->nick); // XXX + } + if (na->GetAccount()->HasFieldS("KILLPROTECT") && !on_access) + { + if (na->GetAccount()->HasFieldS("KILL_IMMED")) + { + u->SendMessage(*NickServ, _("This nickname has been registered; you may not use it.")); + this->Collide(u, na); + } + else if (na->GetAccount()->HasFieldS("KILL_QUICK")) + { + time_t killquick = Config->GetModule("nickserv")->Get("killquick", "20s"); + u->SendMessage(*NickServ, _("If you do not change within %s, I will change your nick."), Anope::Duration(killquick, u->Account()).c_str()); + new NickServCollide(this, this, u, na, killquick); + } + else + { + time_t kill = Config->GetModule("nickserv")->Get("kill", "60s"); + u->SendMessage(*NickServ, _("If you do not change within %s, I will change your nick."), Anope::Duration(kill, u->Account()).c_str()); + new NickServCollide(this, this, u, na, kill); + } + } + + } + + void OnUserLogin(User *u) override + { + NickServ::Nick *na = NickServ::FindNick(u->nick); + if (na && na->GetAccount() == u->Account() && !Config->GetModule("nickserv")->Get("nonicknameownership") && !na->GetAccount()->HasFieldS("UNCONFIRMED")) + u->SetMode(NickServ, "REGISTERED"); + + const Anope::string &modesonid = Config->GetModule(this)->Get("modesonid"); + if (!modesonid.empty()) + u->SetModes(NickServ, "%s", modesonid.c_str()); + } + + void Collide(User *u, NickServ::Nick *na) override + { + if (na) + collided.Set(na, true); + + if (IRCD->CanSVSNick) + { + unsigned nicklen = Config->GetBlock("networkinfo")->Get("nicklen"); + const Anope::string &guestprefix = Config->GetModule("nickserv")->Get("guestnickprefix", "Guest"); + + Anope::string guestnick; + + int i = 0; + do + { + guestnick = guestprefix + stringify(static_cast(rand())); + if (guestnick.length() > nicklen) + guestnick = guestnick.substr(0, nicklen); + } + while (User::Find(guestnick) && i++ < 10); + + if (i == 11) + u->Kill(*NickServ, "Services nickname-enforcer kill"); + else + { + u->SendMessage(*NickServ, _("Your nickname is now being changed to \002%s\002"), guestnick.c_str()); + IRCD->SendForceNickChange(u, guestnick, Anope::CurTime); + } + } + else + u->Kill(*NickServ, "Services nickname-enforcer kill"); + } + + void Release(NickServ::Nick *na) override + { + if (held.HasExt(na)) + { + if (IRCD->CanSVSHold) + IRCD->SendSVSHoldDel(na->GetNick()); + else + { + User *u = User::Find(na->GetNick()); + if (u && u->server == Me) + { + u->Quit(); + } + } + + held.Unset(na); + } + collided.Unset(na); /* clear pending collide */ + } + + NickServ::IdentifyRequest *CreateIdentifyRequest(NickServ::IdentifyRequestListener *l, Module *o, const Anope::string &acc, const Anope::string &pass) override + { + return new IdentifyRequestImpl(l, o, acc, pass); + } + + std::set& GetIdentifyRequests() override + { + return identifyrequests; + } + + std::vector GetNickList() override + { + return nick_type.List(); + } + + NickServ::nickalias_map& GetNickMap() override + { + return NickList; + } + + std::vector GetAccountList() override + { + return account_type.List(); + } + + NickServ::nickcore_map& GetAccountMap() override + { + return AccountList; + } + + NickServ::Nick *FindNick(const Anope::string &nick) override + { + return nick_type.FindNick(nick); + } + + NickServ::Account *FindAccount(const Anope::string &acc) override + { + return account_type.FindAccount(acc); + } + + void OnReload(Configuration::Conf *conf) override + { + const Anope::string &nsnick = conf->GetModule(this)->Get("client"); + + if (nsnick.empty()) + throw ConfigException(Module::name + ": must be defined"); + + ServiceBot *bi = ServiceBot::Find(nsnick, true); + if (!bi) + throw ConfigException(Module::name + ": no bot named " + nsnick); + + NickServ = bi; + + spacesepstream(conf->GetModule(this)->Get("defaults", "ns_secure memo_signon memo_receive")).GetTokens(defaults); + if (defaults.empty()) + { + defaults.push_back("NS_SECURE"); + defaults.push_back("MEMO_SIGNON"); + defaults.push_back("MEMO_RECEIVE"); + } + else if (defaults[0].equals_ci("none")) + defaults.clear(); + } + + void OnDelNick(NickServ::Nick *na) override + { + User *u = User::Find(na->GetNick()); + if (u && u->Account() == na->GetAccount()) + { + IRCD->SendLogout(u); + u->RemoveMode(NickServ, "REGISTERED"); + u->Logout(); + } + } + + void OnDelCore(NickServ::Account *nc) override + { + Log(NickServ, "nick") << "Deleting nickname group " << nc->GetDisplay(); + + /* Clean up this nick core from any users online */ + for (unsigned int i = nc->users.size(); i > 0; --i) + { + User *user = nc->users[i - 1]; + IRCD->SendLogout(user); + user->RemoveMode(NickServ, "REGISTERED"); + user->Logout(); + Event::OnNickLogout(&Event::NickLogout::OnNickLogout, user); + } + } + + void OnChangeCoreDisplay(NickServ::Account *nc, const Anope::string &newdisplay) override + { + Log(LOG_NORMAL, "nick", NickServ) << "Changing " << nc->GetDisplay() << " nickname group display to " << newdisplay; + } + + void OnNickIdentify(User *u) override + { + Configuration::Block *block = Config->GetModule(this); + + if (block->Get("modeonid", "yes")) + + for (User::ChanUserList::iterator it = u->chans.begin(), it_end = u->chans.end(); it != it_end; ++it) + { + ChanUserContainer *cc = it->second; + Channel *c = cc->chan; + if (c) + c->SetCorrectModes(u, true); + } + + const Anope::string &modesonid = block->Get("modesonid"); + if (!modesonid.empty()) + u->SetModes(NickServ, "%s", modesonid.c_str()); + + if (block->Get("forceemail", "yes") && u->Account()->GetEmail().empty()) + { + u->SendMessage(*NickServ, _("You must now supply an e-mail for your nick.\n" + "This e-mail will allow you to retrieve your password in\n" + "case you forget it.")); + u->SendMessage(*NickServ, _("Type \002%s%s SET EMAIL \037e-mail\037\002 in order to set your e-mail.\n" + "Your privacy is respected; this e-mail won't be given to\n" + "any third-party person."), Config->StrictPrivmsg.c_str(), NickServ->nick.c_str()); + } + + for (std::set::iterator it = collides.begin(); it != collides.end(); ++it) + { + NickServCollide *c = *it; + if (c->GetUser() == u && c->GetNick() && c->GetNick()->GetAccount() == u->Account()) + { + delete c; + break; + } + } + } + + void OnNickGroup(User *u, NickServ::Nick *target) override + { + if (!target->GetAccount()->HasFieldS("UNCONFIRMED")) + u->SetMode(NickServ, "REGISTERED"); + } + + void OnNickUpdate(User *u) override + { + for (User::ChanUserList::iterator it = u->chans.begin(), it_end = u->chans.end(); it != it_end; ++it) + { + ChanUserContainer *cc = it->second; + Channel *c = cc->chan; + if (c) + c->SetCorrectModes(u, true); + } + } + + void OnUserConnect(User *u, bool &exempt) override + { + if (u->Quitting() || !u->server->IsSynced() || u->server->IsULined()) + return; + + const NickServ::Nick *na = NickServ::FindNick(u->nick); + + const Anope::string &unregistered_notice = Config->GetModule(this)->Get("unregistered_notice"); + if (!Config->GetModule("nickserv")->Get("nonicknameownership") && !unregistered_notice.empty() && !na && !u->Account()) + u->SendMessage(*NickServ, unregistered_notice); + else if (na && !u->IsIdentified(true)) + this->Validate(u); + } + + void OnPostUserLogoff(User *u) override + { + NickServ::Nick *na = NickServ::FindNick(u->nick); + if (na) + OnCancel(u, na); + } + + void OnServerSync(Server *s) override + { + for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it) + { + User *u = it->second; + + if (u->server == s) + { + if (u->HasMode("REGISTERED") && !u->IsIdentified(true)) + u->RemoveMode(NickServ, "REGISTERED"); + if (!u->IsIdentified()) + this->Validate(u); + } + } + } + + void OnUserNickChange(User *u, const Anope::string &oldnick) override + { + NickServ::Nick *old_na = NickServ::FindNick(oldnick), *na = NickServ::FindNick(u->nick); + /* If the new nick isn't registered or it's registered and not yours */ + if (!na || na->GetAccount() != u->Account()) + { + /* Remove +r, but keep an account associated with the user */ + u->RemoveMode(NickServ, "REGISTERED"); + + this->Validate(u); + } + else + { + /* Reset +r and re-send account (even though it really should be set at this point) */ + IRCD->SendLogin(u, na); + if (!Config->GetModule("nickserv")->Get("nonicknameownership") && na->GetAccount() == u->Account() && !na->GetAccount()->HasFieldS("UNCONFIRMED")) + u->SetMode(NickServ, "REGISTERED"); + Log(u, "", NickServ) << u->GetMask() << " automatically identified for group " << u->Account()->GetDisplay(); + } + + if (!u->nick.equals_ci(oldnick) && old_na) + OnCancel(u, old_na); + } + + void OnUserModeSet(const MessageSource &setter, User *u, const Anope::string &mname) override + { + if (u->server->IsSynced() && mname == "REGISTERED" && !u->IsIdentified(true)) + u->RemoveMode(NickServ, mname); + } + + EventReturn OnPreHelp(CommandSource &source, const std::vector ¶ms) override + { + if (!params.empty() || source.c || source.service != *NickServ) + return EVENT_CONTINUE; + if (!Config->GetModule("nickserv")->Get("nonicknameownership")) + source.Reply(_("\002%s\002 allows you to register a nickname and\n" + "prevent others from using it. The following\n" + "commands allow for registration and maintenance of\n" + "nicknames; to use them, type \002%s%s \037command\037\002.\n" + "For more information on a specific command, type\n" + "\002%s%s %s \037command\037\002.\n"), NickServ->nick.c_str(), Config->StrictPrivmsg.c_str(), NickServ->nick.c_str(), Config->StrictPrivmsg.c_str(), NickServ->nick.c_str(), source.command.c_str()); + else + source.Reply(_("\002%s\002 allows you to register an account.\n" + "The following commands allow for registration and maintenance of\n" + "accounts; to use them, type \002%s%s \037command\037\002.\n" + "For more information on a specific command, type\n" + "\002%s%s %s \037command\037\002.\n"), NickServ->nick.c_str(), Config->StrictPrivmsg.c_str(), NickServ->nick.c_str(), Config->StrictPrivmsg.c_str(), NickServ->nick.c_str(), source.command.c_str()); + return EVENT_CONTINUE; + } + + void OnPostHelp(CommandSource &source, const std::vector ¶ms) override + { + if (!params.empty() || source.c || source.service != *NickServ) + return; + if (source.IsServicesOper()) + source.Reply(_(" \n" + "Services Operators can also drop any nickname without needing\n" + "to identify for the nick, and may view the access list for\n" + "any nickname.")); + time_t nickserv_expire = Config->GetModule(this)->Get("expire", "21d"); + if (nickserv_expire >= 86400) + source.Reply(_(" \n" + "Accounts that are not used anymore are subject to\n" + "the automatic expiration, i.e. they will be deleted\n" + "after %d days if not used."), nickserv_expire / 86400); + source.Reply(_(" \n" + "\002NOTICE:\002 This service is intended to provide a way for\n" + "IRC users to ensure their identity is not compromised.\n" + "It is \002NOT\002 intended to facilitate \"stealing\" of\n" + "nicknames or other malicious actions. Abuse of %s\n" + "will result in, at minimum, loss of the abused\n" + "nickname(s)."), NickServ->nick.c_str()); + } + + void OnNickCoreCreate(NickServ::Account *nc) override + { + /* Set default flags */ + for (unsigned i = 0; i < defaults.size(); ++i) + nc->SetS(defaults[i].upper(), true); + } + + void OnUserQuit(User *u, const Anope::string &msg) override + { + if (u->server && !u->server->GetQuitReason().empty() && Config->GetModule(this)->Get("hidenetsplitquit")) + return; + + /* Update last quit and last seen for the user */ + NickServ::Nick *na = NickServ::FindNick(u->nick); + if (na && !na->GetAccount()->HasFieldS("NS_SUSPENDED") && (u->IsRecognized() || u->IsIdentified(true))) + { + na->SetLastSeen(Anope::CurTime); + na->SetLastQuit(msg); + } + } + + void OnExpireTick() override + { + if (Anope::NoExpire || Anope::ReadOnly) + return; + + time_t nickserv_expire = Config->GetModule(this)->Get("expire", "21d"); + + for (NickServ::Nick *na : nick_type.List()) + { + User *u = User::Find(na->GetNick()); + if (u && (u->IsIdentified(true) || u->IsRecognized())) + na->SetLastSeen(Anope::CurTime); + + bool expire = false; + + if (nickserv_expire && Anope::CurTime - na->GetLastSeen() >= nickserv_expire) + expire = true; + + this->onprenickexpire(&NickServ::Event::PreNickExpire::OnPreNickExpire, na, expire); + + if (expire) + { + Log(LOG_NORMAL, "nickserv/expire", NickServ) << "Expiring nickname " << na->GetNick() << " (group: " << na->GetAccount()->GetDisplay() << ") (e-mail: " << (na->GetAccount()->GetEmail().empty() ? "none" : na->GetAccount()->GetEmail()) << ")"; + this->onnickexpire(&NickServ::Event::NickExpire::OnNickExpire, na); + delete na; + } + } + } + + void OnNickInfo(CommandSource &source, NickServ::Nick *na, InfoFormatter &info, bool show_hidden) override + { + if (!na->GetAccount()->HasFieldS("UNCONFIRMED")) + { + time_t nickserv_expire = Config->GetModule(this)->Get("expire", "21d"); + if (!na->HasFieldS("NS_NO_EXPIRE") && nickserv_expire && !Anope::NoExpire && (source.HasPriv("nickserv/auspex") || na->GetLastSeen() != Anope::CurTime)) + info[_("Expires")] = Anope::strftime(na->GetLastSeen() + nickserv_expire, source.GetAccount()); + } + else + { + time_t unconfirmed_expire = Config->GetModule(this)->Get("unconfirmedexpire", "1d"); + info[_("Expires")] = Anope::strftime(na->GetTimeRegistered() + unconfirmed_expire, source.GetAccount()); + } + } + + void OnModuleUnload(User *u, Module *m) override + { + for (std::set::iterator it = identifyrequests.begin(), it_end = identifyrequests.end(); it != it_end;) + { + NickServ::IdentifyRequest *ir = *it; + ++it; + + ir->Release(m); +#if 0 + ir->holds.erase(m); + if (ir->holds.empty() && ir->dispatched) + { + if (!ir->success) + ir->OnFail(); + delete ir; + continue; + } + + if (ir->GetOwner() == m) + { + if (!ir->success) + ir->OnFail(); + delete ir; + } +#endif + } + } +}; + +MODULE_INIT(NickServCore) + diff --git a/modules/nickserv/main/nicktype.cpp b/modules/nickserv/main/nicktype.cpp new file mode 100644 index 000000000..9607aaa2f --- /dev/null +++ b/modules/nickserv/main/nicktype.cpp @@ -0,0 +1,45 @@ +#include "module.h" +#include "nicktype.h" + +NickType::NickType(Module *me) : Serialize::Type(me, "NickAlias") + , nick(this, "nick") + , last_quit(this, "last_quit") + , last_realname(this, "last_realname") + , last_usermask(this, "last_usermask") + , last_realhost(this, "last_realhost") + , time_registered(this, "time_registered") + , last_seen(this, "last_seen") + , vhost_ident(this, "vhost_ident") + , vhost_host(this, "vhost_host") + , vhost_creator(this, "vhost_creator") + , vhost_created(this, "vhost_created") + , nc(this, "nc") +{ + +} + +void NickType::Nick::SetField(NickImpl *na, const Anope::string &value) +{ + /* Remove us from the aliases list */ + NickServ::nickalias_map &map = NickServ::service->GetNickMap(); + map.erase(GetField(na)); + + Serialize::Field::SetField(na, value); + + map[value] = na; +} + +NickServ::Nick *NickType::FindNick(const Anope::string &n) +{ + Serialize::ID id; + EventReturn result = Event::OnSerialize(&Event::SerializeEvents::OnSerializeFind, this, &this->nick, n, id); + if (result == EVENT_ALLOW) + return RequireID(id); + + NickServ::nickalias_map &map = NickServ::service->GetNickMap(); + auto it = map.find(n); + if (it != map.end()) + return it->second; + return nullptr; +} + diff --git a/modules/nickserv/main/nicktype.h b/modules/nickserv/main/nicktype.h new file mode 100644 index 000000000..d205845e9 --- /dev/null +++ b/modules/nickserv/main/nicktype.h @@ -0,0 +1,32 @@ +#include "nick.h" + +class NickType : public Serialize::Type +{ + public: + struct Nick : Serialize::Field + { + using Serialize::Field::Field; + + void SetField(NickImpl *s, const Anope::string &value) override; + } nick; + Serialize::Field last_quit; + Serialize::Field last_realname; + /* Last usermask this nick was seen on, eg user@host */ + Serialize::Field last_usermask; + /* Last uncloaked usermask, requires nickserv/auspex to see */ + Serialize::Field last_realhost; + Serialize::Field time_registered; + Serialize::Field last_seen; + + Serialize::Field vhost_ident; + Serialize::Field vhost_host; + Serialize::Field vhost_creator; + Serialize::Field vhost_created; + + /* Account this nick is tied to. Multiple nicks can be tied to a single account. */ + Serialize::ObjectField nc; + + NickType(Module *); + + NickServ::Nick *FindNick(const Anope::string &nick); +}; -- cgit