void DoNotify(CommandSource &source, const std::vector<Anope::string> ¶ms, MemoServ::MemoInfo *mi)
{
const Anope::string ¶m = params[1];
NickServ::Account *nc = source.nc;
ServiceBot *MemoServ = Config->GetClient("MemoServ");
if (!MemoServ)
return;
if (param.equals_ci("ON"))
{
nc->SetS<bool>("MEMO_SIGNON", true);
nc->SetS<bool>("MEMO_RECEIVE", true);
source.Reply(_("\002{0}\002 will now notify you of memos when you log on and when they are sent to you."), MemoServ->nick);
}
else if (param.equals_ci("LOGON"))
{
nc->SetS<bool>("MEMO_SIGNON", true);
nc->UnsetS<bool>("MEMO_RECEIVE");
source.Reply(_("\002{0}\002 will now notify you of memos when you log on or unset /AWAY."), MemoServ->nick);
}
else if (param.equals_ci("NEW"))
{
nc->UnsetS<bool>("MEMO_SIGNON");
nc->SetS<bool>("MEMO_RECEIVE", true);
source.Reply(_("\002{0}\002 will now notify you of memos when they are sent to you."), MemoServ->nick);
}
else if (param.equals_ci("MAIL"))
{
if (!nc->GetEmail().empty())
{
nc->SetS<bool>("MEMO_MAIL", true);
source.Reply(_("You will now be informed about new memos via email."));
}
else
source.Reply(_("There's no email address set for your nick."));
}
else if (param.equals_ci("NOMAIL"))
{
nc->UnsetS<bool>("MEMO_MAIL");
source.Reply(_("You will no longer be informed via email."));
}
else if (param.equals_ci("OFF"))
{
nc->UnsetS<bool>("MEMO_SIGNON");
nc->UnsetS<bool>("MEMO_RECEIVE");
nc->UnsetS<bool>("MEMO_MAIL");
source.Reply(_("\002{0}\002 will not send you any notification of memos."), MemoServ->nick);
}
else
this->OnSyntaxError(source, "");
}
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, "");
}
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 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, "");
}
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 OnResult(const LDAPResult &r) override
{
if (!u || !u->Account())
return;
NickServ::Account *nc = u->Account();
try
{
const LDAPAttributes &attr = r.get(0);
const Anope::string &opertype = attr.get(opertype_attribute);
OperType *ot = OperType::Find(opertype);
if (ot != NULL && (nc->o == NULL || ot != nc->o->ot))
{
Oper *o = nc->o;
if (o != NULL && my_opers.count(o) > 0)
{
my_opers.erase(o);
delete o;
}
o = new Oper(u->nick, ot);
my_opers.insert(o);
nc->o = o;
Log(this->owner) << "Tied " << u->nick << " (" << nc->GetDisplay() << ") to opertype " << ot->GetName();
}
}
catch (const LDAPException &ex)
{
if (nc->o != NULL)
{
if (my_opers.count(nc->o) > 0)
{
my_opers.erase(nc->o);
delete nc->o;
}
nc->o = NULL;
Log(this->owner) << "Removed services operator from " << u->nick << " (" << nc->GetDisplay() << ")";
}
}
}
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 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);
}
}
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
{
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());
}
// Debug: Received: :00BAAAAAB ENCAP * LOGIN Adam
void ratbox::Encap::Run(MessageSource &source, const std::vector<Anope::string> ¶ms)
{
if (params[1] == "LOGIN" || params[1] == "SU")
{
User *u = source.GetUser();
NickServ::Account *nc = NickServ::FindAccount(params[2]);
if (!nc)
return;
u->Login(nc);
/* Sometimes a user connects, we send them the usual "this nickname is registered" mess (if
* their server isn't syncing) and then we receive this.. so tell them about it.
*/
if (u->server->IsSynced())
u->SendMessage(Config->GetClient("NickServ"), _("You have been logged in as \002%s\002."), nc->GetDisplay().c_str());
}
}
void Check(User *u) override
{
NickServ::Account *nc = u->Account();
if (!nc || !nc->GetMemos())
return;
auto memos = nc->GetMemos()->GetMemos();
unsigned i = 0, end = memos.size(), newcnt = 0;
for (; i < end; ++i)
if (memos[i]->GetUnread())
++newcnt;
if (newcnt > 0)
u->SendMessage(*MemoServ, newcnt == 1 ? _("You have 1 new memo.") : _("You have %d new memos."), newcnt);
if (nc->GetMemos()->GetMemoMax() > 0 && memos.size() >= static_cast<unsigned>(nc->GetMemos()->GetMemoMax()))
{
if (memos.size() > static_cast<unsigned>(nc->GetMemos()->GetMemoMax()))
u->SendMessage(*MemoServ, _("You are over your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->GetMemos()->GetMemoMax());
else
u->SendMessage(*MemoServ, _("You have reached your maximum number of memos (%d). You will be unable to receive any new memos until you delete some of your current ones."), nc->GetMemos()->GetMemoMax());
}
}
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);
}
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
User *u = source.GetUser();
Anope::string nick;
if (params.empty())
{
NickServ::Account* core = u->Account();
if (core)
nick = core->GetDisplay();
}
else
nick = params[0];
if (nick.empty())
{
this->SendSyntax(source);
return;
}
const Anope::string &pass = params.size() > 1 ? params[1] : "";
if (Anope::ReadOnly)
{
source.Reply(_("Sorry, nickname grouping is temporarily disabled."));
return;
}
if (!IRCD->IsNickValid(u->nick))
{
source.Reply(_("\002{0}\002 may not be registered."), u->nick);
return;
}
if (Config->GetModule("nickserv")->Get<bool>("restrictopernicks"))
for (Oper *o : Serialize::GetObjects<Oper *>())
{
if (!u->HasMode("OPER") && u->nick.find_ci(o->GetName()) != Anope::string::npos)
{
source.Reply(_("\002{0}\002 may not be registered because it is too similar to an operator nick."), u->nick);
return;
}
}
NickServ::Nick *target, *na = NickServ::FindNick(u->nick);
const Anope::string &guestnick = Config->GetModule("nickserv")->Get<Anope::string>("guestnickprefix", "Guest");
time_t reg_delay = Config->GetModule("nickserv")->Get<time_t>("regdelay");
unsigned maxaliases = Config->GetModule(this->GetOwner())->Get<unsigned>("maxaliases");
if (!(target = NickServ::FindNick(nick)))
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
if (Anope::CurTime < u->lastnickreg + reg_delay)
{
source.Reply(_("Please wait \002{0}\002 seconds before using the \002{1}\002 command again."), (reg_delay + u->lastnickreg) - Anope::CurTime, source.command);
return;
}
if (target->GetAccount()->HasFieldS("NS_SUSPENDED"))
{
Log(LOG_COMMAND, source, this) << "and tried to group to suspended nick " << target->GetNick();
source.Reply(_("\002{0}\002 is suspended."), target->GetNick());
return;
}
if (na && Config->GetModule(this->GetOwner())->Get<bool>("nogroupchange"))
{
source.Reply(_("Your nick is already registered."));
return;
}
if (na && target->GetAccount() == na->GetAccount())
{
source.Reply(_("You are already a member of the group of \002{0}\002."), target->GetNick());
return;
}
if (na && na->GetAccount() != u->Account())
{
source.Reply(_("\002{0}\002 is already registered."), na->GetNick());
return;
}
if (na && Config->GetModule(this->GetOwner())->Get<bool>("nogroupchange"))
{
source.Reply(_("You are already registered."));
return;
}
if (maxaliases && target->GetAccount()->GetRefs<NickServ::Nick *>().size() >= maxaliases && !target->GetAccount()->IsServicesOper())
{
source.Reply(_("There are too many nicknames in your group."));
return;
}
if (u->nick.length() <= guestnick.length() + 7 &&
u->nick.length() >= guestnick.length() + 1 &&
!u->nick.find_ci(guestnick) && !u->nick.substr(guestnick.length()).find_first_not_of("1234567890"))
{
source.Reply(_("\002{0}\002 may not be registered."), u->nick);
return;
}
bool ok = false;
if (!na && u->Account() == target->GetAccount())
ok = true;
if (certservice && certservice->Matches(u, target->GetAccount()))
ok = true;
if (ok == false && !pass.empty())
{
NickServ::IdentifyRequest *req = NickServ::service->CreateIdentifyRequest(new NSGroupRequestListener(source, this, u->nick, target), this->GetOwner(), target->GetAccount()->GetDisplay(), pass);
EventManager::Get()->Dispatch(&Event::CheckAuthentication::OnCheckAuthentication, source.GetUser(), req);
req->Dispatch();
}
else
{
NSGroupRequestListener req(source, this, u->nick, target);
if (ok)
req.OnSuccess(nullptr);
else
req.OnFail(nullptr);
}
}
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");
}
MemoResult Send(const Anope::string &source, const Anope::string &target, const Anope::string &message, bool force) override
{
bool ischan, isregistered;
MemoServ::MemoInfo *mi = GetMemoInfo(target, ischan, isregistered, true);
if (mi == NULL)
return MEMO_INVALID_TARGET;
User *sender = User::Find(source);
if (sender != NULL && !sender->HasPriv("memoserv/no-limit") && !force)
{
time_t send_delay = Config->GetModule("memoserv")->Get<time_t>("senddelay");
if (send_delay > 0 && sender->lastmemosend + send_delay > Anope::CurTime)
return MEMO_TOO_FAST;
else if (!mi->GetMemoMax())
return MEMO_TARGET_FULL;
else if (mi->GetMemoMax() > 0 && mi->GetMemos().size() >= static_cast<unsigned>(mi->GetMemoMax()))
return MEMO_TARGET_FULL;
else if (mi->HasIgnore(sender))
return MEMO_SUCCESS;
}
if (sender != NULL)
sender->lastmemosend = Anope::CurTime;
MemoServ::Memo *m = Serialize::New<MemoServ::Memo *>();
m->SetMemoInfo(mi);
m->SetSender(source);
m->SetTime(Anope::CurTime);
m->SetText(message);
m->SetUnread(true);
EventManager::Get()->Dispatch(&MemoServ::Event::MemoSend::OnMemoSend, source, target, mi, m);
if (ischan)
{
ChanServ::Channel *ci = ChanServ::Find(target);
if (ci->c)
{
for (Channel::ChanUserList::iterator it = ci->c->users.begin(), it_end = ci->c->users.end(); it != it_end; ++it)
{
ChanUserContainer *cu = it->second;
if (ci->AccessFor(cu->user).HasPriv("MEMO"))
{
if (cu->user->Account() && cu->user->Account()->HasFieldS("MEMO_RECEIVE"))
cu->user->SendMessage(*MemoServ, _("There is a new memo on channel \002{0}\002. Type \002{1}{2} READ {3} {4}\002 to read it."), ci->GetName(), Config->StrictPrivmsg, MemoServ->nick, ci->GetName(), mi->GetMemos().size()); // XXX
}
}
}
}
else
{
NickServ::Account *nc = NickServ::FindNick(target)->GetAccount();
if (nc->HasFieldS("MEMO_RECEIVE"))
for (User *u : nc->users)
u->SendMessage(*MemoServ, _("You have a new memo from \002{0}\002. Type \002{1}{2} READ {3}\002 to read it."), source, Config->StrictPrivmsg, MemoServ->nick, mi->GetMemos().size());//XXX
/* let's get out the mail if set in the nickcore - certus */
if (nc->HasFieldS("MEMO_MAIL"))
SendMemoMail(nc, mi, m);
}
return MEMO_SUCCESS;
}
