static Anope::string Unescape(const Anope::string &string)
{
Anope::string ret = string;
for (int i = 0; special[i].character.empty() == false; ++i)
if (!special[i].replace.empty())
ret = ret.replace_all_cs(special[i].replace, special[i].character);
for (size_t i, last = 0; (i = string.find("&#", last)) != Anope::string::npos;)
{
last = i + 1;
size_t end = string.find(';', i);
if (end == Anope::string::npos)
break;
Anope::string ch = string.substr(i + 2, end - (i + 2));
if (ch.empty())
continue;
long l;
if (!ch.empty() && ch[0] == 'x')
l = strtol(ch.substr(1).c_str(), NULL, 16);
else
l = strtol(ch.c_str(), NULL, 10);
if (l > 0 && l < 256)
ret = ret.replace_all_cs("&#" + ch + ";", Anope::string(l));
}
return ret;
}
Anope::string Sanitize(const Anope::string &string) override
{
Anope::string ret = string;
for (int i = 0; special[i].character.empty() == false; ++i)
ret = ret.replace_all_cs(special[i].character, special[i].replace);
return ret;
}
static bool SendResetEmail(User *u, NickServ::Nick *na, ServiceBot *bi)
{
Anope::string subject = Language::Translate(na->GetAccount(), Config->GetBlock("mail")->Get<Anope::string>("reset_subject").c_str()),
message = Language::Translate(na->GetAccount(), Config->GetBlock("mail")->Get<Anope::string>("reset_message").c_str()),
passcode = Anope::Random(20);
subject = subject.replace_all_cs("%n", na->GetNick());
subject = subject.replace_all_cs("%N", Config->GetBlock("networkinfo")->Get<Anope::string>("networkname"));
subject = subject.replace_all_cs("%c", passcode);
message = message.replace_all_cs("%n", na->GetNick());
message = message.replace_all_cs("%N", Config->GetBlock("networkinfo")->Get<Anope::string>("networkname"));
message = message.replace_all_cs("%c", passcode);
na->GetAccount()->Extend<ResetInfo>("reset", ResetInfo{passcode, Anope::CurTime});
return Mail::Send(u, na->GetAccount(), bi, subject, message);
}
bool SendMemoMail(NickServ::Account *nc, MemoServ::MemoInfo *mi, MemoServ::Memo *m)
{
Anope::string subject = Language::Translate(nc, Config->GetBlock("mail")->Get<Anope::string>("memo_subject").c_str()),
message = Language::Translate(Config->GetBlock("mail")->Get<Anope::string>("memo_message").c_str());
subject = subject.replace_all_cs("%n", nc->GetDisplay());
subject = subject.replace_all_cs("%s", m->GetSender());
subject = subject.replace_all_cs("%d", stringify(mi->GetIndex(m) + 1));
subject = subject.replace_all_cs("%t", m->GetText());
subject = subject.replace_all_cs("%N", Config->GetBlock("networkinfo")->Get<Anope::string>("networkname"));
message = message.replace_all_cs("%n", nc->GetDisplay());
message = message.replace_all_cs("%s", m->GetSender());
message = message.replace_all_cs("%d", stringify(mi->GetIndex(m) + 1));
message = message.replace_all_cs("%t", m->GetText());
message = message.replace_all_cs("%N", Config->GetBlock("networkinfo")->Get<Anope::string>("networkname"));
return Mail::Send(nc, subject, message);
}
void OnLookupComplete(const Query *record) override
{
if (!user || user->Quitting())
return;
const ResourceRecord &ans_record = record->answers[0];
// Replies should be in 127.0.0.0/8
if (ans_record.rdata.find("127.") != 0)
return;
sockaddrs sresult;
sresult.pton(AF_INET, ans_record.rdata);
int result = sresult.sa4.sin_addr.s_addr >> 24;
Blacklist::Reply *reply = blacklist.Find(result);
if (!blacklist.replies.empty() && !reply)
return;
if (reply && reply->allow_account && user->Account())
return;
Anope::string reason = this->blacklist.reason, addr = user->ip.addr();
reason = reason.replace_all_cs("%n", user->nick);
reason = reason.replace_all_cs("%u", user->GetIdent());
reason = reason.replace_all_cs("%g", user->realname);
reason = reason.replace_all_cs("%h", user->host);
reason = reason.replace_all_cs("%i", addr);
reason = reason.replace_all_cs("%r", reply ? reply->reason : "");
reason = reason.replace_all_cs("%N", Config->GetBlock("networkinfo")->Get<Anope::string>("networkname"));
ServiceBot *OperServ = Config->GetClient("OperServ");
creator->logger.Category("dnsbl").Bot(OperServ).Log(_("{0} ({1}) appears in {2}"), user->GetMask(), addr, this->blacklist.name);
XLine *x = Serialize::New<XLine *>();
x->SetMask("*@" + addr);
x->SetBy(OperServ ? OperServ->nick : "m_dnsbl");
x->SetCreated(Anope::CurTime);
x->SetExpires(Anope::CurTime + this->blacklist.bantime);
x->SetReason(reason);
x->SetID(XLineManager::GenerateUID());
if (this->add_to_akill && akills)
{
akills->AddXLine(x);
akills->Send(NULL, x);
}
else
{
IRCD->Send<messages::Akill>(nullptr, x);
delete x;
}
}
static bool SendMemoMail(NickCore *nc, MemoInfo *mi, Memo *m)
{
Anope::string subject = translate(nc, Config->MailMemoSubject.c_str());
Anope::string message = translate(nc, Config->MailMemoMessage.c_str());
subject = subject.replace_all_cs("%n", nc->display);
subject = subject.replace_all_cs("%s", m->sender);
subject = subject.replace_all_cs("%d", mi->GetIndex(m));
subject = subject.replace_all_cs("%t", m->text);
message = message.replace_all_cs("%n", nc->display);
message = message.replace_all_cs("%s", m->sender);
message = message.replace_all_cs("%d", mi->GetIndex(m));
message = message.replace_all_cs("%t", m->text);
return Mail(nc, subject, message);
}
/* strip dots from username, and remove anything after the first + */
Anope::string CleanMail(const Anope::string &email)
{
size_t host = email.find('@');
if (host == Anope::string::npos)
return email;
Anope::string username = email.substr(0, host);
username = username.replace_all_cs(".", "");
size_t sz = username.find('+');
if (sz != Anope::string::npos)
username = username.substr(0, sz);
Anope::string cleaned = username + email.substr(host);
logger.Debug("cleaned {0} to {1}", email, cleaned);
return cleaned;
}
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;
}
}
/** Main process routine
* @param buffer A raw line from the uplink to do things with
*/
void process(const Anope::string &buffer)
{
/* If debugging, log the buffer */
Log(LOG_RAWIO) << "Received: " << buffer;
/* Strip all extra spaces */
Anope::string buf = buffer;
buf = buf.replace_all_cs(" ", " ");
if (buf.empty())
return;
Anope::string source;
if (buf[0] == ':')
{
size_t space = buf.find_first_of(" ");
if (space == Anope::string::npos)
return;
source = buf.substr(1, space - 1);
buf = buf.substr(space + 1);
if (source.empty() || buf.empty())
return;
}
spacesepstream buf_sep(buf);
Anope::string buf_token;
Anope::string command = buf;
if (buf_sep.GetToken(buf_token))
command = buf_token;
std::vector<Anope::string> params;
while (buf_sep.GetToken(buf_token))
{
if (buf_token[0] == ':')
{
if (!buf_sep.StreamEnd())
params.push_back(buf_token.substr(1) + " " + buf_sep.GetRemaining());
else
params.push_back(buf_token.substr(1));
break;
}
else
params.push_back(buf_token);
}
if (protocoldebug)
{
Log() << "Source : " << (source.empty() ? "No source" : source);
Log() << "Command: " << command;
if (params.empty())
Log() << "No params";
else
for (unsigned i = 0; i < params.size(); ++i)
Log() << "params " << i << ": " << params[i];
}
std::vector<Message *> messages = Anope::FindMessage(command);
if (!messages.empty())
{
bool retVal = true;
for (std::vector<Message *>::iterator it = messages.begin(), it_end = messages.end(); retVal == true && it != it_end; ++it)
{
Message *m = *it;
if (m->func)
retVal = m->func(source, params);
}
}
else
Log(LOG_DEBUG) << "unknown message from server (" << buffer << ")";
}
