EventReturn OnLoadDatabase() override
{
if (!redis)
return EVENT_STOP;
const std::map<Anope::string, Serialize::TypeBase *> &types = Serialize::TypeBase::GetTypes();
for (const std::pair<Anope::string, Serialize::TypeBase *> &p : types)
this->OnSerializeTypeCreate(p.second);
while (redis->BlockAndProcess());
redis->Subscribe(&this->sl, "anope");
return EVENT_STOP;
}
void DoDel(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string nick = params.size() > 1 ? params[1] : "";
if (nick.empty())
{
this->OnSyntaxError(source, "DEL");
return;
}
Anope::string mask = RealMask(nick);
if (mask.empty())
{
source.Reply(_("Mask must be in the form \037user\037@\037host\037."));
return;
}
Ignore *ign = ignore_service->Find(mask);
if (!ign)
{
source.Reply(_("\002{0}\002 not found on ignore list."), mask);
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 an ignore on " << mask;
source.Reply(_("\002{0}\002 will no longer be ignored."), mask);
ign->Delete();
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
if (Anope::ReadOnly)
{
source.Reply(_("Services are in read-only mode."));
return;
}
const Anope::string &nick = params[0];
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
HostRequest *req = na->GetExt<HostRequest>("hostrequest");
if (!req)
{
source.Reply(_("\002{0}\002 does not have a pending vhost request."), na->GetNick());
return;
}
na->SetVhost(req->GetIdent(), req->GetHost(), source.GetNick(), req->GetTime());
EventManager::Get()->Dispatch(&Event::SetVhost::OnSetVhost, na);
if (Config->GetModule(this->GetOwner())->Get<bool>("memouser") && memoserv)
memoserv->Send(source.service->nick, na->GetNick(), _("[auto memo] Your requested vHost has been approved."), true);
source.Reply(_("Vhost for \002{0}\002 has been activated."), na->GetNick());
Log(LOG_COMMAND, source, this) << "for " << na->GetNick() << " for vhost " << (!req->GetIdent().empty() ? req->GetIdent() + "@" : "") << req->GetHost();
req->Delete();
}
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest) override
{
if (!md5)
return EVENT_CONTINUE;
Encryption::Context *context = md5->CreateContext();
context->Update(reinterpret_cast<const unsigned char *>(src.c_str()), src.length());
context->Finalize();
Encryption::Hash hash = context->GetFinalizedHash();
char digest[32], digest2[16];
memset(digest, 0, sizeof(digest));
if (hash.second > sizeof(digest))
throw CoreException("Hash too large");
memcpy(digest, hash.first, hash.second);
for (int i = 0; i < 32; i += 2)
digest2[i / 2] = XTOI(digest[i]) << 4 | XTOI(digest[i + 1]);
Anope::string buf = "oldmd5:" + Anope::Hex(digest2, sizeof(digest2));
Log(LOG_DEBUG_2) << "(enc_old) hashed password from [" << src << "] to [" << buf << "]";
dest = buf;
delete context;
return EVENT_ALLOW;
}
void DoStatsHash(CommandSource &source)
{
size_t entries, buckets, max_chain;
GetHashStats(UserListByNick, entries, buckets, max_chain);
source.Reply(_("Users (nick): {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
if (!UserListByUID.empty())
{
GetHashStats(UserListByUID, entries, buckets, max_chain);
source.Reply(_("Users (uid): {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
}
GetHashStats(ChannelList, entries, buckets, max_chain);
source.Reply(_("Channels: {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
GetHashStats(ChanServ::service->GetChannels(), entries, buckets, max_chain);
source.Reply(_("Registered channels: {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
GetHashStats(NickServ::service->GetNickMap(), entries, buckets, max_chain);
source.Reply(_("Registered nicknames: {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
GetHashStats(NickServ::service->GetAccountMap(), entries, buckets, max_chain);
source.Reply(_("Registered nick groups: {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
if (session_service)
{
GetHashStats(session_service->GetSessions(), entries, buckets, max_chain);
source.Reply(_("Sessions: {0} entries, {1} buckets, longest chain is {2}"), entries, buckets, max_chain);
}
}
EventReturn OnSerializeSet(Serialize::Object *object, Serialize::FieldBase *field, const Anope::string &value) override
{
std::vector<Anope::string> args;
redis->StartTransaction();
const Anope::string &old = field->SerializeToString(object);
args = { "SREM", "lookup:" + object->GetSerializableType()->GetName() + ":" + field->serialize_name + ":" + old, stringify(object->id) };
redis->SendCommand(nullptr, args);
// add object to type set
args = { "SADD", "ids:" + object->GetSerializableType()->GetName(), stringify(object->id) };
redis->SendCommand(nullptr, args);
// add key to key set
args = { "SADD", "keys:" + stringify(object->id), field->serialize_name };
redis->SendCommand(nullptr, args);
// set value
args = { "SET", "values:" + stringify(object->id) + ":" + field->serialize_name, value };
redis->SendCommand(nullptr, args);
// lookup
args = { "SADD", "lookup:" + object->GetSerializableType()->GetName() + ":" + field->serialize_name + ":" + value, stringify(object->id) };
redis->SendCommand(nullptr, args);
redis->CommitTransaction();
return EVENT_CONTINUE;
}
EventReturn OnSerializeUnset(Serialize::Object *object, Serialize::FieldBase *field) override
{
std::vector<Anope::string> args;
redis->StartTransaction();
const Anope::string &old = field->SerializeToString(object);
args = { "SREM", "lookup:" + object->GetSerializableType()->GetName() + ":" + field->serialize_name + ":" + old, stringify(object->id) };
redis->SendCommand(nullptr, args);
// remove field from set
args = { "SREM", "keys:" + stringify(object->id), field->serialize_name };
redis->SendCommand(nullptr, args);
redis->CommitTransaction();
return EVENT_CONTINUE;
}
ModuleXMLRPCMain(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, EXTRA | VENDOR)
{
me = this;
if (!xmlrpc)
throw ModuleException("Unable to find xmlrpc reference, is m_xmlrpc loaded?");
xmlrpc->Register(&stats);
}
bool MiningBundleActivator::addingService( const ServiceReference& ref )
{
if ( ref.getServiceName() == "IndexSearchService" )
{
Properties props = ref.getServiceProperties();
if ( props.get( "collection" ) == config_->collectionName_)
{
IndexSearchService* service = reinterpret_cast<IndexSearchService*> ( const_cast<IService*>(ref.getService()) );
cout << "[MiningBundleActivator#addingService] Calling IndexSearchService..." << endl;
currentCollectionDataName_ = service->bundleConfig_->collPath_.getCurrCollectionDir();
miningManager_ = createMiningManager_(service);
if (!miningManager_)
{
cerr << "error: failed in creating MiningManager" << endl;
return false;
}
searchService_ = new MiningSearchService;
searchService_->bundleConfig_ = config_;
searchService_->miningManager_ = miningManager_;
searchService_->searchAggregator_ = service->searchAggregator_;
searchService_->ro_searchAggregator_ = service->ro_searchAggregator_;
searchService_->searchWorker_ = service->searchWorker_;
taskService_ = new MiningTaskService(config_);
taskService_->miningManager_ = miningManager_;
Properties props;
props.put( "collection", config_->collectionName_);
searchServiceReg_ = context_->registerService( "MiningSearchService", searchService_, props );
taskServiceReg_ = context_->registerService( "MiningTaskService", taskService_, props );
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
SQL::Result RunQuery(const SQL::Query &query)
{
if (!this->sql)
throw SQL::Exception("Unable to locate SQL reference, is m_mysql loaded and configured correctly?");
SQL::Result res = sql->RunQuery(query);
if (!res.GetError().empty())
throw SQL::Exception(res.GetError());
return res;
}
void OnChannelSync(Channel *c) override
{
if (!c->ci || !mlocks)
return;
if (use_server_side_mlock && Servers::Capab.count("MLOCK") > 0)
{
Anope::string modes = mlocks->GetMLockAsString(c->ci, false).replace_all_cs("+", "").replace_all_cs("-", "");
Uplink::Send(Me, "MLOCK", c->creation_time, c->ci->GetName(), modes);
}
}
void OnSerializableDelete(Serialize::Object *obj) override
{
std::vector<Anope::string> args;
redis->StartTransaction();
for (Serialize::FieldBase *field : obj->GetSerializableType()->GetFields())
{
Anope::string value = field->SerializeToString(obj);
args = { "SREM", "lookup:" + obj->GetSerializableType()->GetName() + ":" + field->serialize_name + ":" + value, stringify(obj->id) };
redis->SendCommand(nullptr, args);
args = { "DEL", "values:" + stringify(obj->id) + ":" + field->serialize_name };
redis->SendCommand(nullptr, args);
args = { "SREM", "keys:" + stringify(obj->id), field->serialize_name };
redis->SendCommand(nullptr, args);
}
args = { "SREM", "ids:" + obj->GetSerializableType()->GetName(), stringify(obj->id) };
redis->SendCommand(nullptr, args);
redis->CommitTransaction();
}
EventReturn OnUnMLock(ChanServ::Channel *ci, ModeLock *lock) override
{
if (!mlocks)
return EVENT_CONTINUE;
ChannelMode *cm = ModeManager::FindChannelModeByName(lock->GetName());
if (use_server_side_mlock && cm && ci->c && (cm->type == MODE_REGULAR || cm->type == MODE_PARAM) && Servers::Capab.count("MLOCK") > 0)
{
Anope::string modes = mlocks->GetMLockAsString(ci, false).replace_all_cs("+", "").replace_all_cs("-", "").replace_all_cs(cm->mchar, "");
Uplink::Send(Me, "MLOCK", ci->c->creation_time, ci->GetName(), modes);
}
return EVENT_CONTINUE;
}
void OnUserNickChange(User *u)
{
if (u->HasMode("OPER"))
return;
ForbidData *d = fs->FindForbid(u->nick, FT_NICK);
if (d != NULL)
{
ServiceBot *bi = Config->GetClient("NickServ");
if (!bi)
bi = Config->GetClient("OperServ");
if (bi)
u->SendMessage(bi, _("This nickname has been forbidden: \002{0}\002"), d->GetReason());
if (NickServ::service)
NickServ::service->Collide(u, NULL);
}
}
void OnLog(Logger *logger) override
{
User *user = logger->GetUser();
ChanServ::Channel *channel = logger->GetCi();
Command *command = logger->GetCommand();
CommandSource *source = logger->GetSource();
if (logger->GetType() != LogType::COMMAND || user == nullptr || command == nullptr || channel == nullptr || !Me || !Me->IsSynced())
return;
Channel *c = channel->GetChannel();
for (LogSetting *log : channel->GetRefs<LogSetting *>())
{
/* wrong command */
if (log->GetServiceName() != command->GetName())
continue;
/* if a command name is given check the service and the command */
if (!log->GetCommandName().empty())
{
/* wrong service (only check if not a fantasy command, though) */
if (!source->c && log->GetCommandService() != source->service->nick)
continue;
if (!log->GetCommandName().equals_ci(source->GetCommand()))
continue;
}
const Anope::string &buffer = logger->GetMaskedMessage();
if (log->GetMethod().equals_ci("MEMO") && memoserv && channel->WhoSends() != NULL)
memoserv->Send(channel->WhoSends()->nick, channel->GetName(), buffer, true);
else if (source->c)
/* Sending a channel message or notice in response to a fantasy command */;
else if (log->GetMethod().equals_ci("MESSAGE") && c)
{
IRCD->SendPrivmsg(channel->WhoSends(), log->GetExtra() + c->name, "{0}", buffer);
#warning "fix idletimes"
//l->ci->WhoSends()->lastmsg = Anope::CurTime;
}
else if (log->GetMethod().equals_ci("NOTICE") && c)
IRCD->SendNotice(channel->WhoSends(), log->GetExtra() + c->name, "{0}", buffer);
}
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms) override
{
if (Anope::ReadOnly)
{
source.Reply(_("Services are in read-only mode."));
return;
}
const Anope::string &nick = params[0];
const Anope::string &reason = params.size() > 1 ? params[1] : "";
NickServ::Nick *na = NickServ::FindNick(nick);
if (!na)
{
source.Reply(_("\002{0}\002 isn't registered."), nick);
return;
}
HostRequest *req = na->GetExt<HostRequest>("hostrequest");
if (!req)
{
source.Reply(_("\002{0}\002 does not have a pending vhost request."), na->GetNick());
return;
}
req->Delete();
if (Config->GetModule(this->GetOwner())->Get<bool>("memouser") && memoserv)
{
Anope::string message;
if (!reason.empty())
message = Anope::printf(_("[auto memo] Your requested vHost has been rejected. Reason: %s"), reason.c_str());
else
message = _("[auto memo] Your requested vHost has been rejected.");
memoserv->Send(source.service->nick, nick, Language::Translate(source.GetAccount(), message.c_str()), true);
}
source.Reply(_("Vhost for \002{0}\002 has been rejected."), na->GetNick());
Log(LOG_COMMAND, source, this) << "to reject vhost for " << nick << " (" << (!reason.empty() ? reason : "no reason") << ")";
}
void SendMemos(CommandSource &source, const Anope::string &vIdent, const Anope::string &vHost)
{
Anope::string host;
if (!vIdent.empty())
host = vIdent + "@" + vHost;
else
host = vHost;
if (Config->GetModule(GetOwner())->Get<bool>("memooper") && memoserv)
for (Oper *o : Serialize::GetObjects<Oper *>())
{
NickServ::Nick *na = NickServ::FindNick(o->GetName());
if (!na)
continue;
Anope::string message = Anope::printf(_("[auto memo] vHost \002%s\002 has been requested by %s."), host.c_str(), source.GetNick().c_str());
memoserv->Send(source.service->nick, na->GetNick(), message, true);
}
}
void SendSVSKillInternal(const MessageSource &source, User *targ, const Anope::string &reason) override { hybrid->SendSVSKillInternal(source, targ, reason); }
void OnSerializeTypeCreate(Serialize::TypeBase *sb)
{
std::vector<Anope::string> args = { "SMEMBERS", "ids:" + sb->GetName() };
redis->SendCommand(new TypeLoader(this, sb), args);
}
bool IsIdentValid(const Anope::string &ident) override { return hybrid->IsIdentValid(ident); }
~ModuleXMLRPC()
{
if (httpref)
httpref->UnregisterPage(&xmlrpcinterface);
}
void SendModeInternal(const MessageSource &source, User *u, const Anope::string &buf) override { hybrid->SendModeInternal(source, u, buf); }
void SendChannel(Channel *c) override { hybrid->SendChannel(c); }
void SendJoin(User *user, Channel *c, const ChannelStatus *status) override { hybrid->SendJoin(user, c, status); }
void SendServer(const Server *server) override { hybrid->SendServer(server); }
void SendSQLineDel(XLine *x) override { hybrid->SendSQLineDel(x); }
void SendAkillDel(XLine *x) override { hybrid->SendAkillDel(x); }
void SendAkill(User *u, XLine *x) override { hybrid->SendAkill(u, x); }
void SendSGLine(User *u, XLine *x) override { hybrid->SendSGLine(u, x); }
void SendGlobalPrivmsg(ServiceBot *bi, const Server *dest, const Anope::string &msg) override { hybrid->SendGlobalPrivmsg(bi, dest, msg); }
