static void rsend_notify(CommandSource &source, MemoServ::MemoInfo *mi, MemoServ::Memo *m, const Anope::string &targ)
{
/* Only send receipt if memos are allowed */
if (MemoServ::service && !Anope::ReadOnly)
{
/* Get nick alias for sender */
NickServ::Nick *na = NickServ::FindNick(m->GetSender());
if (!na)
return;
/* Get nick core for sender */
NickServ::Account *nc = na->GetAccount();
if (!nc)
return;
/* Text of the memo varies if the recipient was a
nick or channel */
Anope::string text = Anope::printf(Language::Translate(na->GetAccount(), _("\002[auto-memo]\002 The memo you sent to \002%s\002 has been viewed.")), targ.c_str());
/* Send notification */
MemoServ::service->Send(source.GetNick(), m->GetSender(), text, true);
/* Notify recipient of the memo that a notification has
been sent to the sender */
source.Reply(_("A notification memo has been sent to \002{0}\002 informing him/her you have read his/her memo."), nc->GetDisplay());
}
/* Remove receipt flag from the original memo */
m->SetReceipt(false);
}
void User::ChangeNick(const Anope::string &newnick, time_t ts)
{
/* Sanity check to make sure we don't segfault */
if (newnick.empty())
throw CoreException("User::ChangeNick() got a bad argument");
this->super_admin = false;
Log(this, "nick") << "(" << this->realname << ") changed nick to " << newnick;
Anope::string old = this->nick;
this->timestamp = ts;
if (this->nick.equals_ci(newnick))
this->nick = newnick;
else
{
NickServ::Nick *old_na = NickServ::FindNick(this->nick);
if (old_na && (this->IsIdentified(true) || this->IsRecognized()))
old_na->SetLastSeen(Anope::CurTime);
UserListByNick.erase(this->nick);
this->nick = newnick;
User* &other = UserListByNick[this->nick];
if (other)
{
CollideKill(this, "Nick collision");
CollideKill(other, "Nick collision");
return;
}
other = this;
on_access = false;
if (NickServ::service)
{
NickServ::Nick *na = NickServ::service->FindNick(this->nick);
if (na)
{
on_access = na->GetAccount()->IsOnAccess(this);
if (na->GetAccount() == this->Account())
{
na->SetLastSeen(Anope::CurTime);
this->UpdateHost();
}
}
}
}
EventManager::Get()->Dispatch(&Event::UserNickChange::OnUserNickChange, this, old);
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &nick = params[0];
const Anope::string &pass = params.size() > 1 ? params[1] : "";
User *user = User::Find(nick, true);
if (user && source.GetUser() == user)
{
source.Reply(_("You can't %s yourself!"), source.command.lower().c_str());
return;
}
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
if (na->GetAccount()->HasFieldS("NS_SUSPENDED"))
{
source.Reply(_("\002{0}\002 is suspended."), na->GetNick());
return;
}
bool ok = false;
if (source.GetAccount() == na->GetAccount())
ok = true;
else if (!na->GetAccount()->HasFieldS("NS_SECURE") && source.GetUser() && na->GetAccount()->IsOnAccess(source.GetUser()))
ok = true;
if (certservice && source.GetUser() && certservice->Matches(source.GetUser(), na->GetAccount()))
ok = true;
if (ok == false && !pass.empty())
{
NickServ::IdentifyRequest *req = NickServ::service->CreateIdentifyRequest(new NSRecoverRequestListener(source, this, na->GetNick(), pass), owner, na->GetNick(), pass);
Event::OnCheckAuthentication(&Event::CheckAuthentication::OnCheckAuthentication, source.GetUser(), req);
req->Dispatch();
}
else
{
NSRecoverRequestListener req(source, this, na->GetNick(), pass);
if (ok)
req.OnSuccess(nullptr);
else
req.OnFail(nullptr);
}
}
void OnUserLogin(User *u) override
{
if (!IRCD->CanSetVHost)
return;
NickServ::Nick *na = NickServ::FindNick(u->nick);
if (!na || na->GetAccount() != u->Account() || !na->HasVhost())
na = NickServ::FindNick(u->Account()->GetDisplay());
if (!na || !na->HasVhost())
return;
if (u->vhost.empty() || !u->vhost.equals_cs(na->GetVhostHost()) || (!na->GetVhostIdent().empty() && !u->GetVIdent().equals_cs(na->GetVhostIdent())))
{
IRCD->SendVhost(u, na->GetVhostIdent(), na->GetVhostHost());
u->vhost = na->GetVhostHost();
u->UpdateHost();
if (IRCD->CanSetVIdent && !na->GetVhostIdent().empty())
u->SetVIdent(na->GetVhostIdent());
if (HostServ)
{
if (!na->GetVhostIdent().empty())
u->SendMessage(*HostServ, _("Your vhost of \002%s\002@\002%s\002 is now activated."), na->GetVhostIdent().c_str(), na->GetVhostHost().c_str());
else
u->SendMessage(*HostServ, _("Your vhost of \002%s\002 is now activated."), na->GetVhostHost().c_str());
}
}
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &nick = params[0];
if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode. Any changes made may not persist."));
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
NSSuspendInfo *si = na->GetAccount()->GetRef<NSSuspendInfo *>();
if (!si)
{
source.Reply(_("\002{0}\002 is not suspended."), na->GetNick());
return;
}
Log(LOG_ADMIN, source, this) << "for " << na->GetNick() << " which was suspended by " << (!si->GetBy().empty() ? si->GetBy() : "(none)") << " for: " << (!si->GetReason().empty() ? si->GetReason() : "No reason");
si->Delete();
source.Reply(_("\002{0}\002 is now released."), na->GetNick());
EventManager::Get()->Dispatch(&Event::NickUnsuspend::OnNickUnsuspend, na);
}
void OnSuccess(NickServ::IdentifyRequest *) override
{
if (!source.GetUser() || source.GetUser()->nick != nick || !target)
return;
User *u = source.GetUser();
NickServ::Nick *na = NickServ::FindNick(nick);
/* If the nick is already registered, drop it. */
if (na)
{
EventManager::Get()->Dispatch(&Event::ChangeCoreDisplay::OnChangeCoreDisplay, na->GetAccount(), u->nick);
delete na;
}
na = Serialize::New<NickServ::Nick *>();
na->SetNick(nick);
na->SetAccount(target->GetAccount());
na->SetLastUsermask(u->GetIdent() + "@" + u->GetDisplayedHost());
na->SetLastRealname(u->realname);
na->SetLastSeen(Anope::CurTime);
na->SetTimeRegistered(Anope::CurTime);
u->Login(target->GetAccount());
EventManager::Get()->Dispatch(&Event::NickGroup::OnNickGroup, u, target);
Log(LOG_COMMAND, source, cmd) << "to make " << nick << " join group of " << target->GetNick() << " (" << target->GetAccount()->GetDisplay() << ") (email: " << (!target->GetAccount()->GetEmail().empty() ? target->GetAccount()->GetEmail() : "none") << ")";
source.Reply(_("You are now in the group of \002{0}\002."), target->GetNick());
u->lastnickreg = Anope::CurTime;
}
void OnCheckAuthentication(User *, NickServ::IdentifyRequest *req) override
{
NickServ::Nick *na = NickServ::FindNick(req->GetAccount());
if (na == NULL)
return;
NickServ::Account *nc = na->GetAccount();
size_t pos = nc->GetPassword().find(':');
if (pos == Anope::string::npos)
return;
Anope::string hash_method(nc->GetPassword().begin(), nc->GetPassword().begin() + pos);
if (!hash_method.equals_cs("oldmd5"))
return;
Anope::string buf;
this->OnEncrypt(req->GetPassword(), buf);
if (nc->GetPassword().equals_cs(buf))
{
/* if we are NOT the first module in the list,
* we want to re-encrypt the pass with the new encryption
*/
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
{
Anope::string p;
Anope::Encrypt(req->GetPassword(), p);
nc->SetPassword(p);
}
req->Success(this);
}
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
User *u = source.GetUser();
Anope::string nick = !params.empty() ? params[0] : "";
NickServ::Nick *na = NickServ::FindNick(!nick.empty() ? nick : u->nick);
if (u->Account()->GetRefs<NickServ::Nick *>().size() == 1)
{
source.Reply(_("Your nickname is not grouped to anything, so you can't ungroup it."));
return;
}
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), !nick.empty() ? nick : u->nick);
return;
}
if (na->GetAccount() != u->Account())
{
source.Reply(_("\002{0}\002 is not in your group."), na->GetNick());
return;
}
NickServ::Account *oldcore = na->GetAccount();
if (na->GetNick().equals_ci(oldcore->GetDisplay()))
oldcore->SetDisplay(oldcore->GetRef<NickServ::Nick *>());
NickServ::Account *nc = Serialize::New<NickServ::Account *>();
nc->SetDisplay(na->GetNick());
na->SetAccount(nc);
nc->SetPassword(oldcore->GetPassword());
if (!oldcore->GetEmail().empty())
nc->SetEmail(oldcore->GetEmail());
nc->SetLanguage(oldcore->GetLanguage());
source.Reply(_("\002{0}\002 has been ungrouped from \002{1}\002."), na->GetNick(), oldcore->GetDisplay());
User *user = User::Find(na->GetNick());
if (user)
/* The user on the nick who was ungrouped may be identified to the old group, set -r */
user->RemoveMode(source.service, "REGISTERED");
}
EventReturn OnPreCommand(CommandSource &source, Command *command, std::vector<Anope::string> ¶ms) override
{
if (command->name == "nickserv/confirm" && params.size() > 1)
{
if (Anope::ReadOnly)
{
source.Reply(_("Services are in read-only mode."));
return EVENT_STOP;
}
NickServ::Nick *na = NickServ::FindNick(params[0]);
ResetInfo *ri = na ? reset.Get(na->GetAccount()) : NULL;
if (na && ri)
{
NickServ::Account *nc = na->GetAccount();
const Anope::string &passcode = params[1];
if (ri->time < Anope::CurTime - 3600)
{
reset.Unset(nc);
source.Reply(_("Your password reset request has expired."));
}
else if (passcode.equals_cs(ri->code))
{
reset.Unset(nc);
nc->UnsetS<bool>("UNCONFIRMED");
Log(LOG_COMMAND, source, &commandnsresetpass) << "confirmed RESETPASS to forcefully identify as " << na->GetNick();
if (source.GetUser())
{
source.GetUser()->Identify(na);
source.Reply(_("You are now identified for \002{0}\002. Change your password now."), na->GetAccount()->GetDisplay());
}
}
else
return EVENT_CONTINUE;
return EVENT_STOP;
}
}
return EVENT_CONTINUE;
}
bool User::IsIdentified(bool check_nick) const
{
if (check_nick && this->nc)
{
NickServ::Nick *na = NickServ::FindNick(nick);
return na && na->GetAccount() == *this->nc;
}
return this->nc ? true : false;
}
bool User::IsRecognized(bool check_secure) const
{
if (check_secure && on_access)
{
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na || na->GetAccount()->HasFieldS("NS_SECURE"))
return false;
}
return on_access;
}
MemoServ::MemoInfo *GetMemoInfo(const Anope::string &target, bool &is_registered, bool &ischan, bool create) override
{
if (!target.empty() && target[0] == '#')
{
ischan = true;
ChanServ::Channel *ci = ChanServ::Find(target);
if (ci != NULL)
{
is_registered = true;
if (create && !ci->GetMemos())
{
MemoServ::MemoInfo *mi = Serialize::New<MemoServ::MemoInfo *>();
mi->SetOwner(ci);
}
return ci->GetMemos();
}
else
is_registered = false;
}
else
{
ischan = false;
NickServ::Nick *na = NickServ::FindNick(target);
if (na != NULL)
{
is_registered = true;
if (create && !na->GetAccount()->GetMemos())
{
MemoServ::MemoInfo *mi = Serialize::New<MemoServ::MemoInfo *>();
mi->SetOwner(na->GetAccount());
}
return na->GetAccount()->GetMemos();
}
else
is_registered = false;
}
return NULL;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &cmd = params[0];
Anope::string nick, mask;
if (cmd.equals_ci("LIST"))
nick = params.size() > 1 ? params[1] : "";
else
{
nick = params.size() == 3 ? params[1] : "";
mask = params.size() > 1 ? params[params.size() - 1] : "";
}
NickServ::Account *nc;
if (!nick.empty() && source.HasPriv("nickserv/access"))
{
NickServ::Nick *na = NickServ::FindNick(nick);
if (na == NULL)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
if (Config->GetModule("nickserv")->Get<bool>("secureadmins", "yes") && source.GetAccount() != na->GetAccount() && na->GetAccount()->IsServicesOper() && !cmd.equals_ci("LIST"))
{
source.Reply(_("You may view but not modify the access list of other Services Operators."));
return;
}
nc = na->GetAccount();
}
else
nc = source.nc;
if (!mask.empty() && (mask.find('@') == Anope::string::npos || mask.find('!') != Anope::string::npos))
{
source.Reply(_("Mask must be in the form \037user\037@\037host\037."));
source.Reply(_("\002%s%s HELP %s\002 for more information."), Config->StrictPrivmsg, source.service->nick, source.command); // XXX
}
else if (cmd.equals_ci("LIST"))
return this->DoList(source, nc, mask);
else if (nc->HasFieldS("NS_SUSPENDED"))
source.Reply(_("\002{0}\002 is suspended."), nc->GetDisplay());
else if (cmd.equals_ci("ADD"))
return this->DoAdd(source, nc, mask);
else if (cmd.equals_ci("DEL"))
return this->DoDel(source, nc, mask);
else
this->OnSyntaxError(source, "");
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &nick = !params.empty() ? params[0] : "";
NickServ::Account *nc;
if (!nick.empty() && source.IsServicesOper())
{
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
nc = na->GetAccount();
}
else
nc = source.GetAccount();
ListFormatter list(source.GetAccount());
list.AddColumn(_("Nick")).AddColumn(_("Expires"));
time_t nickserv_expire = Config->GetModule("nickserv")->Get<time_t>("expire", "21d"),
unconfirmed_expire = Config->GetModule("nickserv")->Get<time_t>("unconfirmedexpire", "1d");
for (NickServ::Nick *na2 : nc->GetRefs<NickServ::Nick *>())
{
Anope::string expires;
if (na2->HasFieldS("NS_NO_EXPIRE"))
expires = _("Does not expire");
else if (!nickserv_expire || Anope::NoExpire)
;
else if (na2->GetAccount()->HasFieldS("UNCONFIRMED") && unconfirmed_expire)
expires = Anope::strftime(na2->GetTimeRegistered() + unconfirmed_expire, source.GetAccount());
else
expires = Anope::strftime(na2->GetLastSeen() + nickserv_expire, source.GetAccount());
ListFormatter::ListEntry entry;
entry["Nick"] = na2->GetNick();
entry["Expires"] = expires;
list.AddEntry(entry);
}
source.Reply(nc != source.GetAccount() ? _("List of nicknames in the group of \002%s\002:") : _("List of nicknames in your group:"), nc->GetDisplay().c_str());
std::vector<Anope::string> replies;
list.Process(replies);
for (unsigned i = 0; i < replies.size(); ++i)
source.Reply(replies[i]);
source.Reply(_("%d nickname(s) in the group."), replies.size());
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
User *u = source.GetUser();
NickServ::Nick *na = NickServ::FindNick(u->nick);
if (!na || !na->HasVhost() || na->GetAccount() != source.GetAccount())
{
source.Reply(_("There is no vhost assigned to this nickname."));
return;
}
u->vhost.clear();
IRCD->SendVhostDel(u);
Log(LOG_COMMAND, source, this) << "to disable their vhost";
source.Reply(_("Your vhost was removed and the normal cloaking restored."));
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &cmd = params[0];
Anope::string nick, certfp;
if (cmd.equals_ci("LIST"))
nick = params.size() > 1 ? params[1] : "";
else
{
nick = params.size() == 3 ? params[1] : "";
certfp = params.size() > 1 ? params[params.size() - 1] : "";
}
NickServ::Account *nc;
if (!nick.empty() && source.HasPriv("nickserv/access"))
{
NickServ::Nick *na = NickServ::FindNick(nick);
if (na == NULL)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
if (Config->GetModule("nickserv")->Get<bool>("secureadmins", "yes") && source.GetAccount() != na->GetAccount() && na->GetAccount()->IsServicesOper() && !cmd.equals_ci("LIST"))
{
source.Reply(_("You may view, but not modify, the certificate list of other Services Operators."));
return;
}
nc = na->GetAccount();
}
else
nc = source.nc;
if (cmd.equals_ci("LIST"))
return this->DoList(source, nc);
else if (nc->HasFieldS("NS_SUSPENDED"))
source.Reply(_("\002{0}\002 is suspended."), nc->GetDisplay());
else if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode."));
else if (cmd.equals_ci("ADD"))
return this->DoAdd(source, nc, certfp);
else if (cmd.equals_ci("DEL"))
return this->DoDel(source, nc, certfp);
else
this->OnSyntaxError(source, "");
}
/* :0MC UID Steve 1 1350157102 +oi ~steve resolved.host 10.0.0.1 0MCAAAAAB Steve :Mining all the time */
void hybrid::UID::Run(MessageSource &source, const std::vector<Anope::string> ¶ms)
{
Anope::string ip = params[6];
if (ip == "0") /* Can be 0 for spoofed clients */
ip.clear();
NickServ::Nick *na = NULL;
if (params[8] != "0" && params[8] != "*")
na = NickServ::FindNick(params[8]);
/* Source is always the server */
User::OnIntroduce(params[0], params[4], params[5], "",
ip, source.GetServer(),
params[9], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : 0,
params[3], params[7], na ? na->GetAccount() : NULL);
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &cmd = params[0];
Anope::string nick, param, param2;
if (cmd.equals_ci("LIST"))
nick = params.size() > 1 ? params[1] : "";
else
nick = (params.size() > 2 && IRCD->IsChannelValid(params[2])) ? params[1] : "";
NickServ::Account *nc;
if (!nick.empty() && !source.HasCommand("nickserv/ajoin"))
{
NickServ::Nick *na = NickServ::FindNick(nick);
if (na == NULL)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
nc = na->GetAccount();
param = params.size() > 2 ? params[2] : "";
param2 = params.size() > 3 ? params[3] : "";
}
else
{
nc = source.nc;
param = params.size() > 1 ? params[1] : "";
param2 = params.size() > 2 ? params[2] : "";
}
if (cmd.equals_ci("LIST"))
return this->DoList(source, nc);
else if (nc->HasFieldS("NS_SUSPENDED"))
source.Reply(_("\002{0}\002 isn't registered."), nc->GetDisplay());
else if (param.empty())
this->OnSyntaxError(source, "");
else if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode."));
else if (cmd.equals_ci("ADD"))
return this->DoAdd(source, nc, param, param2);
else if (cmd.equals_ci("DEL"))
return this->DoDel(source, nc, param);
else
this->OnSyntaxError(source, "");
}
void User::UpdateHost()
{
if (this->host.empty())
return;
//XXX event
NickServ::Nick *na = NickServ::FindNick(this->nick);
on_access = false;
if (na)
on_access = na->GetAccount()->IsOnAccess(this);
if (na && (this->IsIdentified(true) || this->IsRecognized()))
{
Anope::string last_usermask = this->GetIdent() + "@" + this->GetDisplayedHost();
Anope::string last_realhost = this->GetIdent() + "@" + this->host;
na->SetLastUsermask(last_usermask);
na->SetLastRealhost(last_realhost);
}
}
void OnFingerprint(User *u) override
{
ServiceBot *NickServ = Config->GetClient("NickServ");
if (!NickServ || u->IsIdentified())
return;
NickServ::Account *nc = cs.FindAccountFromCert(u->fingerprint);
if (!nc || nc->HasFieldS("NS_SUSPENDED"))
return;
NickServ::Nick *na = NickServ::FindNick(u->nick);
if (na && na->GetAccount() == nc)
u->Identify(na);
else
u->Login(nc);
u->SendMessage(NickServ, _("SSL certificate fingerprint accepted, you are now identified to \002%s\002."), nc->GetDisplay().c_str());
Log(NickServ) << u->GetMask() << " automatically identified for account " << nc->GetDisplay() << " via SSL certificate fingerprint";
}
void DoCommand(XMLRPCServiceInterface *iface, HTTPClient *client, XMLRPCRequest &request)
{
Anope::string service = request.data.size() > 0 ? request.data[0] : "";
Anope::string user = request.data.size() > 1 ? request.data[1] : "";
Anope::string command = request.data.size() > 2 ? request.data[2] : "";
if (service.empty() || user.empty() || command.empty())
request.reply("error", "Invalid parameters");
else
{
ServiceBot *bi = ServiceBot::Find(service, true);
if (!bi)
request.reply("error", "Invalid service");
else
{
request.reply("result", "Success");
NickServ::Nick *na = NickServ::FindNick(user);
Anope::string out;
struct XMLRPCommandReply : CommandReply
{
Anope::string &str;
XMLRPCommandReply(Anope::string &s) : str(s) { }
void SendMessage(const MessageSource &, const Anope::string &msg) override
{
str += msg + "\n";
};
}
reply(out);
CommandSource source(user, NULL, na ? na->GetAccount() : NULL, &reply, bi);
Command::Run(source, command);
if (!out.empty())
request.reply("return", iface->Sanitize(out));
}
}
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
NickServ::Nick *na = NickServ::FindNick(params[0]);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), params[0]);
return;
}
if (!na->GetAccount()->GetEmail().equals_ci(params[1]))
{
source.Reply(_("Incorrect email address."));
return;
}
if (SendResetEmail(source.GetUser(), na, source.service))
{
Log(LOG_COMMAND, source, this) << "for " << na->GetNick() << " (group: " << na->GetAccount()->GetDisplay() << ")";
source.Reply(_("Password reset email for \002{0}\002 has been sent."), na->GetNick());
}
}
ChanServ::AccessGroup ChannelImpl::AccessFor(const User *u, bool updateLastUsed)
{
ChanServ::AccessGroup group;
if (u == NULL)
return group;
NickServ::Account *nc = u->Account();
if (nc == NULL && !nc->IsSecure() && u->IsRecognized())
{
NickServ::Nick *na = NickServ::FindNick(u->nick);
if (na != NULL)
nc = na->GetAccount();
}
group.super_admin = u->super_admin;
group.founder = IsFounder(u);
group.ci = this;
group.nc = nc;
for (unsigned i = 0, end = this->GetAccessCount(); i < end; ++i)
{
ChanServ::ChanAccess *a = this->GetAccess(i);
if (a->Matches(u, u->Account()))
group.push_back(a);
}
if (group.founder || !group.empty())
{
if (updateLastUsed)
this->SetLastUsed(Anope::CurTime);
for (unsigned i = 0; i < group.size(); ++i)
group[i]->SetLastSeen(Anope::CurTime);
}
return group;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
if (Anope::ReadOnly)
{
source.Reply(_("Services are in read-only mode."));
return;
}
User *u = source.GetUser();
NickServ::Nick *na = NickServ::FindNick(source.GetNick());
if (!na || na->GetAccount() != source.GetAccount())
{
source.Reply(_("Access denied.")); //XXX with nonickownership this should be allowed.
return;
}
if (source.GetAccount()->HasFieldS("UNCONFIRMED"))
{
source.Reply(_("You must confirm your account before you may request a vhost."));
return;
}
Anope::string rawhostmask = params[0];
Anope::string user, host;
size_t a = rawhostmask.find('@');
if (a == Anope::string::npos)
host = rawhostmask;
else
{
user = rawhostmask.substr(0, a);
host = rawhostmask.substr(a + 1);
}
if (host.empty())
{
this->OnSyntaxError(source, "");
return;
}
if (!user.empty())
{
if (user.length() > Config->GetBlock("networkinfo")->Get<unsigned>("userlen"))
{
source.Reply(_("The username \002{0}\002 is too long, please use a username shorter than %d characters."), Config->GetBlock("networkinfo")->Get<unsigned>("userlen"));
return;
}
if (!IRCD->CanSetVIdent)
{
source.Reply(_("Vhosts may not contain a username."));
return;
}
if (!IRCD->IsIdentValid(user))
{
source.Reply(_("The requested username is not valid."));
return;
}
}
if (host.length() > Config->GetBlock("networkinfo")->Get<unsigned>("hostlen"))
{
source.Reply(_("The requested vhost is too long, please use a hostname no longer than {0} characters."), Config->GetBlock("networkinfo")->Get<unsigned>("hostlen"));
return;
}
if (!IRCD->IsHostValid(host))
{
source.Reply(_("The requested hostname is not valid."));
return;
}
time_t send_delay = Config->GetModule("memoserv")->Get<time_t>("senddelay");
if (Config->GetModule(this->GetOwner())->Get<bool>("memooper") && send_delay > 0 && u && u->lastmemosend + send_delay > Anope::CurTime)
{
source.Reply(_("Please wait %d seconds before requesting a new vHost."), send_delay);
u->lastmemosend = Anope::CurTime;
return;
}
HostRequest *req = Serialize::New<HostRequest *>();
req->SetNick(na);
req->SetIdent(user);
req->SetHost(host);
req->SetTime(Anope::CurTime);
source.Reply(_("Your vhost has been requested."));
this->SendMemos(source, user, host);
Log(LOG_COMMAND, source, this) << "to request new vhost " << (!user.empty() ? user + "@" : "") << host;
}
void OnResult(const LDAPResult &r) override
{
if (!ii->lprov)
return;
switch (r.type)
{
case QUERY_SEARCH:
{
if (!r.empty())
{
try
{
const LDAPAttributes &attr = r.get(0);
ii->dn = attr.get("dn");
Log(LOG_DEBUG) << "m_ldap_authenticationn: binding as " << ii->dn;
ii->lprov->Bind(new IdentifyInterface(this->owner, ii), ii->dn, ii->req->GetPassword());
ii = NULL;
}
catch (const LDAPException &ex)
{
Log(this->owner) << "Error binding after search: " << ex.GetReason();
}
}
break;
}
case QUERY_BIND:
{
if (ii->admin_bind)
{
Anope::string sf = search_filter.replace_all_cs("%account", ii->req->GetAccount()).replace_all_cs("%object_class", object_class);
try
{
Log(LOG_DEBUG) << "m_ldap_authentication: searching for " << sf;
ii->lprov->Search(new IdentifyInterface(this->owner, ii), basedn, sf);
ii->admin_bind = false;
ii = NULL;
}
catch (const LDAPException &ex)
{
Log(this->owner) << "Unable to search for " << sf << ": " << ex.GetReason();
}
}
else
{
NickServ::Nick *na = NickServ::FindNick(ii->req->GetAccount());
if (na == NULL)
{
na = new NickServ::Nick(ii->req->GetAccount(), new NickServ::Account(ii->req->GetAccount()));
na->SetLastRealname(ii->user ? ii->user->realname : ii->req->GetAccount());
NickServ::Event::OnNickRegister(&NickServ::Event::NickRegister::OnNickRegister, ii->user, na, ii->req->GetPassword());;
ServiceBot *NickServ = Config->GetClient("NickServ");
if (ii->user && NickServ)
ii->user->SendMessage(NickServ, _("Your account \002%s\002 has been successfully created."), na->GetNick().c_str());
}
// encrypt and store the password in the nickcore
Anope::Encrypt(ii->req->GetPassword(), na->GetAccount()->pass);
na->GetAccount()->Extend<Anope::string>("m_ldap_authentication_dn", ii->dn);
ii->req->Success(me);
}
break;
}
default:
break;
}
}
void DoLimit(CommandSource &source, const std::vector<Anope::string> ¶ms, MemoServ::MemoInfo *mi)
{
Anope::string p1 = params[1];
Anope::string p2 = params.size() > 2 ? params[2] : "";
Anope::string p3 = params.size() > 3 ? params[3] : "";
Anope::string user, chan;
int16_t limit;
NickServ::Account *nc = source.nc;
ChanServ::Channel *ci = NULL;
bool is_servadmin = source.HasPriv("memoserv/set-limit");
if (p1[0] == '#')
{
chan = p1;
p1 = p2;
p2 = p3;
p3 = params.size() > 4 ? params[4] : "";
ci = ChanServ::Find(chan);
if (!ci)
{
source.Reply(_("Channel \002{0}\002 isn't registered."), chan);
return;
}
if (!is_servadmin && !source.AccessFor(ci).HasPriv("MEMO"))
{
source.Reply(_("Access denied. You do not have privilege \002{0}\002 on \002{1}\002."), "MEMO", ci->GetName());
return;
}
mi = ci->GetMemos();
}
if (is_servadmin)
{
if (!p2.empty() && !p2.equals_ci("HARD") && chan.empty())
{
NickServ::Nick *na;
if (!(na = NickServ::FindNick(p1)))
{
source.Reply(_("\002{0}\002 isn't registered."), p1);
return;
}
user = p1;
mi = na->GetAccount()->GetMemos();
nc = na->GetAccount();
p1 = p2;
p2 = p3;
}
else if (p1.empty() || (!p1.is_pos_number_only() && !p1.equals_ci("NONE")) || (!p2.empty() && !p2.equals_ci("HARD")))
{
this->OnSyntaxError(source, "");
return;
}
if (!chan.empty())
{
if (!p2.empty())
ci->SetS<bool>("MEMO_HARDMAX", true);
else
ci->UnsetS<bool>("MEMO_HARDMAX");
}
else
{
if (!p2.empty())
nc->SetS<bool>("MEMO_HARDMAX", true);
else
nc->UnsetS<bool>("MEMO_HARDMAX");
}
limit = -1;
try
{
limit = convertTo<int16_t>(p1);
}
catch (const ConvertException &) { }
}
else
{
if (p1.empty() || !p2.empty() || !isdigit(p1[0]))
{
this->OnSyntaxError(source, "");
return;
}
if (!chan.empty() && ci->HasFieldS("MEMO_HARDMAX"))
{
source.Reply(_("The memo limit for \002{0}\002 may not be changed."), chan);
return;
}
if (chan.empty() && nc->HasFieldS("MEMO_HARDMAX"))
{
source.Reply(_("You are not permitted to change your memo limit."));
return;
}
int max_memos = Config->GetModule("memoserv")->Get<int>("maxmemos");
limit = -1;
try
{
limit = convertTo<int16_t>(p1);
}
catch (const ConvertException &) { }
/* The first character is a digit, but we could still go negative
* from overflow... watch out! */
if (limit < 0 || (max_memos > 0 && limit > max_memos))
{
if (!chan.empty())
source.Reply(_("You cannot set the memo limit for \002{0}\002 higher than \002{1}\002."), chan, max_memos);
else
source.Reply(_("You cannot set your memo limit higher than \002{0}\002."), max_memos);
return;
}
}
mi->SetMemoMax(limit);
if (limit > 0)
{
if (chan.empty() && nc == source.nc)
source.Reply(_("Your memo limit has been set to \002{0}\002."), limit);
else
source.Reply(_("Memo limit for \002{0}\002 set to \002{1}\002."), !chan.empty() ? chan : user, limit);
}
else if (!limit)
{
if (chan.empty() && nc == source.nc)
source.Reply(_("You will no longer be able to receive memos."));
else
source.Reply(_("Memo limit for \002{0}\002 set to \0020\002."), !chan.empty() ? chan : user);
}
else
{
if (chan.empty() && nc == source.nc)
source.Reply(_("Your memo limit has been disabled."));
else
source.Reply(_("Memo limit \002disabled\002 for \002{0}\002."), !chan.empty() ? chan : user);
}
}
// :42X UID Adam 1 1348535644 +aow Adam 192.168.0.5 192.168.0.5 42XAAAAAB 0 192.168.0.5 :Adam
void plexus::UID::Run(MessageSource &source, const std::vector<Anope::string> ¶ms)
{
/* An IP of 0 means the user is spoofed */
Anope::string ip = params[6];
if (ip == "0")
ip.clear();
time_t ts;
try
{
ts = convertTo<time_t>(params[2]);
}
catch (const ConvertException &)
{
ts = Anope::CurTime;
}
NickServ::Nick *na = NULL;
try
{
if (params[8].is_pos_number_only() && convertTo<time_t>(params[8]) == ts)
na = NickServ::FindNick(params[0]);
}
catch (const ConvertException &) { }
if (params[8] != "0" && !na)
na = NickServ::FindNick(params[8]);
User::OnIntroduce(params[0], params[4], params[9], params[5], ip, source.GetServer(), params[10], ts, params[3], params[7], na ? na->GetAccount() : NULL);
}
/*
* :42X EUID DukePyrolator 1 1353240577 +Zi ~jens erft-5d80b00b.pool.mediaWays.net 93.128.176.11 42XAAAAAD * * :jens
* :<SID> EUID <NICK> <HOPS> <TS> +<UMODE> <USERNAME> <VHOST> <IP> <UID> <REALHOST> <ACCOUNT> :<GECOS>
* 0 1 2 3 4 5 6 7 8 9 10
*
* Introduces a user. The hostname field is now always the visible host.
* The realhost field is * if the real host is equal to the visible host.
* The account field is * if the login is not set.
* Note that even if both new fields are *, an EUID command still carries more
* information than a UID command (namely that real host is visible host and the
* user is not logged in with services). Hence a NICK or UID command received
* from a remote server should not be sent in EUID form to other servers.
*/
void Run(MessageSource &source, const std::vector<Anope::string> ¶ms) override
{
NickServ::Nick *na = NULL;
if (params[9] != "*")
na = NickServ::FindNick(params[9]);
User::OnIntroduce(params[0], params[4], params[8], params[5], params[6], source.GetServer(), params[10], params[2].is_pos_number_only() ? convertTo<time_t>(params[2]) : Anope::CurTime, params[3], params[7], na ? na->GetAccount() : NULL);
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
if (!this->fs)
return;
const Anope::string &command = params[0];
const Anope::string &subcommand = params.size() > 1 ? params[1] : "";
ForbidType ftype = FT_SIZE;
if (subcommand.equals_ci("NICK"))
ftype = FT_NICK;
else if (subcommand.equals_ci("CHAN"))
ftype = FT_CHAN;
else if (subcommand.equals_ci("EMAIL"))
ftype = FT_EMAIL;
else if (subcommand.equals_ci("REGISTER"))
ftype = FT_REGISTER;
if (command.equals_ci("ADD") && params.size() > 3 && ftype != FT_SIZE)
{
const Anope::string &expiry = params[2][0] == '+' ? params[2] : "";
const Anope::string &entry = !expiry.empty() ? params[3] : params[2];
Anope::string reason;
if (expiry.empty())
reason = params[3] + " ";
if (params.size() > 4)
reason += params[4];
reason.trim();
if (entry.replace_all_cs("?*", "").empty())
{
source.Reply(_("The mask must contain at least one non wildcard character."));
return;
}
time_t expiryt = 0;
if (!expiry.empty())
{
expiryt = Anope::DoTime(expiry);
if (expiryt == -1)
{
source.Reply(_("Invalid expiry time \002{0}\002."), expiry);
return;
}
else if (expiryt)
expiryt += Anope::CurTime;
}
NickServ::Nick *target = NickServ::FindNick(entry);
if (target != NULL && Config->GetModule("nickserv")->Get<bool>("secureadmins", "yes") && target->GetAccount()->IsServicesOper())
{
source.Reply(_("Access denied."));
return;
}
ForbidData *d = this->fs->FindForbid(entry, ftype);
bool created = false;
if (d == NULL)
{
d = Serialize::New<ForbidData *>();
created = true;
}
d->SetMask(entry);
d->SetCreator(source.GetNick());
d->SetReason(reason);
d->SetCreated(Anope::CurTime);
d->SetExpires(expiryt);
d->SetType(ftype);
if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode. Any changes made may not persist."));
Log(LOG_ADMIN, source, this) << "to add a forbid on " << entry << " of type " << subcommand;
source.Reply(_("Added a forbid on \002{0}\002 of type \002{1}\002 to expire on \002{2}\002."), entry, subcommand.lower(), expiryt ? Anope::strftime(expiryt, source.GetAccount()) : "never");
/* apply forbid */
switch (ftype)
{
case FT_NICK:
{
int na_matches = 0;
for (user_map::const_iterator it = UserListByNick.begin(); it != UserListByNick.end(); ++it)
this->OnUserNickChange(it->second);
for (auto it = NickServ::service->GetNickList().begin(); it != NickServ::service->GetNickList().end();)
{
NickServ::Nick *na = *it;
++it;
d = this->fs->FindForbid(na->GetNick(), FT_NICK);
if (d == NULL)
continue;
++na_matches;
delete na;
}
source.Reply(_("\002{0}\002 nickname(s) dropped."), na_matches);
break;
}
case FT_CHAN:
{
int chan_matches = 0, ci_matches = 0;
for (channel_map::const_iterator it = ChannelList.begin(), it_end = ChannelList.end(); it != it_end;)
{
Channel *c = it->second;
++it;
d = this->fs->FindForbid(c->name, FT_CHAN);
if (d == NULL)
continue;
ServiceBot *OperServ = Config->GetClient("OperServ");
if (IRCD->CanSQLineChannel && OperServ)
{
time_t inhabit = Config->GetModule("chanserv")->Get<time_t>("inhabit", "15s");
#warning "xline allocated on stack"
#if 0
XLine x(c->name, OperServ->nick, Anope::CurTime + inhabit, d->GetReason());
IRCD->SendSQLine(NULL, &x);
#endif
}
else if (ChanServ::service)
{
ChanServ::service->Hold(c);
}
++chan_matches;
for (Channel::ChanUserList::const_iterator cit = c->users.begin(), cit_end = c->users.end(); cit != cit_end;)
{
User *u = cit->first;
++cit;
if (u->server == Me || u->HasMode("OPER"))
continue;
reason = Anope::printf(Language::Translate(u, _("This channel has been forbidden: \002%s\002")), d->GetReason().c_str());
c->Kick(source.service, u, "%s", reason.c_str());
}
}
for (auto it = ChanServ::service->GetChannels().begin(); it != ChanServ::service->GetChannels().end();)
{
ChanServ::Channel *ci = it->second;
++it;
d = this->fs->FindForbid(ci->GetName(), FT_CHAN);
if (d == NULL)
continue;
++ci_matches;
delete ci;
}
source.Reply(_("\002{0}\002 channel(s) cleared, and \002{1}\002 channel(s) dropped."), chan_matches, ci_matches);
break;
}
default:
break;
}
}
else if (command.equals_ci("DEL") && params.size() > 2 && ftype != FT_SIZE)
{
const Anope::string &entry = params[2];
ForbidData *d = this->fs->FindForbid(entry, ftype);
if (d == nullptr)
{
source.Reply(_("Forbid on \002{0}\002 was not found."), entry);
return;
}
if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode. Any changes made may not persist."));
Log(LOG_ADMIN, source, this) << "to remove forbid on " << d->GetMask() << " of type " << subcommand;
source.Reply(_("\002{0}\002 deleted from the \002{1}\002 forbid list."), d->GetMask(), subcommand);
d->Delete();
}
else if (command.equals_ci("LIST"))
{
const std::vector<ForbidData *> &forbids = this->fs->GetForbids();
if (forbids.empty())
{
source.Reply(_("Forbid list is empty."));
return;
}
ListFormatter list(source.GetAccount());
list.AddColumn(_("Mask")).AddColumn(_("Type")).AddColumn(_("Creator")).AddColumn(_("Expires")).AddColumn(_("Reason"));
unsigned shown = 0;
for (unsigned i = 0; i < forbids.size(); ++i)
{
ForbidData *d = forbids[i];
if (ftype != FT_SIZE && ftype != d->GetType())
continue;
Anope::string stype;
if (d->GetType() == FT_NICK)
stype = "NICK";
else if (d->GetType() == FT_CHAN)
stype = "CHAN";
else if (d->GetType() == FT_EMAIL)
stype = "EMAIL";
else if (d->GetType() == FT_REGISTER)
stype = "REGISTER";
else
continue;
ListFormatter::ListEntry entry;
entry["Mask"] = d->GetMask();
entry["Type"] = stype;
entry["Creator"] = d->GetCreator();
entry["Expires"] = d->GetExpires() ? Anope::strftime(d->GetExpires(), NULL, true).c_str() : Language::Translate(source.GetAccount(), _("Never"));
entry["Reason"] = d->GetReason();
list.AddEntry(entry);
++shown;
}
if (!shown)
{
source.Reply(_("There are no forbids of type \002{0}\002."), subcommand.upper());
return;
}
source.Reply(_("Forbid list:"));
std::vector<Anope::string> replies;
list.Process(replies);
for (unsigned i = 0; i < replies.size(); ++i)
source.Reply(replies[i]);
if (shown >= forbids.size())
source.Reply(_("End of forbid list."));
else
source.Reply(_("End of forbid list - \002{0}\002/\002{1}\002 entries shown."), shown, forbids.size());
}
else
this->OnSyntaxError(source, command);
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
const Anope::string &nick = params[0];
Anope::string expiry = params[1];
Anope::string reason = params.size() > 2 ? params[2] : "";
time_t expiry_secs = Config->GetModule(this->GetOwner())->Get<time_t>("suspendexpire");
if (Anope::ReadOnly)
source.Reply(_("Services are in read-only mode. Any changes made may not persist."));
if (expiry[0] != '+')
{
reason = expiry + " " + reason;
reason.trim();
expiry.clear();
}
else
{
expiry_secs = Anope::DoTime(expiry);
if (expiry_secs == -1)
{
source.Reply(_("Invalid expiry time \002{0}\002."), expiry);
return;
}
}
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
if (Config->GetModule("nickserv/main")->Get<bool>("secureadmins", "yes") && na->GetAccount()->GetOper())
{
source.Reply(_("You may not suspend other Services Operators' nicknames."));
return;
}
NSSuspendInfo *si = na->GetAccount()->GetRef<NSSuspendInfo *>();
if (!si)
{
source.Reply(_("\002%s\002 is already suspended."), na->GetAccount()->GetDisplay().c_str());
return;
}
NickServ::Account *nc = na->GetAccount();
si = Serialize::New<NSSuspendInfo *>();
si->SetAccount(nc);
si->SetBy(source.GetNick());
si->SetReason(reason);
si->SetWhen(Anope::CurTime);
si->SetExpires(expiry_secs ? expiry_secs + Anope::CurTime : 0);
for (NickServ::Nick *na2 : nc->GetRefs<NickServ::Nick *>())
{
na2->SetLastQuit(reason);
User *u2 = User::Find(na2->GetNick(), true);
if (u2)
{
u2->Logout();
if (NickServ::service)
NickServ::service->Collide(u2, na2);
}
}
Log(LOG_ADMIN, source, this) << "for " << nick << " (" << (!reason.empty() ? reason : "No reason") << "), expires on " << (expiry_secs ? Anope::strftime(Anope::CurTime + expiry_secs) : "never");
source.Reply(_("\002{0}\002 is now suspended."), na->GetNick());
EventManager::Get()->Dispatch(&Event::NickSuspend::OnNickSuspend, na);
}