/**
* handle the IDENTIFY command
*/
void cs_identify(char *src,int ac,char **av) {
if(ac<3) {
notice(cs_name,src,CS_IDENTIFY_ERR_USAGE);
notice(cs_name,src,NS_RPL_HLP_SHORT,cs_name,"HELP IDENTIFY");
return;
}
char *chan = sstrdup(av[1]);
char *pass = sstrdup(av[2]);
user *u = finduser(src);
if (!isregcs(chan)) {
notice(cs_name, src, CS_ERR_NOTREG, chan);
return;
}
if (isidentified(u, chan) > 0) {
notice(ns_name, src, CS_IDENTIFY_RPL_ALREADYIDF, chan);
return;
}
ChanInfo *c = findchan(chan);
if (stricmp(pass,c->pass)!=0) {
notice(cs_name,src,CS_IDENTIFY_ERR_WRONGPASS,chan);
return;
} else {
notice(cs_name,src,CS_IDENTIFY_RPL_PASSACCEPTED,chan);
add_identifiedcs(u,chan);
}
return;
}
/**
* Handle seen fantasy command.
**/
int do_fantasy_seen(int argc, char **argv)
{
User *u;
char *target = NULL;
ChannelStats *cs;
char *message = NULL;
if (denora->debug)
protocol_debug(NULL, argc, argv);
if (argc >= 3 && stricmp(argv[0], "seen") == 0) {
u = finduser(argv[1]);
cs = find_cs(argv[2]);
if (argc == 3) {
if (cs->flags & CS_NOTICE)
moduleNoticeLang(s_StatServ, u, SEEN_USAGE,
ChanStatsTrigger);
else
moduleNoticeChanLang(s_StatServ, cs, SEEN_USAGE,
ChanStatsTrigger);
} else {
target = myStrGetToken(argv[3], ' ', 0);
message = do_seen(u, target);
if (cs->flags & CS_NOTICE)
notice(s_StatServ, u->nick, message);
else
denora_cmd_privmsg(s_StatServ, cs->name, message);
}
}
return MOD_CONT;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
User *u = source.u;
const Anope::string &chan = params[0];
const Anope::string &nick = params[1];
const Anope::string &s = params[2];
Channel *c;
User *u2;
if (!(c = findchan(chan)))
{
source.Reply(CHAN_X_NOT_IN_USE, chan.c_str());
return;
}
else if (c->bouncy_modes)
{
source.Reply(_("Services is unable to change modes. Are your servers' U:lines configured correctly?"));
return;
}
else if (!(u2 = finduser(nick)))
{
source.Reply(NICK_X_NOT_IN_USE, nick.c_str());
return;
}
c->Kick(source.owner, u2, "%s (%s)", u->nick.c_str(), s.c_str());
Log(LOG_ADMIN, u, this) << "on " << u2->nick << " in " << c->name << " (" << s << ")";
return;
}
int my_privmsg(char *source, int ac, char **av)
{
User *u;
char *s;
/* First, some basic checks */
if (ac != 2)
return MOD_CONT; /* bleh */
if (!(u = finduser(source))) {
return MOD_CONT;
} /* non-user source */
if (*av[0] == '#') {
return MOD_CONT;
}
/* Channel message */
/* we should prolly honour the ignore list here, but i cba for this... */
s = strchr(av[0], '@');
if (s) {
*s++ = 0;
if (stricmp(s, ServerName) != 0)
return MOD_CONT;
}
if ((stricmp(av[0], s_CatServ)) == 0) { /* its for US! */
catserv(u, av[1]);
return MOD_STOP;
} else { /* ok it isnt us, let the old code have it */
return MOD_CONT;
}
}
/**
* The /ns ghost command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int do_ghost(User * u)
{
char *nick = strtok(NULL, " ");
char *pass = strtok(NULL, " ");
NickAlias *na;
User *u2;
if (!nick) {
syntax_error(s_NickServ, u, "GHOST", NICK_GHOST_SYNTAX);
} else if (!(u2 = finduser(nick))) {
notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
} else if (!(na = u2->na)) {
notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
} else if (na->status & NS_VERBOTEN) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, na->nick);
} else if (na->nc->flags & NI_SUSPENDED) {
notice_lang(s_NickServ, u, NICK_X_SUSPENDED, na->nick);
} else if (stricmp(nick, u->nick) == 0) {
notice_lang(s_NickServ, u, NICK_NO_GHOST_SELF);
} else if (pass) {
int res = enc_check_password(pass, na->nc->pass);
if (res == 1) {
char buf[NICKMAX + 32];
snprintf(buf, sizeof(buf), "GHOST command used by %s",
u->nick);
send_event(EVENT_NICK_GHOSTED, 3, EVENT_START, u->nick, nick);
alog("%s: %s!%s@%s used GHOST on %s",
s_NickServ, u->nick, u->username, u->host, u2->nick);
kill_user(s_NickServ, nick, buf);
notice_lang(s_NickServ, u, NICK_GHOST_KILLED, nick);
send_event(EVENT_NICK_GHOSTED, 3, EVENT_STOP, u->nick, nick);
} else {
notice_lang(s_NickServ, u, ACCESS_DENIED);
if (res == 0) {
alog("%s: GHOST: invalid password for %s by %s!%s@%s",
s_NickServ, nick, u->nick, u->username, u->host);
bad_password(u);
}
}
} else {
if (group_identified(u, na->nc)
|| (!(na->nc->flags & NI_SECURE) && is_on_access(u, na->nc))) {
char buf[NICKMAX + 32];
snprintf(buf, sizeof(buf), "GHOST command used by %s",
u->nick);
send_event(EVENT_NICK_GHOSTED, 3, EVENT_START, u->nick, nick);
alog("%s: %s!%s@%s used GHOST on %s",
s_NickServ, u->nick, u->username, u->host, u2->nick);
kill_user(s_NickServ, nick, buf);
notice_lang(s_NickServ, u, NICK_GHOST_KILLED, nick);
send_event(EVENT_NICK_GHOSTED, 3, EVENT_STOP, u->nick, nick);
} else {
notice_lang(s_NickServ, u, ACCESS_DENIED);
}
}
return MOD_CONT;
}
/**
* handle the LIST command
*/
void cs_list(char *src,int ac,char **av) {
user *u = finduser(src);
ChanInfo *c = chans;
int count = 0;
char *pattern;
if((u->oper<=0) && (cs_operonly)) {
notice(cs_name,src,NS_ERR_NEEDMOREPRIVS);
return;
}
if(ac<2) {
notice(cs_name,src,CS_LIST_ERR_USAGE);
notice(cs_name,src,CS_RPL_HLP,cs_name,"LIST");
return;
}
if(!strchr(av[1],'#')) {
pattern = (char*)malloc(sizeof(char*)*256);
sprintf(pattern,"#%s",av[1]);
} else {
pattern = sstrdup(av[1]);
}
notice(cs_name,src,CS_LIST_RPL_BEGIN,pattern);
while (c) {
if(ifmatch_0(pattern,c->name)) {
notice(cs_name,src,CS_LIST_RPL_ENTRY,++count,c->name,find_nick_by_id(c->founder)->nick);
}
c = c->next;
}
if(count==1) {
notice(cs_name,src,CS_LIST_RPL_END2);
return;
} else {
notice(cs_name,src,CS_LIST_RPL_END1,count);
return;
}
}
int do_invite(User * u, Channel *c, char *nick) {
ChannelInfo *ci = c->ci;
if (!nick)
noticeLang(ci->bi->nick, u, LANG_INVITE_SYNTAX);
else {
if (check_access(u, ci, CA_OPDEOP) && check_access(u, ci, CA_OPDEOPME)) {
User *u2;
if ((u2 = finduser(nick))) {
if (stricmp(u2->nick, u->nick) != 0) {
if (!is_on_chan(c, u2)) {
anope_cmd_invite(ci->bi->nick, ci->name, u2->nick);
notice(ci->bi->nick, ci->name, "%s was invited to the channel.", u2->nick);
} else
noticeLang(ci->bi->nick, u, LANG_INVITE_IS_ON);
} else
noticeLang(ci->bi->nick, u, LANG_INVITE_YOURSELF);
} else
noticeLang(ci->bi->nick, u, LANG_INVITE_NO_USER);
} else
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
}
return MOD_CONT;
}
/**
* Handle unban fantasy command.
* @param argc Argument count
* @param argv Argument list
* @return MOD_CONT or MOD_STOP
**/
static int do_fantasy(int argc, char **argv)
{
User *u;
ChannelInfo *ci;
char *target = NULL;
if (argc < 3)
return MOD_CONT;
if (stricmp(argv[0], "unban") == 0) {
u = finduser(argv[1]);
ci = cs_findchan(argv[2]);
if (!u || !ci || !check_access(u, ci, CA_UNBAN))
return MOD_CONT;
if (argc >= 4)
target = myStrGetToken(argv[3], ' ', 0);
if (!target)
common_unban_full(ci, u->nick, true);
else
common_unban(ci, target);
/* free target if needed (#852) */
Anope_Free(target);
}
return MOD_CONT;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
User *u = source.u;
const Anope::string &nick = !params.empty() ? params[0] : u->nick;
NickAlias *na = findnick(nick);
spacesepstream sep(nick);
Anope::string nickbuf;
while (sep.GetToken(nickbuf))
{
User *u2 = finduser(nickbuf);
if (!u2) /* Nick is not online */
source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 0, "");
else if (u2->IsIdentified() && na && na->nc == u2->Account()) /* Nick is identified */
source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 3, u2->Account()->display.c_str());
else if (u2->IsRecognized()) /* Nick is recognised, but NOT identified */
source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 2, u2->Account() ? u2->Account()->display.c_str() : "");
else if (!na) /* Nick is online, but NOT a registered */
source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 0, "");
else
/* Nick is not identified for the nick, but they could be logged into an account,
* so we tell the user about it
*/
source.Reply(_("STATUS %s %d %s"), nickbuf.c_str(), 1, u2->Account() ? u2->Account()->display.c_str() : "");
}
return;
}
/**
* handle the MKICK command
*/
void cs_mkick(char *src, int ac, char **av) {
if (ac < 2) {
notice(cs_name, src, CS_MKICK_ERR_USAGE);
notice(cs_name, src, CS_RPL_HLP, cs_name, "MKICK");
return;
}
char *chan = sstrdup(av[1]);
char *reason = sstrdup(av[2]);
user *u = finduser(src);
if (!isregcs(chan)) {
notice(cs_name, src, CS_ERR_NOTREG, chan);
return;
}
ChanInfo *c = findchan(chan);
if (cs_xop_get_level(u, c) < cs_mkick_access) {
notice(cs_name, src, CS_XOP_ERR_HIGHERACCESS, get_opacc(cs_mkick_access));
return;
}
channel *channel = findchannel(chan);
int relevant_count;
if(channel->bot) {
relevant_count = 1;
} else {
relevant_count = 0;
}
if(channel->ucnt<relevant_count) {
notice(cs_name,src,CS_MKICK_RPL_NOUSERS,chan);
return;
}
char final_reason[256];
sprintf(final_reason,"MKICK Command used by %s (%s)",src,reason);
do_mkick(channel,final_reason);
return;
}
void do_kill(char *nick, char *msg)
{
User *user;
NickAlias *na;
user = finduser(nick);
if (!user) {
if (debug) {
alog("debug: KILL of nonexistent nick: %s", nick);
}
return;
}
if (debug) {
alog("debug: %s killed", nick);
}
if ((na = user->na) && (!(na->status & NS_VERBOTEN))
&& (!(na->nc->flags & NI_SUSPENDED))
&& (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
na->last_seen = time(NULL);
if (na->last_quit)
free(na->last_quit);
na->last_quit = *msg ? sstrdup(msg) : NULL;
}
if (LimitSessions && !is_ulined(user->server->name)) {
del_session(user->host);
}
delete_user(user);
}
void do_quit(const char *source, int ac, char **av)
{
User *user;
NickAlias *na;
user = finduser(source);
if (!user) {
alog("user: QUIT from nonexistent user %s: %s", source,
merge_args(ac, av));
return;
}
if (debug) {
alog("debug: %s quits", source);
}
if ((na = user->na) && (!(na->status & NS_VERBOTEN))
&& (!(na->nc->flags & NI_SUSPENDED))
&& (na->status & (NS_IDENTIFIED | NS_RECOGNIZED))) {
na->last_seen = time(NULL);
if (na->last_quit)
free(na->last_quit);
na->last_quit = *av[0] ? sstrdup(av[0]) : NULL;
}
if (LimitSessions && !is_ulined(user->server->name)) {
del_session(user->host);
}
delete_user(user);
}
void common_unban2(ChannelInfo * ci, char *nick) {
User *u;
char *av[3], **bans;
int count, i;
if (!ci || !nick)
return;
else if (!(u = finduser(nick)))
return;
av[0] = ci->name;
av[1] = sstrdup("-b");
count = ci->c->bancount;
bans = scalloc(sizeof(char *) * count, 1);
memcpy(bans, ci->c->bans, sizeof(char *) * count);
for (i = 0; i < count; i++) {
if (match_usermask2(bans[i], u)) {
anope_cmd_mode(whosends(ci), ci->name, "-b %s", bans[i]);
av[2] = bans[i];
do_cmode(whosends(ci), 3, av);
}
}
free(bans);
free(av[1]);
}
/*
* ENCAP handler
* av[0] = servermask (not used)
* av[1] = command
* av[2] and beyond are dynamic.
*/
int
anope_event_encap (char *source, int ac, char **av)
{
if (ac < 2)
return MOD_CONT;
if (!stricmp (av[1], "CHGHOST"))
{
User *u;
if (ac != 4)
return MOD_CONT;
u = finduser (av[2]);
if (!u)
{
if (debug)
{
alog ("debug: CHGHOST for nonexistent user %s", av[2]);
}
return MOD_CONT;
}
change_user_host (u, av[3]);
return MOD_CONT;
}
return MOD_CONT;
}
void operserv(const char *source, char *buf)
{
char *cmd;
char *s;
User *u;
u = finduser(source);
if (!u) {
log("%s: user record for %s not found", s_OperServ, source);
notice(s_OperServ, source,
getstring(0, USER_RECORD_NOT_FOUND));
return;
}
log("%s: %s: %s", s_OperServ, source, buf);
snoop(s_OperServ, "[OS] %s (%s@%s): %s", u->nick, u->username,
u->host, buf);
cmd = strtok(buf, " ");
if (!cmd) {
return;
} else if (stricmp(cmd, "\1PING") == 0) {
if (!(s = strtok(NULL, "")))
s = "\1";
notice(s_OperServ, source, "\1PING %s", s);
} else if (stricmp(cmd, "\1VERSION\1") == 0) {
notice(s_OperServ, source, "\1VERSION Blitzed-Based OFTC IRC Services v%s\1",
VERSION);
} else {
run_cmd(s_OperServ, u, cmds, cmd);
}
}
int do_redirect (User *u) {
char *buf = moduleGetLastBuffer();
User *target= NULL;
Channel *c;
ChannelInfo *ci;
char *nick = myStrGetToken (buf,' ', 0);
char *chan1 = myStrGetToken (buf,' ', 1);
char *chan2 = myStrGetToken (buf,' ', 2);
if (!u ||!chan1||!nick||!chan2)
{
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
return MOD_STOP;
}
if (!(target = finduser(nick)))
{
notice (s_OperServ, u->nick,"No such user to redirect");
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
return MOD_STOP;
}
if (!(ci = cs_findchan(chan1)))
{
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
return MOD_STOP;
}
if (!(c = findchan(ci->name)))
{
notice (s_OperServ, u->nick,"No such channel to be redirected from.");
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
return MOD_STOP;
}
if (!(is_on_chan(c,target)))
{
notice (s_OperServ, u->nick,"User %s is not in this channel", target->nick);
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
return MOD_STOP;
}
notice (s_OperServ, u->nick,"Redirecting user %s from channel %s to channel %s",target->nick,chan1,chan2);
wallops(c->ci->bi->nick, "%s redirected %s from channel %s to channel %s .", u->nick, nick, c->name , chan2);
anope_cmd_svspart(c->ci->bi->nick, nick, c->name);
anope_cmd_svsjoin(s_OperServ, target->nick, chan2, NULL);
notice (s_OperServ, target->nick,"You have been redirected from channel %s to channel %s by operator %s", chan1,chan2,u->nick);
if (nick) free(nick);
if (chan1) free(chan1);
if (chan2) free(chan2);
/* Halt processing */
return MOD_STOP;
}
/**
* Handle kickban/kb fantasy commands.
* @param argc Argument count
* @param argv Argument list
* @return MOD_CONT or MOD_STOP
**/
int do_fantasy(int argc, char **argv)
{
User *u, *u2;
ChannelInfo *ci;
char *target = NULL;
char *reason = NULL;
if (argc < 3)
return MOD_CONT;
if ((stricmp(argv[0], "kickban") == 0)
|| (stricmp(argv[0], "kb") == 0)) {
u = finduser(argv[1]);
ci = cs_findchan(argv[2]);
if (!u || !ci)
return MOD_CONT;
if (argc >= 4) {
target = myStrGetToken(argv[3], ' ', 0);
reason = myStrGetTokenRemainder(argv[3], ' ', 1);
}
if (!target && check_access(u, ci, CA_BANME)) {
bot_raw_ban(u, ci, u->nick, "Requested");
} else if (target && check_access(u, ci, CA_BAN)) {
if (stricmp(target, ci->bi->nick) == 0) {
bot_raw_ban(u, ci, u->nick, "Oops!");
} else {
u2 = finduser(target);
if (u2 && ci->c && is_on_chan(ci->c, u2)) {
if (!reason && !is_protected(u2))
bot_raw_ban(u, ci, target, "Requested");
else if (!is_protected(u2))
bot_raw_ban(u, ci, target, reason);
}
}
}
}
if (target)
free(target);
if (reason)
free(reason);
return MOD_CONT;
}
bool IRCdMessage::OnAway(const Anope::string &source, const std::vector<Anope::string> ¶ms)
{
User *u = finduser(source);
if (u)
{
FOREACH_MOD(I_OnUserAway, OnUserAway(u, params.empty() ? "" : params[0]));
}
return true;
}
/**
* The /ns logout command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_logout(User * u)
{
char *nick = strtok(NULL, " ");
char *param = strtok(NULL, " ");
User *u2;
if (!is_services_admin(u) && nick) {
syntax_error(s_NickServ, u, "LOGOUT", NICK_LOGOUT_SYNTAX);
} else if (!(u2 = (nick ? finduser(nick) : u))) {
notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
} else if (!u2->na) {
if (nick)
notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
else
notice_lang(s_NickServ, u, NICK_NOT_REGISTERED);
} else if (u2->na->status & NS_VERBOTEN) {
notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, u2->na->nick);
} else if (!nick && !nick_identified(u)) {
notice_lang(s_NickServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
} else if (nick && is_services_admin(u2)) {
notice_lang(s_NickServ, u, NICK_LOGOUT_SERVICESADMIN, nick);
} else {
if (nick && param && !stricmp(param, "REVALIDATE")) {
cancel_user(u2);
validate_user(u2);
} else {
u2->na->status &= ~(NS_IDENTIFIED | NS_RECOGNIZED);
}
if (ircd->modeonreg) {
common_svsmode(u2, ircd->modeonunreg, "1");
}
u->isSuperAdmin = 0; /* Dont let people logout and remain a SuperAdmin */
alog("%s: %s!%s@%s logged out nickname %s", s_NickServ, u->nick,
u->username, u->host, u2->nick);
if (nick)
notice_lang(s_NickServ, u, NICK_LOGOUT_X_SUCCEEDED, nick);
else
notice_lang(s_NickServ, u, NICK_LOGOUT_SUCCEEDED);
/* Stop nick tracking if enabled */
if (NSNickTracking)
/* Shouldn't this be u2? -GD */
nsStopNickTracking(u);
/* Clear any timers again */
if (u->na->nc->flags & NI_KILLPROTECT) {
del_ns_timeout(u->na, TO_COLLIDE);
}
/* Send out an event */
send_event(EVENT_NICK_LOGOUT, 1, u2->nick);
}
return MOD_CONT;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string &chan = params[0];
User *u = source.u;
Channel *c = findchan(chan);
if (!c)
{
source.Reply(CHAN_X_NOT_IN_USE, chan.c_str());
return;
}
ChannelInfo *ci = c->ci;
if (!ci)
{
source.Reply(CHAN_X_NOT_REGISTERED, chan.c_str());
return;
}
if (!ci->AccessFor(u).HasPriv("INVITE") && !u->HasCommand("chanserv/invite"))
{
source.Reply(ACCESS_DENIED);
return;
}
User *u2;
if (params.size() == 1)
u2 = u;
else
{
if (!(u2 = finduser(params[1])))
{
source.Reply(NICK_X_NOT_IN_USE, params[1].c_str());
return;
}
}
if (c->FindUser(u2))
{
if (u2 == u)
source.Reply(_("You are already in \002%s\002!"), c->name.c_str());
else
source.Reply(_("\002%s\002 is already in \002%s\002!"), u2->nick.c_str(), c->name.c_str());
}
else
{
bool override = !ci->AccessFor(u).HasPriv("INVITE");
ircdproto->SendInvite(ci->WhoSends(), chan, u2->nick);
if (u2 != u)
{
source.Reply(_("\002%s\002 has been invited to \002%s\002."), u2->nick.c_str(), c->name.c_str());
Log(override ? LOG_OVERRIDE : LOG_COMMAND, u, this, ci) << "for " << u2->nick;
}
else
{
void plexus_cmd_notice(char *source, char *dest, char *buf)
{
Uid *ud;
User *u;
ud = find_uid(source);
u = finduser(dest);
send_cmd((UseTS6 ? (ud ? ud->uid : source) : source),
"NOTICE %s :%s", (UseTS6 ? (u ? u->uid : dest) : dest), buf);
}
static int do_qakill_some_lameass(User * u)
{
char *to_be_akilled, *reason;
char reasonx[512];
char mask[USERMAX + HOSTMAX + 2];
User *target;
to_be_akilled = strtok(NULL, " ");
reason = strtok(NULL, "");
if (!is_services_admin(u)) {
notice(s_OperServ, u->nick, "Access Denied");
return MOD_STOP;
}
if (to_be_akilled) {
if (!reason) {
reason = "You have been AKILLED";
}
if (AddAkiller) {
snprintf(reasonx, sizeof(reasonx), "[%s] %s", u->nick, reason);
}
if ((target = finduser(to_be_akilled))) {
sprintf(mask, "*@%s", target->host);
#ifdef DISABLE_LOWER_QAKILL
if ((is_services_admin(target)) && (!is_services_root(u))) {
notice(s_OperServ, u->nick, "Permission Denied");
#ifndef ANOPE17x
wallops(s_OperServ, "%s attempted to QAKILL %s (%s)", u->nick, target->nick, reasonx);
#else
anope_cmd_global(s_OperServ, "%s attempted to QAKILL %s (%s)", u->nick, target->nick, reasonx);
#endif
return MOD_STOP;
}
#endif
add_akill(u, mask, u->nick, time(NULL)+AutokillExpiry, reason);
if (WallOSAkill) {
#ifndef ANOPE17x
wallops(s_OperServ, "%s used QAKILL on %s (%s)", u->nick, target->nick, reasonx);
#else
anope_cmd_global(s_OperServ, "%s used QAKILL on %s (%s)", u->nick, target->nick, reasonx);
#endif
}
if (!AkillOnAdd) {
kill_user(s_OperServ, target->nick, reasonx);
}
}
else {
notice_lang(s_OperServ, u, NICK_X_NOT_IN_USE, to_be_akilled);
}
}
else {
notice(s_OperServ, u->nick, "See /msg OperServ HELP QAKILL for more info.");
}
return MOD_CONT;
}
static void do_killclones(User * u)
{
char killreason[NICKMAX + 32];
char akillreason[] = "Temporary KILLCLONES akill.";
int count;
char *clonenick, *clonemask, *akillmask;
User *cloneuser, *user, *tempuser;
clonenick = strtok(NULL, " ");
count = 0;
if (!clonenick) {
notice_lang(s_OperServ, u, OPER_KILLCLONES_SYNTAX);
} else if (!(cloneuser = finduser(clonenick))) {
notice_lang(s_OperServ, u, OPER_KILLCLONES_UNKNOWN_NICK,
clonenick);
} else {
clonemask = smalloc(strlen(cloneuser->host) + 5);
sprintf(clonemask, "*!*@%s", cloneuser->host);
akillmask = smalloc(strlen(cloneuser->host) + 3);
sprintf(akillmask, "*@%s", strlower(cloneuser->host));
user = firstuser();
while (user) {
if (match_usermask(clonemask, user) != 0) {
tempuser = nextuser();
count++;
snprintf(killreason, sizeof(killreason),
"Cloning [%d]", count);
kill_user(NULL, user->nick, killreason);
user = tempuser;
} else {
user = nextuser();
}
}
add_akill(akillmask, akillreason, u->nick,
time(NULL) + (60 * 60 * 6));
wallops(s_OperServ, "\2%s\2 used KILLCLONES for \2%s\2 "
"killing \2%d\2 clones. A temporary AKILL has been "
"added for \2%s\2.", u->nick, clonemask, count,
akillmask);
log("%s: KILLCLONES: %d clone(s) matching %s killed.",
s_OperServ, count, clonemask);
free(akillmask);
free(clonemask);
}
}
void asuka_cmd_privmsg(char *source, char *dest, char *buf)
{
User *u;
Uid *ud;
u = finduser(dest);
ud = find_uid(source);
send_cmd((ud ? ud->uid : source), "P %s :%s", (u ? u->uid : dest),
buf);
}
void nefarious_cmd_notice(char *source, char *dest, char *buf)
{
User *u;
Uid *ud;
u = finduser(dest);
ud = find_uid(source);
send_cmd((ud ? ud->uid : source), "O %s :%s", (u ? u->uid : dest),
buf);
}
/**
* handle the DEOP command
*/
void cs_deop(char *src, int ac, char **av) {
char *nick,*chan;
int level_src,level_target;
user *u,*u1;
ChanInfo *c;
if(ac<3) {
notice(cs_name,src,CS_OP_ERR_USAGE,"DEOP");
notice(cs_name,src,CS_RPL_HLP,cs_name, "DEOP");
return;
}
nick = sstrdup(av[2]);
chan = sstrdup(av[1]);
if(!isregcs(chan)) {
notice(cs_name,src,CS_ERR_NOTREG,chan);
return;
}
if(!isreg(nick)) {
notice(cs_name,src,NS_ERR_NOTREG,nick);
return;
}
u = finduser(src);
u1 = finduser(nick);
c = findchan(chan);
level_src = cs_xop_get_level(u,c);
level_target = cs_xop_get_level(u1,c);
if(level_src<AOP_LIST) {
notice(cs_name,src,CS_XOP_ERR_HIGHERACCESS,"Aop");
return;
}
if(level_target<AOP_LIST) {
if(stricmp(src,nick)==0) {
notice(cs_name,src,CS_XOP_ERR_HIGHERACCESS,"Aop");
return;
} else {
notice(cs_name,src,CS_XOP_ERR_HIGHERACCESS2,nick);
return;
}
}
deop(cs_name,nick,chan);
return;
}
EventReturn OnChannelModeSet(Channel *c, ChannelModeName Name, const Anope::string ¶m)
{
if (Name == CMODE_OP && c && c->ci && c->name.equals_ci(this->HelpChan))
{
User *u = finduser(param);
if (u && c->ci->AccessFor(u).HasPriv("OPDEOPME"))
u->SetMode(findbot(Config->OperServ), UMODE_HELPOP);
}
return EVENT_CONTINUE;
}
int do_on_join(int argc, char **argv) {
User *u;
Channel *c = NULL;
int status;
char *tmp;
if (!AutoOwner)
return MOD_CONT;
if (argc != 3)
return MOD_CONT;
if (stricmp(argv[0], EVENT_STOP))
return MOD_CONT;
if (UseTS6 && ircd->ts6) {
u = find_byuid(argv[1]);
if (!u)
u = finduser(argv[1]);
} else
u = finduser(argv[1]);
c = findchan(argv[2]);
if (!c || !c->ci)
return MOD_CONT; /* chan not registered */
if (!u || !nick_identified(u))
return MOD_CONT; /* user not found/identified */
status = chan_get_user_status(c, u);
if ((get_access_level(c->ci, u->na) >= AutoOwnerLevel) && (!is_founder(u,c->ci))) {
if (!(status & CUS_OWNER)) {
tmp = stripModePrefix(ircd->ownerset);
xanadu_cmd_mode(whosends(c->ci), c->name, "+%s %s", tmp, u->nick);
if (tmp) free(tmp);
chan_set_user_status(c, u, CUS_OWNER);
}
}
return MOD_CONT;
}
/* SVSNICK */
void
plexus_cmd_svsnick (char *nick, char *newnick, time_t when)
{
User *u;
if (!nick || !newnick)
return;
if( (u = finduser (nick))) {
send_cmd (ServerName, "ENCAP * SVSNICK %s %ld %s %ld",
u->nick, (long int) u->timestamp, newnick, (long int) when);
}
}
void do_umode2(const char *source, int ac, char **av)
{
User *user;
user = finduser(source);
if (!user) {
alog("user: MODE %s for nonexistent nick %s: %s", av[0], source,
merge_args(ac, av));
return;
}
anope_set_umode(user, ac, &av[0]);
}
