/**
* 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;
}
int do_getpass(User * u)
{
char *chan = strtok(NULL, " ");
char tmp_pass[PASSMAX];
ChannelInfo *ci;
if (!chan) {
syntax_error(s_ChanServ, u, "GETPASS", CHAN_GETPASS_SYNTAX);
} else if (!(ci = cs_findchan(chan))) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, chan);
} else if (CSRestrictGetPass && !is_services_root(u)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
} else {
if(enc_decrypt(ci->founderpass,tmp_pass,PASSMAX)==1) {
alog("%s: %s!%s@%s used GETPASS on %s",
s_ChanServ, u->nick, u->username, u->host, ci->name);
if (WallGetpass) {
xanadu_cmd_global(s_ChanServ,
"\2%s\2 used GETPASS on channel \2%s\2",
u->nick, chan);
}
notice_lang(s_ChanServ, u, CHAN_GETPASS_PASSWORD_IS,
chan, ci->founderpass);
} else {
notice_lang(s_ChanServ, u, CHAN_GETPASS_UNAVAILABLE);
}
}
return MOD_CONT;
}
/**
* The /bs say command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_say(User * u)
{
ChannelInfo *ci;
char *chan = strtok(NULL, " ");
char *text = strtok(NULL, "");
if (!chan || !text)
syntax_error(s_BotServ, u, "SAY", BOT_SAY_SYNTAX);
else if (!(ci = cs_findchan(chan)))
notice_lang(s_BotServ, u, CHAN_X_NOT_REGISTERED, chan);
else if (ci->flags & CI_VERBOTEN)
notice_lang(s_BotServ, u, CHAN_X_FORBIDDEN, chan);
else if (!ci->bi)
notice_help(s_BotServ, u, BOT_NOT_ASSIGNED);
else if (!ci->c || ci->c->usercount < BSMinUsers)
notice_lang(s_BotServ, u, BOT_NOT_ON_CHANNEL, ci->name);
else if (!check_access(u, ci, CA_SAY))
notice_lang(s_BotServ, u, ACCESS_DENIED);
else {
if (text[0] != '\001') {
xanadu_cmd_privmsg(ci->bi->nick, ci->name, "%s", text);
ci->bi->lastmsg = time(NULL);
if (logchan && LogBot)
xanadu_cmd_privmsg(ci->bi->nick, LogChannel,
"SAY %s %s %s", u->nick, ci->name, text);
} else {
syntax_error(s_BotServ, u, "SAY", BOT_SAY_SYNTAX);
}
}
return MOD_CONT;
}
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;
}
static int do_unsuspend(User * u)
{
ChannelInfo *ci;
char *chan = strtok(NULL, " ");
/* Assumes that permission checking has already been done. */
if (!chan) {
syntax_error(s_ChanServ, u, "UNSUSPEND", CHAN_UNSUSPEND_SYNTAX);
return MOD_CONT;
}
if (chan[0] != '#') {
notice_lang(s_ChanServ, u, CHAN_UNSUSPEND_ERROR);
return MOD_CONT;
}
if (readonly)
notice_lang(s_ChanServ, u, READ_ONLY_MODE);
/* Only UNSUSPEND already suspended channels */
if ((ci = cs_findchan(chan)) == NULL) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
}
if (!(ci->flags & CI_SUSPENDED))
{
notice_lang(s_ChanServ, u, CHAN_UNSUSPEND_FAILED, chan);
return MOD_CONT;
}
if (ci) {
ci->flags &= ~CI_SUSPENDED;
if (ci->forbidreason)
{
free(ci->forbidreason);
ci->forbidreason = NULL;
}
if (ci->forbidby)
{
free(ci->forbidby);
ci->forbidby = NULL;
}
if (WallForbid)
anope_cmd_global(s_ChanServ,
"\2%s\2 used UNSUSPEND on channel \2%s\2",
u->nick, ci->name);
alog("%s: %s set UNSUSPEND for channel %s", s_ChanServ, u->nick,
ci->name);
notice_lang(s_ChanServ, u, CHAN_UNSUSPEND_SUCCEEDED, chan);
send_event(EVENT_CHAN_UNSUSPEND, 1, chan);
} else {
alog("%s: Valid UNSUSPEND for %s by %s failed", s_ChanServ,
chan, u->nick);
notice_lang(s_ChanServ, u, CHAN_UNSUSPEND_FAILED, chan);
}
return MOD_CONT;
}
void EntryMsg::unserialize(serialized_data &data)
{
ChannelInfo *ci = cs_findchan(data["ci"].astr());
if (!ci)
return;
EntryMessageList *messages = ci->GetExt<EntryMessageList *>("cs_entrymsg");
if (messages == NULL)
{
messages = new EntryMessageList();
ci->Extend("cs_entrymsg", messages);
}
messages->push_back(EntryMsg(ci, data["creator"].astr(), data["message"].astr()));
}
int do_chanurl(int ac, char **av)
{
ChannelInfo *ci;
char *nick = NULL;
nick = av[1];
ci = cs_findchan(av[2]);
if (ci) {
if (stricmp(av[0], EVENT_STOP) == 0) {
if (ci->url) {
send_cmd(ServerName, "328 %s %s :%s", nick, ci->name, ci->url);
}
}
}
return MOD_CONT;
}
/**
* 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;
}
MemoInfo *GetMemoInfo(const Anope::string &target, bool &ischan)
{
if (!target.empty() && target[0] == '#')
{
ischan = true;
ChannelInfo *ci = cs_findchan(target);
if (ci != NULL)
return &ci->memos;
}
else
{
ischan = false;
NickAlias *na = findnick(target);
if (na != NULL)
return &na->nc->memos;
}
return NULL;
}
int mLoadData(int argc, char **argv)
{
FILE *fp;
char *filename;
char *type = NULL;
char *name = NULL;
ChannelInfo *ci;
char buffer[1024];
if (CSAVoiceDBName) {
filename = CSAVoiceDBName;
} else {
filename = DEFAULT_DB_NAME;
}
fp = fopen(filename, "r");
if (!fp) {
if (debug)
alog("cs_autovoice: Unable to open database ('%s') for reading!", filename);
return MOD_CONT;
}
while (fgets(buffer, 1024, fp)) {
type = myStrGetToken(buffer, ' ', 0);
name = myStrGetToken(buffer, ' ', 1);
if (type) {
if (name) {
if ((ci = cs_findchan(name))) {
if (stricmp(type, "REG") == 0) {
moduleAddData(&ci->moduleData, "avoice", "REG");
} else if (stricmp(type, "ALL") == 0) {
moduleAddData(&ci->moduleData, "avoice", "ALL");
} else {
alog("cs_autovoice: Possible invalid entry [%s] in .db file, ignoring...", name);
}
}
free(name);
}
free(type);
}
}
fclose(fp);
return MOD_CONT;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
User *u = source.u;
ChannelInfo *ci = cs_findchan(params[0]);
if (ci == NULL)
{
source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str());
return;
}
if (IsFounder(u, ci) || u->HasCommand("chanserv/set"))
{
bool success = true;
if (params[1].equals_ci("LIST"))
this->DoList(source, ci);
else if (params[1].equals_ci("CLEAR"))
this->DoClear(source, ci);
else if (params.size() < 3)
{
success = false;
this->OnSyntaxError(source, "");
}
else if (params[1].equals_ci("ADD"))
this->DoAdd(source, ci, params[2]);
else if (params[1].equals_ci("DEL"))
this->DoDel(source, ci, params[2]);
else
{
success = false;
this->OnSyntaxError(source, "");
}
if (success)
Log(IsFounder(u, ci) ? LOG_COMMAND : LOG_OVERRIDE, u, this, ci) << " to " << params[1] << " a message";
}
else
source.Reply(ACCESS_DENIED);
return;
}
/**
* The /cs 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 *chan = strtok(NULL, " ");
char *nick = strtok(NULL, " ");
ChannelInfo *ci;
User *u2 = NULL;
int is_servadmin = is_services_admin(u);
if (!chan || (!nick && !is_servadmin)) {
syntax_error(s_ChanServ, u, "LOGOUT",
(!is_servadmin ? CHAN_LOGOUT_SYNTAX :
CHAN_LOGOUT_SERVADMIN_SYNTAX));
} else if (!(ci = cs_findchan(chan))) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
} else if (!is_servadmin && (ci->flags & CI_VERBOTEN)) {
notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, chan);
} else if (nick && !(u2 = finduser(nick))) {
notice_lang(s_ChanServ, u, NICK_X_NOT_IN_USE, nick);
} else if (!is_servadmin && u2 != u && !is_real_founder(u, ci)) {
notice_lang(s_ChanServ, u, ACCESS_DENIED);
} else {
if (u2) {
make_unidentified(u2, ci);
notice_lang(s_ChanServ, u, CHAN_LOGOUT_SUCCEEDED, nick, chan);
alog("%s: User %s!%s@%s has been logged out of channel %s.",
s_ChanServ, u2->nick, u2->username, u2->host, chan);
} else {
int i;
for (i = 0; i < 1024; i++)
for (u2 = userlist[i]; u2; u2 = u2->next)
make_unidentified(u2, ci);
notice_lang(s_ChanServ, u, CHAN_LOGOUT_ALL_SUCCEEDED, chan);
alog("%s: All users identified have been logged out of channel %s.", s_ChanServ, chan);
}
}
return MOD_CONT;
}
/**
* Return the MemoInfo corresponding to the given nick or channel name.
* @param name Name to check
* @param ischan - the result its a channel will be stored in here
* @param isforbid - the result if its forbidden will be stored in here
* @return `ischan' 1 if the name was a channel name, else 0.
* @return `isforbid' 1 if the name is forbidden, else 0.
*/
MemoInfo *getmemoinfo(const char *name, int *ischan, int *isforbid)
{
if (*name == '#') {
ChannelInfo *ci;
if (ischan)
*ischan = 1;
ci = cs_findchan(name);
if (ci) {
if (!(ci->flags & CI_VERBOTEN)) {
*isforbid = 0;
return &ci->memos;
} else {
*isforbid = 1;
return NULL;
}
} else {
*isforbid = 0;
return NULL;
}
} else {
NickAlias *na;
if (ischan)
*ischan = 0;
na = findnick(name);
if (na) {
if (!(na->status & NS_VERBOTEN)) {
*isforbid = 0;
return &na->nc->memos;
} else {
*isforbid = 1;
return NULL;
}
} else {
*isforbid = 0;
return NULL;
}
}
}
int mEventJoin(int argc, char **argv)
{
ChannelInfo *ci;
User *u;
NickAlias *na;
char *data = NULL;
if (argc != 3) {
return MOD_CONT;
}
if (!(u = finduser(argv[1]))) {
return MOD_CONT;
}
if (strcmp(argv[0], EVENT_STOP) == 0) {
if (u) {
if ((ci = cs_findchan(argv[2]))) {
if ((data = moduleGetData(&ci->moduleData, "avoice"))) {
if (stricmp(data, "REG") == 0) {
if ((na = findnick(u->nick))) {
if (!check_access(na->u, ci, CA_AUTOVOICE) && nick_identified(u) &&
!(na->nc->flags & NI_AUTOOP)) {
anope_cmd_mode(whosends(ci), ci->name, "+v %s", na->nick);
chan_set_user_status(ci->c, u, CUS_VOICE);
}
}
} else if (stricmp(data, "ALL") == 0) {
if (!check_access(u, ci, CA_AUTOVOICE)) {
anope_cmd_mode(whosends(ci), ci->name, "+v %s", u->nick);
chan_set_user_status(ci->c, u, CUS_VOICE);
}
}
free(data);
}
}
}
}
return MOD_CONT;
}
/**
* The /bs assign command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_assign(User * u)
{
char *chan = strtok(NULL, " ");
char *nick = strtok(NULL, " ");
BotInfo *bi;
ChannelInfo *ci;
if (readonly)
notice_lang(s_BotServ, u, BOT_ASSIGN_READONLY);
else if (!chan || !nick)
syntax_error(s_BotServ, u, "ASSIGN", BOT_ASSIGN_SYNTAX);
else if (!(bi = findbot(nick)))
notice_lang(s_BotServ, u, BOT_DOES_NOT_EXIST, nick);
else if (bi->flags & BI_PRIVATE && !is_oper(u))
notice_lang(s_BotServ, u, PERMISSION_DENIED);
else if (!(ci = cs_findchan(chan)))
notice_lang(s_BotServ, u, CHAN_X_NOT_REGISTERED, chan);
else if (ci->flags & CI_VERBOTEN)
notice_lang(s_BotServ, u, CHAN_X_FORBIDDEN, chan);
else if ((ci->bi) && (stricmp(ci->bi->nick, nick) == 0))
notice_lang(s_BotServ, u, BOT_ASSIGN_ALREADY, ci->bi->nick, chan);
else if ((ci->botflags & BS_NOBOT)
|| (!check_access(u, ci, CA_ASSIGN) && !is_services_admin(u)))
notice_lang(s_BotServ, u, PERMISSION_DENIED);
else {
if (ci->bi)
unassign(u, ci);
ci->bi = bi;
bi->chancount++;
if (ci->c && ci->c->usercount >= BSMinUsers) {
bot_join(ci);
}
notice_lang(s_BotServ, u, BOT_ASSIGN_ASSIGNED, bi->nick, ci->name);
send_event(EVENT_BOT_ASSIGN, 2, ci->name, bi->nick);
}
return MOD_CONT;
}
/**
* Handle all csmodeutils fantasy commands.
* @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;
CSModeUtil *util = csmodeutils;
char *target;
if (argc < 3)
return MOD_CONT;
do {
if (stricmp(argv[0], util->bsname) == 0) {
/* This could have been moved to its own module
however it would require more coding to handle the pass holders
similar to how PROTECT is done
*/
if (!ircd->halfop) {
if (!stricmp(argv[0], "halfop") || !stricmp(argv[0], "dehalfop")) {
return MOD_CONT;
}
}
u = finduser(argv[1]);
ci = cs_findchan(argv[2]);
if (!u || !ci)
return MOD_CONT;
target = ((argc == 4) ? argv[3] : NULL);
if (!target && check_access(u, ci, util->levelself))
bot_raw_mode(u, ci, util->mode, u->nick);
else if (target && check_access(u, ci, util->level))
bot_raw_mode(u, ci, util->mode, target);
}
} while ((++util)->name != NULL);
return MOD_CONT;
}
/**
* The /cs register command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_register(User * u)
{
char *chan = strtok(NULL, " ");
char *pass = strtok(NULL, " ");
char *desc = strtok(NULL, "");
NickCore *nc;
Channel *c;
ChannelInfo *ci;
struct u_chaninfolist *uc;
int is_servadmin = is_services_admin(u);
char founderpass[PASSMAX + 1];
char tmp_pass[PASSMAX];
if (readonly) {
notice_lang(s_ChanServ, u, CHAN_REGISTER_DISABLED);
return MOD_CONT;
}
if (checkDefCon(DEFCON_NO_NEW_CHANNELS)) {
notice_lang(s_ChanServ, u, OPER_DEFCON_DENIED);
return MOD_CONT;
}
if (!desc) {
syntax_error(s_ChanServ, u, "REGISTER", CHAN_REGISTER_SYNTAX);
} else if (*chan == '&') {
notice_lang(s_ChanServ, u, CHAN_REGISTER_NOT_LOCAL);
} else if (*chan != '#') {
notice_lang(s_ChanServ, u, CHAN_SYMBOL_REQUIRED);
} else if (!xanadu_valid_chan(chan)) {
notice_lang(s_ChanServ, u, CHAN_X_INVALID, chan);
} else if (!u->na || !(nc = u->na->nc)) {
notice_lang(s_ChanServ, u, CHAN_MUST_REGISTER_NICK, s_NickServ);
} else if (!nick_recognized(u)) {
notice_lang(s_ChanServ, u, CHAN_MUST_IDENTIFY_NICK, s_NickServ,
s_NickServ);
} else if (!(c = findchan(chan))) {
notice_lang(s_ChanServ, u, CHAN_REGISTER_NONE_CHANNEL, chan);
} else if ((ci = cs_findchan(chan)) != NULL) {
if (ci->flags & CI_VERBOTEN) {
alog("%s: Attempt to register FORBIDden channel %s by %s!%s@%s", s_ChanServ, ci->name, u->nick, u->username, u->host);
notice_lang(s_ChanServ, u, CHAN_MAY_NOT_BE_REGISTERED, chan);
} else {
notice_lang(s_ChanServ, u, CHAN_ALREADY_REGISTERED, chan);
}
} else if (!stricmp(chan, "#")) {
notice_lang(s_ChanServ, u, CHAN_MAY_NOT_BE_REGISTERED, chan);
} else if (!chan_has_user_status(c, u, CUS_OP)) {
notice_lang(s_ChanServ, u, CHAN_MUST_BE_CHANOP);
} else if (!is_servadmin && nc->channelmax > 0
&& nc->channelcount >= nc->channelmax) {
notice_lang(s_ChanServ, u,
nc->channelcount >
nc->
channelmax ? CHAN_EXCEEDED_CHANNEL_LIMIT :
CHAN_REACHED_CHANNEL_LIMIT, nc->channelmax);
} else if (stricmp(u->nick, pass) == 0
|| (StrictPasswords && strlen(pass) < 5)) {
notice_lang(s_ChanServ, u, MORE_OBSCURE_PASSWORD);
} else if (!(ci = makechan(chan))) {
alog("%s: makechan() failed for REGISTER %s", s_ChanServ, chan);
notice_lang(s_ChanServ, u, CHAN_REGISTRATION_FAILED);
} else if (strscpy(founderpass, pass, PASSMAX + 1),
enc_encrypt_in_place(founderpass, PASSMAX) < 0) {
alog("%s: Couldn't encrypt password for %s (REGISTER)",
s_ChanServ, chan);
notice_lang(s_ChanServ, u, CHAN_REGISTRATION_FAILED);
delchan(ci);
} else {
c->ci = ci;
ci->c = c;
ci->bantype = CSDefBantype;
ci->flags = CSDefFlags;
ci->mlock_on = ircd->defmlock;
ci->memos.memomax = MSMaxMemos;
ci->last_used = ci->time_registered;
ci->founder = nc;
if (strlen(pass) > PASSMAX)
notice_lang(s_ChanServ, u, PASSWORD_TRUNCATED, PASSMAX);
memset(pass, 0, strlen(pass));
memcpy(ci->founderpass, founderpass, PASSMAX);
ci->desc = sstrdup(desc);
if (c->topic) {
ci->last_topic = sstrdup(c->topic);
strscpy(ci->last_topic_setter, c->topic_setter, NICKMAX);
ci->last_topic_time = c->topic_time;
} else {
/* Set this to something, otherwise it will maliform the topic */
strscpy(ci->last_topic_setter, s_ChanServ, NICKMAX);
}
ci->bi = NULL;
ci->botflags = BSDefFlags;
ci->founder->channelcount++;
alog("%s: Channel '%s' registered by %s!%s@%s", s_ChanServ, chan,
u->nick, u->username, u->host);
notice_lang(s_ChanServ, u, CHAN_REGISTERED, chan, u->nick);
if(enc_decrypt(ci->founderpass,tmp_pass,PASSMAX) == 1) {
notice_lang(s_ChanServ, u, CHAN_PASSWORD_IS, ci->founderpass);
}
uc = scalloc(sizeof(*uc), 1);
uc->next = u->founder_chans;
uc->prev = NULL;
if (u->founder_chans)
u->founder_chans->prev = uc;
u->founder_chans = uc;
uc->chan = ci;
/* Implement new mode lock */
check_modes(c);
/* On most ircds you do not receive the admin/owner mode till its registered */
if (ircd->admin) {
xanadu_cmd_mode(s_ChanServ, chan, "%s %s", ircd->adminset,
u->nick);
}
if (ircd->owner && ircd->ownerset) {
xanadu_cmd_mode(s_ChanServ, chan, "%s %s", ircd->ownerset,
u->nick);
}
send_event(EVENT_CHAN_REGISTERED, 1, chan);
}
return MOD_CONT;
}
int do_avoice(User *u)
{
char *buf = moduleGetLastBuffer();
char *chan = myStrGetToken(buf, ' ', 0);
char *option = myStrGetTokenRemainder(buf, ' ', 1);
char *data;
ChannelInfo *ci;
if (!chan) {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_SYNTAX);
return MOD_CONT;
}
if ((ci = cs_findchan(chan))) {
if (!check_access(u, ci, CA_PROTECT)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
if (chan) free(chan);
if (option) free(option);
return MOD_CONT;
}
if (!option) {
if ((data = moduleGetData(&ci->moduleData, "avoice"))) {
if (stricmp(data, "REG") == 0) {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_REG, chan);
} else if (stricmp(data, "ALL") == 0) {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_ALL, chan);
}
free(data);
} else {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_OFF, chan);
}
} else {
if (stricmp(option, "REG") == 0) {
moduleAddData(&ci->moduleData, "avoice", "REG");
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_SET_REG, chan);
} else if (stricmp(option, "ALL") == 0) {
moduleAddData(&ci->moduleData, "avoice", "ALL");
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_SET_ALL, chan);
} else if (stricmp(option, "OFF") == 0) {
moduleDelData(&ci->moduleData, "avoice");
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_SET_OFF, chan);
} else if (stricmp(option, "STATUS") == 0) {
if ((data = moduleGetData(&ci->moduleData, "avoice"))) {
if (stricmp(data, "REG") == 0) {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_REG, chan);
} else if (stricmp(data, "ALL") == 0) {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_ALL, chan);
}
free(data);
} else {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_STATUS_OFF, chan);
}
} else {
moduleNoticeLang(s_ChanServ, u, CS_AUTOVOICE_SYNTAX);
}
}
} else {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
}
if (chan)
free(chan);
if (option)
free(option);
return MOD_CONT;
}
int fantasy_defkick(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], "help"))
{
u = finduser(argv[1]);
if (argc >= 4)
{
int ret = MOD_CONT;
char *cmd, *param;
cmd = myStrGetToken(argv[3],' ',0);
param = myStrGetToken(argv[3],' ',1);
if (!stricmp(cmd, "kickr"))
{
notice(s_BotServ, u->nick, "\037Syntax\037: \002!kickr [NICK] [TRIGGER]\002 or");
notice(s_BotServ, u->nick, "\037Syntax\037: \002!kr [NICK] [TRIGGER]\002");
notice(s_BotServ, u->nick, "(For example: !kr VisioN idling or !kickr VisioN idling)");
notice(s_BotServ, u->nick, "\n");
notice(s_BotServ, u->nick, "----------------------------------------------------------------------------------------------------------");
notice(s_BotServ, u->nick, "\n");
notice(s_BotServ, u->nick, "\037Description\037: This command allows you to kick a user from a channel, using the bot's default kick reasons.");
notice(s_BotServ, u->nick, "The bot supports multipule kick reasons for each of the basic abuses for channels, a list of which");
notice(s_BotServ, u->nick, "you can find below.");
notice(s_BotServ, u->nick, "\n");
notice(s_BotServ, u->nick, "List of triggers:");
notice(s_BotServ, u->nick, "\037\002Name\002\037 \037\002Description\002\037");
notice(s_BotServ, u->nick, "badlang Kicks for bad language (insults etc)");
notice(s_BotServ, u->nick, "caps Kicks for capital letters ");
notice(s_BotServ, u->nick, "flood Kicks for channel flooding ");
notice(s_BotServ, u->nick, "bold Kicks for bold letters ");
notice(s_BotServ, u->nick, "advertise Kicks for Spam/Advertising ");
notice(s_BotServ, u->nick, "repeat Kicks for repetition ");
notice(s_BotServ, u->nick, "idle Kicks for idling (mostly for help chans) ");
notice(s_BotServ, u->nick, "badnick Kicks for bad nicknames ");
ret = MOD_CONT;
}
free(cmd);
if (param) free(param);
return ret;
}
}
else if ((stricmp(argv[0], "kickr") == 0) || (stricmp(argv[0], "kr") == 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 (!check_access(u, ci, CA_KICK))
{
notice(s_BotServ, u->nick, "You are not authorised to kick the selected user.");
}
else if (!target && check_access(u, ci, CA_KICKME))
{
notice(s_BotServ, u->nick, "\037Syntax\037: \002!kickr [NICK] [TRIGGER]\002 or");
notice(s_BotServ, u->nick, "\037Syntax\037: \002!kr [NICK] [TRIGGER]\002");
notice(s_BotServ, u->nick, "For detailed information about this command and");
notice(s_BotServ, u->nick, "for a list of triggers, type \002!help kickr\002");
}
else if (target && check_access(u, ci, CA_KICK))
{
if (!stricmp(target, ci->bi->nick))
bot_raw_kick(u, ci, u->nick, "Wrong Move!");
else
{
u2 = finduser(target);
if (u2 && ci->c && is_on_chan(ci->c, u2))
{
if (!reason && !is_protected(u2))
bot_raw_kick(u, ci, target, "Requested");
else if (!is_protected(u2))
{
if ((stricmp(reason , "badlang") == 0))
bot_raw_kick(u, ci, target, BADLANG);
else if ((stricmp(reason , "caps") == 0))
bot_raw_kick(u, ci, target, CAPS);
else if ((stricmp(reason , "flood") == 0))
bot_raw_kick(u, ci, target, FLOOD);
else if ((stricmp(reason , "bold") == 0))
bot_raw_kick(u, ci, target, BOLD);
else if ((stricmp(reason , "advertise") == 0))
bot_raw_kick(u, ci, target, ADVERTISE);
else if ((stricmp(reason , "repeat") == 0))
bot_raw_kick(u, ci, target, REPEAT);
else if ((stricmp(reason , "idle") == 0))
bot_raw_kick(u, ci, target, IDLE);
else if ((stricmp(reason , "badnick") == 0))
bot_raw_kick(u, ci, target, BADNICK);
else
{
notice(s_BotServ, u->nick, "The number you chose does not correspond to a kick reason.");
notice(s_BotServ, u->nick, "If you want to kick with your own custom reason , use !kick trigger");
}
}
}
}
}
}
if (target) free(target);
if (reason) free(reason);
return MOD_CONT;
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string &chan = params[0];
const Anope::string &chdesc = params.size() > 1 ? params[1] : "";
User *u = source.u;
Channel *c = findchan(params[0]);
ChannelInfo *ci = cs_findchan(params[0]);
if (readonly)
source.Reply(_("Sorry, channel registration is temporarily disabled."));
else if (u->Account()->HasFlag(NI_UNCONFIRMED))
source.Reply(_("You must confirm your account before you can register a channel."));
else if (chan[0] == '&')
source.Reply(_("Local channels cannot be registered."));
else if (chan[0] != '#')
source.Reply(CHAN_SYMBOL_REQUIRED);
else if (!ircdproto->IsChannelValid(chan))
source.Reply(CHAN_X_INVALID, chan.c_str());
else if (ci)
source.Reply(_("Channel \002%s\002 is already registered!"), chan.c_str());
else if (c && !c->HasUserStatus(u, CMODE_OP))
source.Reply(_("You must be a channel operator to register the channel."));
else if (Config->CSMaxReg && u->Account()->channelcount >= Config->CSMaxReg && !u->HasPriv("chanserv/no-register-limit"))
source.Reply(u->Account()->channelcount > Config->CSMaxReg ? CHAN_EXCEEDED_CHANNEL_LIMIT : _(CHAN_REACHED_CHANNEL_LIMIT), Config->CSMaxReg);
else
{
ci = new ChannelInfo(chan);
ci->SetFounder(u->Account());
if (!chdesc.empty())
ci->desc = chdesc;
ci->mode_locks = def_mode_locks;
for (ChannelInfo::ModeList::iterator it = ci->mode_locks.begin(), it_end = ci->mode_locks.end(); it != it_end; ++it)
{
it->second.setter = u->nick;
it->second.ci = ci;
}
if (c && !c->topic.empty())
{
ci->last_topic = c->topic;
ci->last_topic_setter = c->topic_setter;
ci->last_topic_time = c->topic_time;
}
else
ci->last_topic_setter = source.owner->nick;
Log(LOG_COMMAND, u, this, ci);
source.Reply(_("Channel \002%s\002 registered under your nickname: %s"), chan.c_str(), u->nick.c_str());
/* Implement new mode lock */
if (c)
{
check_modes(c);
ChannelMode *cm;
if (u->FindChannel(c) != NULL)
{
/* On most ircds you do not receive the admin/owner mode till its registered */
if ((cm = ModeManager::FindChannelModeByName(CMODE_OWNER)))
c->SetMode(NULL, cm, u->nick);
else if ((cm = ModeManager::FindChannelModeByName(CMODE_PROTECT)))
c->RemoveMode(NULL, cm, u->nick);
}
/* Mark the channel as persistent */
if (c->HasMode(CMODE_PERM))
ci->SetFlag(CI_PERSIST);
/* Persist may be in def cflags, set it here */
else if (ci->HasFlag(CI_PERSIST) && (cm = ModeManager::FindChannelModeByName(CMODE_PERM)))
c->SetMode(NULL, CMODE_PERM);
}
FOREACH_MOD(I_OnChanRegistered, OnChanRegistered(ci));
}
return;
}
/**
* The /cs (un)suspend 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_suspend(User * u)
{
ChannelInfo *ci;
char *chan = strtok(NULL, " ");
char *reason = strtok(NULL, "");
Channel *c;
/* Assumes that permission checking has already been done. */
if (!chan || (ForceForbidReason && !reason)) {
syntax_error(s_ChanServ, u, "SUSPEND",
(ForceForbidReason ? CHAN_SUSPEND_SYNTAX_REASON :
CHAN_SUSPEND_SYNTAX));
return MOD_CONT;
}
if (chan[0] != '#') {
notice_lang(s_ChanServ, u, CHAN_UNSUSPEND_ERROR);
return MOD_CONT;
}
/* Only SUSPEND existing channels, otherwise use FORBID (bug #54) */
if ((ci = cs_findchan(chan)) == NULL) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
}
/* You should not SUSPEND a FORBIDEN channel */
if (ci->flags & CI_VERBOTEN) {
notice_lang(s_ChanServ, u, CHAN_MAY_NOT_BE_REGISTERED, chan);
return MOD_CONT;
}
if (readonly)
notice_lang(s_ChanServ, u, READ_ONLY_MODE);
if (ci) {
ci->flags |= CI_SUSPENDED;
ci->forbidby = sstrdup(u->nick);
if (reason)
ci->forbidreason = sstrdup(reason);
if ((c = findchan(ci->name))) {
struct c_userlist *cu, *next;
char *av[3];
for (cu = c->users; cu; cu = next) {
next = cu->next;
if (is_oper(cu->user))
continue;
av[0] = c->name;
av[1] = cu->user->nick;
av[2] = reason ? reason : getstring(cu->user->na, CHAN_SUSPEND_REASON);
anope_cmd_kick(s_ChanServ, av[0], av[1], av[2]);
do_kick(s_ChanServ, 3, av);
}
}
if (WallForbid)
anope_cmd_global(s_ChanServ,
"\2%s\2 used SUSPEND on channel \2%s\2",
u->nick, ci->name);
alog("%s: %s set SUSPEND for channel %s", s_ChanServ, u->nick,
ci->name);
notice_lang(s_ChanServ, u, CHAN_SUSPEND_SUCCEEDED, chan);
send_event(EVENT_CHAN_SUSPENDED, 1, chan);
} else {
alog("%s: Valid SUSPEND for %s by %s failed", s_ChanServ, ci->name,
u->nick);
notice_lang(s_ChanServ, u, CHAN_SUSPEND_FAILED, chan);
}
return MOD_CONT;
}
/**
* The /ms set limit 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_set_limit(User * u, MemoInfo * mi, char *param)
{
char *p1 = strtok(param, " ");
char *p2 = strtok(NULL, " ");
char *p3 = strtok(NULL, " ");
char *user = NULL, *chan = NULL;
int32 limit;
NickAlias *na = u->na;
ChannelInfo *ci = NULL;
int is_servadmin = is_services_admin(u);
if (p1 && *p1 == '#') {
chan = p1;
p1 = p2;
p2 = p3;
p3 = strtok(NULL, " ");
if (!(ci = cs_findchan(chan))) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, chan);
return MOD_CONT;
} else if (!is_servadmin && !check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
}
if (is_servadmin) {
if (p2 && stricmp(p2, "HARD") != 0 && !chan) {
if (!(na = findnick(p1))) {
notice_lang(s_MemoServ, u, NICK_X_NOT_REGISTERED, p1);
return MOD_CONT;
}
user = p1;
mi = &na->nc->memos;
p1 = p2;
p2 = p3;
} else if (!p1) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SERVADMIN_SYNTAX);
return MOD_CONT;
}
if ((!isdigit(*p1) && stricmp(p1, "NONE") != 0) ||
(p2 && stricmp(p2, "HARD") != 0)) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SERVADMIN_SYNTAX);
return MOD_CONT;
}
if (chan) {
if (p2)
ci->flags |= CI_MEMO_HARDMAX;
else
ci->flags &= ~CI_MEMO_HARDMAX;
} else {
if (p2)
na->nc->flags |= NI_MEMO_HARDMAX;
else
na->nc->flags &= ~NI_MEMO_HARDMAX;
}
limit = atoi(p1);
if (limit < 0 || limit > 32767) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_OVERFLOW, 32767);
limit = 32767;
}
if (stricmp(p1, "NONE") == 0)
limit = -1;
} else {
if (!p1 || p2 || !isdigit(*p1)) {
syntax_error(s_MemoServ, u, "SET LIMIT",
MEMO_SET_LIMIT_SYNTAX);
return MOD_CONT;
}
if (chan && (ci->flags & CI_MEMO_HARDMAX)) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_FORBIDDEN, chan);
return MOD_CONT;
} else if (!chan && (na->nc->flags & NI_MEMO_HARDMAX)) {
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_FORBIDDEN);
return MOD_CONT;
}
limit = atoi(p1);
/* The first character is a digit, but we could still go negative
* from overflow... watch out! */
if (limit < 0 || (MSMaxMemos > 0 && limit > MSMaxMemos)) {
if (chan) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_TOO_HIGH,
chan, MSMaxMemos);
} else {
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_TOO_HIGH,
MSMaxMemos);
}
return MOD_CONT;
} else if (limit > 32767) {
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_OVERFLOW, 32767);
limit = 32767;
}
}
mi->memomax = limit;
if (limit > 0) {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s set their memo limit to %d",
s_MemoServ, u->nick, u->username, u->host, limit);
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT, limit);
} else {
alog("%s: %s!%s@%s set the memo limit for %s to %d",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user, limit);
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT,
chan ? chan : user, limit);
}
} else if (limit == 0) {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s set their memo limit to 0",
s_MemoServ, u->nick, u->username, u->host);
notice_lang(s_MemoServ, u, MEMO_SET_YOUR_LIMIT_ZERO);
} else {
alog("%s: %s!%s@%s set the memo limit for %s to 0",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user);
notice_lang(s_MemoServ, u, MEMO_SET_LIMIT_ZERO,
chan ? chan : user);
}
} else {
if (!chan && na->nc == u->na->nc) {
alog("%s: %s!%s@%s unset their memo limit",
s_MemoServ, u->nick, u->username, u->host);
notice_lang(s_MemoServ, u, MEMO_UNSET_YOUR_LIMIT);
} else {
alog("%s: %s!%s@%s unset the memo limit for %s",
s_MemoServ, u->nick, u->username, u->host,
chan ? chan : user);
notice_lang(s_MemoServ, u, MEMO_UNSET_LIMIT,
chan ? chan : user);
}
}
return MOD_CONT;
}
/**
* The /bs kick command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_kickcmd(User * u)
{
char *chan = strtok(NULL, " ");
char *option = strtok(NULL, " ");
char *value = strtok(NULL, " ");
char *ttb = strtok(NULL, " ");
ChannelInfo *ci;
if (readonly)
notice_lang(s_BotServ, u, BOT_KICK_DISABLED);
else if (!chan || !option || !value)
syntax_error(s_BotServ, u, "KICK", BOT_KICK_SYNTAX);
else if (stricmp(value, "ON") && stricmp(value, "OFF"))
syntax_error(s_BotServ, u, "KICK", BOT_KICK_SYNTAX);
else if (!(ci = cs_findchan(chan)))
notice_lang(s_BotServ, u, CHAN_X_NOT_REGISTERED, chan);
else if (ci->flags & CI_VERBOTEN)
notice_lang(s_BotServ, u, CHAN_X_FORBIDDEN, chan);
else if (!is_services_admin(u) && !check_access(u, ci, CA_SET))
notice_lang(s_BotServ, u, ACCESS_DENIED);
else if (!ci->bi)
notice_lang(s_BotServ, u, BOT_NOT_ASSIGNED);
else {
if (!stricmp(option, "BADWORDS")) {
if (!stricmp(value, "ON")) {
if (ttb) {
ci->ttb[TTB_BADWORDS] =
strtol(ttb, (char **) NULL, 10);
/* Only error if errno returns ERANGE or EINVAL or we are less then 0 - TSL */
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_BADWORDS] < 0) {
/* leaving the debug behind since we might want to know what these are */
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_BADWORDS]);
}
/* reset the value back to 0 - TSL */
ci->ttb[TTB_BADWORDS] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else {
ci->ttb[TTB_BADWORDS] = 0;
}
ci->botflags |= BS_KICK_BADWORDS;
if (ci->ttb[TTB_BADWORDS])
notice_lang(s_BotServ, u, BOT_KICK_BADWORDS_ON_BAN,
ci->ttb[TTB_BADWORDS]);
else
notice_lang(s_BotServ, u, BOT_KICK_BADWORDS_ON);
} else {
ci->botflags &= ~BS_KICK_BADWORDS;
notice_lang(s_BotServ, u, BOT_KICK_BADWORDS_OFF);
}
} else if (!stricmp(option, "BOLDS")) {
if (!stricmp(value, "ON")) {
if (ttb) {
ci->ttb[TTB_BOLDS] = strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_BOLDS] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_BOLDS]);
}
ci->ttb[TTB_BOLDS] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_BOLDS] = 0;
ci->botflags |= BS_KICK_BOLDS;
if (ci->ttb[TTB_BOLDS])
notice_lang(s_BotServ, u, BOT_KICK_BOLDS_ON_BAN,
ci->ttb[TTB_BOLDS]);
else
notice_lang(s_BotServ, u, BOT_KICK_BOLDS_ON);
} else {
ci->botflags &= ~BS_KICK_BOLDS;
notice_lang(s_BotServ, u, BOT_KICK_BOLDS_OFF);
}
} else if (!stricmp(option, "CAPS")) {
if (!stricmp(value, "ON")) {
char *min = strtok(NULL, " ");
char *percent = strtok(NULL, " ");
if (ttb) {
ci->ttb[TTB_CAPS] = strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_CAPS] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_CAPS]);
}
ci->ttb[TTB_CAPS] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_CAPS] = 0;
if (!min)
ci->capsmin = 10;
else
ci->capsmin = atol(min);
if (ci->capsmin < 1)
ci->capsmin = 10;
if (!percent)
ci->capspercent = 25;
else
ci->capspercent = atol(percent);
if (ci->capspercent < 1 || ci->capspercent > 100)
ci->capspercent = 25;
ci->botflags |= BS_KICK_CAPS;
if (ci->ttb[TTB_CAPS])
notice_lang(s_BotServ, u, BOT_KICK_CAPS_ON_BAN,
ci->capsmin, ci->capspercent,
ci->ttb[TTB_CAPS]);
else
notice_lang(s_BotServ, u, BOT_KICK_CAPS_ON,
ci->capsmin, ci->capspercent);
} else {
ci->botflags &= ~BS_KICK_CAPS;
notice_lang(s_BotServ, u, BOT_KICK_CAPS_OFF);
}
} else if (!stricmp(option, "COLORS")) {
if (!stricmp(value, "ON")) {
if (ttb) {
ci->ttb[TTB_COLORS] = strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_COLORS] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_COLORS]);
}
ci->ttb[TTB_COLORS] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_COLORS] = 0;
ci->botflags |= BS_KICK_COLORS;
if (ci->ttb[TTB_COLORS])
notice_lang(s_BotServ, u, BOT_KICK_COLORS_ON_BAN,
ci->ttb[TTB_COLORS]);
else
notice_lang(s_BotServ, u, BOT_KICK_COLORS_ON);
} else {
ci->botflags &= ~BS_KICK_COLORS;
notice_lang(s_BotServ, u, BOT_KICK_COLORS_OFF);
}
} else if (!stricmp(option, "FLOOD")) {
if (!stricmp(value, "ON")) {
char *lines = strtok(NULL, " ");
char *secs = strtok(NULL, " ");
if (ttb) {
ci->ttb[TTB_FLOOD] = strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_FLOOD] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_FLOOD]);
}
ci->ttb[TTB_FLOOD] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_FLOOD] = 0;
if (!lines)
ci->floodlines = 6;
else
ci->floodlines = atol(lines);
if (ci->floodlines < 2)
ci->floodlines = 6;
if (!secs)
ci->floodsecs = 10;
else
ci->floodsecs = atol(secs);
if (ci->floodsecs < 1 || ci->floodsecs > BSKeepData)
ci->floodsecs = 10;
ci->botflags |= BS_KICK_FLOOD;
if (ci->ttb[TTB_FLOOD])
notice_lang(s_BotServ, u, BOT_KICK_FLOOD_ON_BAN,
ci->floodlines, ci->floodsecs,
ci->ttb[TTB_FLOOD]);
else
notice_lang(s_BotServ, u, BOT_KICK_FLOOD_ON,
ci->floodlines, ci->floodsecs);
} else {
ci->botflags &= ~BS_KICK_FLOOD;
notice_lang(s_BotServ, u, BOT_KICK_FLOOD_OFF);
}
} else if (!stricmp(option, "REPEAT")) {
if (!stricmp(value, "ON")) {
char *times = strtok(NULL, " ");
if (ttb) {
ci->ttb[TTB_REPEAT] = strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_REPEAT] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_REPEAT]);
}
ci->ttb[TTB_REPEAT] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_REPEAT] = 0;
if (!times)
ci->repeattimes = 3;
else
ci->repeattimes = atol(times);
if (ci->repeattimes < 2)
ci->repeattimes = 3;
ci->botflags |= BS_KICK_REPEAT;
if (ci->ttb[TTB_REPEAT])
notice_lang(s_BotServ, u, BOT_KICK_REPEAT_ON_BAN,
ci->repeattimes, ci->ttb[TTB_REPEAT]);
else
notice_lang(s_BotServ, u, BOT_KICK_REPEAT_ON,
ci->repeattimes);
} else {
ci->botflags &= ~BS_KICK_REPEAT;
notice_lang(s_BotServ, u, BOT_KICK_REPEAT_OFF);
}
} else if (!stricmp(option, "REVERSES")) {
if (!stricmp(value, "ON")) {
if (ttb) {
ci->ttb[TTB_REVERSES] =
strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_REVERSES] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_REVERSES]);
}
ci->ttb[TTB_REVERSES] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_REVERSES] = 0;
ci->botflags |= BS_KICK_REVERSES;
if (ci->ttb[TTB_REVERSES])
notice_lang(s_BotServ, u, BOT_KICK_REVERSES_ON_BAN,
ci->ttb[TTB_REVERSES]);
else
notice_lang(s_BotServ, u, BOT_KICK_REVERSES_ON);
} else {
ci->botflags &= ~BS_KICK_REVERSES;
notice_lang(s_BotServ, u, BOT_KICK_REVERSES_OFF);
}
} else if (!stricmp(option, "UNDERLINES")) {
if (!stricmp(value, "ON")) {
if (ttb) {
ci->ttb[TTB_UNDERLINES] =
strtol(ttb, (char **) NULL, 10);
if (errno == ERANGE || errno == EINVAL
|| ci->ttb[TTB_UNDERLINES] < 0) {
if (debug) {
alog("debug: errno is %d ERANGE %d EINVAL %d ttb %d", errno, ERANGE, EINVAL, ci->ttb[TTB_UNDERLINES]);
}
ci->ttb[TTB_UNDERLINES] = 0;
notice_lang(s_BotServ, u, BOT_KICK_BAD_TTB, ttb);
return MOD_CONT;
}
} else
ci->ttb[TTB_UNDERLINES] = 0;
ci->botflags |= BS_KICK_UNDERLINES;
if (ci->ttb[TTB_UNDERLINES])
notice_lang(s_BotServ, u, BOT_KICK_UNDERLINES_ON_BAN,
ci->ttb[TTB_UNDERLINES]);
else
notice_lang(s_BotServ, u, BOT_KICK_UNDERLINES_ON);
} else {
ci->botflags &= ~BS_KICK_UNDERLINES;
notice_lang(s_BotServ, u, BOT_KICK_UNDERLINES_OFF);
}
} else
notice_help(s_BotServ, u, BOT_KICK_UNKNOWN, option);
}
return MOD_CONT;
}
/**
* The /cs forbid 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_forbid(User * u)
{
Channel *c;
ChannelInfo *ci;
char *chan = strtok(NULL, " ");
char *reason = strtok(NULL, "");
Entry *cur, *enext;
/* Assumes that permission checking has already been done. */
if (!chan || (ForceForbidReason && !reason)) {
syntax_error(s_ChanServ, u, "FORBID",
(ForceForbidReason ? CHAN_FORBID_SYNTAX_REASON :
CHAN_FORBID_SYNTAX));
return MOD_CONT;
}
if (*chan != '#') {
notice_lang(s_ChanServ, u, CHAN_SYMBOL_REQUIRED);
return MOD_CONT;
} else if (!anope_valid_chan(chan)) {
notice_lang(s_ChanServ, u, CHAN_X_INVALID, chan);
return MOD_CONT;
}
if (readonly)
notice_lang(s_ChanServ, u, READ_ONLY_MODE);
if ((ci = cs_findchan(chan)) != NULL) {
delchan(ci);
send_event(EVENT_CHAN_DROP, 1, chan);
}
ci = makechan(chan);
if (ci) {
ci->flags |= CI_VERBOTEN;
ci->forbidby = sstrdup(u->nick);
if (reason)
ci->forbidreason = sstrdup(reason);
if ((c = findchan(ci->name))) {
struct c_userlist *cu, *next;
char *av[3];
/* Before banning everyone, it might be prudent to clear +e and +I lists..
* to prevent ppl from rejoining.. ~ Viper */
if (ircd->except && c->excepts && c->excepts->count) {
av[0] = sstrdup("-e");
for (cur = c->excepts->entries; cur; cur = enext) {
enext = cur->next;
av[1] = sstrdup(cur->mask);
anope_cmd_mode(whosends(ci), chan, "-e %s", cur->mask);
chan_set_modes(whosends(ci), c, 2, av, 0);
free(av[1]);
}
free(av[0]);
}
if (ircd->invitemode && c->invites && c->invites->count) {
av[0] = sstrdup("-I");
for (cur = c->invites->entries; cur; cur = enext) {
enext = cur->next;
av[1] = sstrdup(cur->mask);
anope_cmd_mode(whosends(ci), chan, "-I %s", cur->mask);
chan_set_modes(whosends(ci), c, 2, av, 0);
free(av[1]);
}
free(av[0]);
}
for (cu = c->users; cu; cu = next) {
next = cu->next;
if (is_oper(cu->user))
continue;
av[0] = c->name;
av[1] = cu->user->nick;
av[2] = reason ? reason : "CHAN_FORBID_REASON";
anope_cmd_kick(s_ChanServ, av[0], av[1], av[2]);
do_kick(s_ChanServ, 3, av);
}
}
if (WallForbid)
anope_cmd_global(s_ChanServ,
"\2%s\2 used FORBID on channel \2%s\2",
u->nick, ci->name);
if (ircd->chansqline) {
anope_cmd_sqline(ci->name, ((reason) ? reason : "Forbidden"));
}
alog("%s: %s set FORBID for channel %s", s_ChanServ, u->nick,
ci->name);
notice_lang(s_ChanServ, u, CHAN_FORBID_SUCCEEDED, chan);
send_event(EVENT_CHAN_FORBIDDEN, 1, chan);
} else {
alog("%s: Valid FORBID for %s by %s failed", s_ChanServ, ci->name,
u->nick);
notice_lang(s_ChanServ, u, CHAN_FORBID_FAILED, chan);
}
return MOD_CONT;
}
/**
* The /ms info 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_info(User * u)
{
MemoInfo *mi;
NickAlias *na = NULL;
ChannelInfo *ci = NULL;
char *name = strtok(NULL, " ");
int is_servadmin = is_services_admin(u);
int hardmax = 0;
if (is_servadmin && name && *name != '#') {
na = findnick(name);
if (!na) {
notice_lang(s_MemoServ, u, NICK_X_NOT_REGISTERED, name);
return MOD_CONT;
} else if (na->status & NS_VERBOTEN) {
notice_lang(s_MemoServ, u, NICK_X_FORBIDDEN, name);
return MOD_CONT;
}
mi = &na->nc->memos;
hardmax = na->nc->flags & NI_MEMO_HARDMAX ? 1 : 0;
} else if (name && *name == '#') {
ci = cs_findchan(name);
if (!ci) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, name);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, name);
return MOD_CONT;
} else if (!check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
hardmax = ci->flags & CI_MEMO_HARDMAX ? 1 : 0;
} else if (name) { /* It's not a chan and we aren't services admin */
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
} else { /* !name */
if (!nick_identified(u)) {
notice_lang(s_MemoServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
return MOD_CONT;
}
mi = &u->na->nc->memos;
hardmax = u->na->nc->flags & NI_MEMO_HARDMAX ? 1 : 0;
}
if (name && (ci || na->nc != u->na->nc)) {
if (!mi->memocount) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NO_MEMOS, name);
} else if (mi->memocount == 1) {
if (mi->memos[0].flags & MF_UNREAD)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMO_UNREAD, name);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMO, name);
} else {
int count = 0, i;
for (i = 0; i < mi->memocount; i++) {
if (mi->memos[i].flags & MF_UNREAD)
count++;
}
if (count == mi->memocount)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_ALL_UNREAD,
name, count);
else if (count == 0)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS, name,
mi->memocount);
else if (count == 1)
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_ONE_UNREAD,
name, mi->memocount);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_MEMOS_SOME_UNREAD,
name, mi->memocount, count);
}
if (mi->memomax == 0) {
if (hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_X_HARD_LIMIT, name,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_LIMIT, name,
mi->memomax);
} else if (mi->memomax > 0) {
if (hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_X_HARD_LIMIT, name,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_X_LIMIT, name,
mi->memomax);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NO_LIMIT, name);
}
/* I ripped this code out of ircservices 4.4.5, since I didn't want
to rewrite the whole thing (it pisses me off). */
if (na) {
if ((na->nc->flags & NI_MEMO_RECEIVE)
&& (na->nc->flags & NI_MEMO_SIGNON)) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_ON, name);
} else if (na->nc->flags & NI_MEMO_RECEIVE) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_RECEIVE,
name);
} else if (na->nc->flags & NI_MEMO_SIGNON) {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_SIGNON,
name);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_X_NOTIFY_OFF, name);
}
}
} else { /* !name || (!ci || na->nc == u->na->nc) */
if (!mi->memocount) {
notice_lang(s_MemoServ, u, MEMO_INFO_NO_MEMOS);
} else if (mi->memocount == 1) {
if (mi->memos[0].flags & MF_UNREAD)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMO_UNREAD);
else
notice_lang(s_MemoServ, u, MEMO_INFO_MEMO);
} else {
int count = 0, i;
for (i = 0; i < mi->memocount; i++) {
if (mi->memos[i].flags & MF_UNREAD)
count++;
}
if (count == mi->memocount)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_ALL_UNREAD,
count);
else if (count == 0)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS, mi->memocount);
else if (count == 1)
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_ONE_UNREAD,
mi->memocount);
else
notice_lang(s_MemoServ, u, MEMO_INFO_MEMOS_SOME_UNREAD,
mi->memocount, count);
}
if (mi->memomax == 0) {
if (!is_servadmin && hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_HARD_LIMIT_ZERO);
else
notice_lang(s_MemoServ, u, MEMO_INFO_LIMIT_ZERO);
} else if (mi->memomax > 0) {
if (!is_servadmin && hardmax)
notice_lang(s_MemoServ, u, MEMO_INFO_HARD_LIMIT,
mi->memomax);
else
notice_lang(s_MemoServ, u, MEMO_INFO_LIMIT, mi->memomax);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_NO_LIMIT);
}
/* Ripped too. But differently because of a seg fault (loughs) */
if ((u->na->nc->flags & NI_MEMO_RECEIVE)
&& (u->na->nc->flags & NI_MEMO_SIGNON)) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_ON);
} else if (u->na->nc->flags & NI_MEMO_RECEIVE) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_RECEIVE);
} else if (u->na->nc->flags & NI_MEMO_SIGNON) {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_SIGNON);
} else {
notice_lang(s_MemoServ, u, MEMO_INFO_NOTIFY_OFF);
}
}
return MOD_CONT; /* if (name && (ci || na->nc != u->na->nc)) */
}
void Execute(CommandSource &source, const std::vector<Anope::string> ¶ms)
{
const Anope::string &channel = params[0];
const Anope::string &target = params[1];
Anope::string what = params.size() > 2 ? params[2] : "";
User *u = source.u;
ChannelInfo *ci = cs_findchan(params[0]);
if (ci == NULL)
{
source.Reply(CHAN_X_NOT_REGISTERED, params[0].c_str());
return;
}
if (!ci->AccessFor(u).HasPriv("SET"))
{
source.Reply(ACCESS_DENIED);
return;
}
ChannelInfo *target_ci = cs_findchan(target);
if (!target_ci)
{
source.Reply(CHAN_X_NOT_REGISTERED, target.c_str());
return;
}
if (!IsFounder(u, ci) || !IsFounder(u, target_ci))
{
source.Reply(ACCESS_DENIED);
return;
}
if (what.equals_ci("ALL"))
what.clear();
if (what.empty())
{
delete target_ci;
target_ci = new ChannelInfo(*ci);
target_ci->name = target;
RegisteredChannelList[target_ci->name] = target_ci;
target_ci->c = findchan(target_ci->name);
if (target_ci->c)
{
target_ci->c->ci = target_ci;
check_modes(target_ci->c);
ChannelMode *cm;
if (u->FindChannel(target_ci->c) != NULL)
{
/* On most ircds you do not receive the admin/owner mode till its registered */
if ((cm = ModeManager::FindChannelModeByName(CMODE_OWNER)))
target_ci->c->SetMode(NULL, cm, u->nick);
else if ((cm = ModeManager::FindChannelModeByName(CMODE_PROTECT)))
target_ci->c->RemoveMode(NULL, cm, u->nick);
}
/* Mark the channel as persistent */
if (target_ci->c->HasMode(CMODE_PERM))
target_ci->SetFlag(CI_PERSIST);
/* Persist may be in def cflags, set it here */
else if (target_ci->HasFlag(CI_PERSIST) && (cm = ModeManager::FindChannelModeByName(CMODE_PERM)))
target_ci->c->SetMode(NULL, CMODE_PERM);
if (target_ci->bi && target_ci->c->FindUser(target_ci->bi) == NULL)
target_ci->bi->Join(target_ci->c, &Config->BotModeList);
}
if (target_ci->c && !target_ci->c->topic.empty())
{
target_ci->last_topic = target_ci->c->topic;
target_ci->last_topic_setter = target_ci->c->topic_setter;
target_ci->last_topic_time = target_ci->c->topic_time;
}
else
target_ci->last_topic_setter = source.owner->nick;
FOREACH_MOD(I_OnChanRegistered, OnChanRegistered(target_ci));
source.Reply(_("All settings from \002%s\002 have been cloned to \002%s\002"), channel.c_str(), target.c_str());
}
else if (what.equals_ci("ACCESS"))
{
for (unsigned i = 0; i < ci->GetAccessCount(); ++i)
{
ChanAccess *taccess = ci->GetAccess(i);
AccessProvider *provider = taccess->provider;
ChanAccess *newaccess = provider->Create();
newaccess->ci = target_ci;
newaccess->mask = taccess->mask;
newaccess->creator = taccess->creator;
newaccess->last_seen = taccess->last_seen;
newaccess->created = taccess->created;
newaccess->Unserialize(taccess->Serialize());
target_ci->AddAccess(newaccess);
}
source.Reply(_("All access entries from \002%s\002 have been cloned to \002%s\002"), channel.c_str(), target.c_str());
}
else if (what.equals_ci("AKICK"))
{
target_ci->ClearAkick();
for (unsigned i = 0; i < ci->GetAkickCount(); ++i)
{
AutoKick *akick = ci->GetAkick(i);
if (akick->HasFlag(AK_ISNICK))
target_ci->AddAkick(akick->creator, akick->nc, akick->reason, akick->addtime, akick->last_used);
else
target_ci->AddAkick(akick->creator, akick->mask, akick->reason, akick->addtime, akick->last_used);
}
source.Reply(_("All akick entries from \002%s\002 have been cloned to \002%s\002"), channel.c_str(), target.c_str());
}
else if (what.equals_ci("BADWORDS"))
{
target_ci->ClearBadWords();
for (unsigned i = 0; i < ci->GetBadWordCount(); ++i)
{
BadWord *bw = ci->GetBadWord(i);
target_ci->AddBadWord(bw->word, bw->type);
}
source.Reply(_("All badword entries from \002%s\002 have been cloned to \002%s\002"), channel.c_str(), target.c_str());
}
else
{
this->OnSyntaxError(source, "");
return;
}
Log(LOG_COMMAND, u, this, ci) << "to clone " << (what.empty() ? "everything from it" : what) << " to " << target_ci->name;
return;
}
MemoResult Send(const Anope::string &source, const Anope::string &target, const Anope::string &message, bool force)
{
bool ischan;
MemoInfo *mi = this->GetMemoInfo(target, ischan);
if (mi == NULL)
return MEMO_INVALID_TARGET;
User *sender = finduser(source);
if (sender != NULL && !sender->HasPriv("memoserv/no-limit") && !force)
{
if (Config->MSSendDelay > 0 && sender->lastmemosend + Config->MSSendDelay > Anope::CurTime)
return MEMO_TOO_FAST;
else if (!mi->memomax)
return MEMO_TARGET_FULL;
else if (mi->memomax > 0 && mi->memos.size() >= mi->memomax)
return MEMO_TARGET_FULL;
else if (mi->HasIgnore(sender))
return MEMO_SUCCESS;
}
if (sender != NULL)
sender->lastmemosend = Anope::CurTime;
Memo *m = new Memo();
mi->memos.push_back(m);
m->owner = target;
m->sender = source;
m->time = Anope::CurTime;
m->text = message;
m->SetFlag(MF_UNREAD);
FOREACH_MOD(I_OnMemoSend, OnMemoSend(source, target, mi, m));
if (ischan)
{
ChannelInfo *ci = cs_findchan(target);
if (ci->c)
{
for (CUserList::iterator it = ci->c->users.begin(), it_end = ci->c->users.end(); it != it_end; ++it)
{
UserContainer *cu = *it;
if (ci->AccessFor(cu->user).HasPriv("MEMO"))
{
if (cu->user->Account() && cu->user->Account()->HasFlag(NI_MEMO_RECEIVE))
cu->user->SendMessage(MemoServ, MEMO_NEW_X_MEMO_ARRIVED, ci->name.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), ci->name.c_str(), mi->memos.size());
}
}
}
}
else
{
NickCore *nc = findnick(target)->nc;
if (nc->HasFlag(NI_MEMO_RECEIVE))
{
for (std::list<NickAlias *>::iterator it = nc->aliases.begin(), it_end = nc->aliases.end(); it != it_end; ++it)
{
NickAlias *na = *it;
User *user = finduser(na->nick);
if (user && user->IsIdentified())
user->SendMessage(MemoServ, MEMO_NEW_MEMO_ARRIVED, source.c_str(), Config->UseStrictPrivMsgString.c_str(), Config->MemoServ.c_str(), mi->memos.size());
}
}
/* let's get out the mail if set in the nickcore - certus */
if (nc->HasFlag(NI_MEMO_MAIL))
SendMemoMail(nc, mi, m);
}
return MEMO_SUCCESS;
}
/**
* The /bs info command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_info(User * u)
{
BotInfo *bi;
ChannelInfo *ci;
char *query = strtok(NULL, " ");
int need_comma = 0, is_servadmin = is_services_admin(u);
char buf[BUFSIZE], *end;
const char *commastr = getstring(u->na, COMMA_SPACE);
if (!query)
syntax_error(s_BotServ, u, "INFO", BOT_INFO_SYNTAX);
else if ((bi = findbot(query))) {
char buf[BUFSIZE];
struct tm *tm;
notice_lang(s_BotServ, u, BOT_INFO_BOT_HEADER, bi->nick);
notice_lang(s_BotServ, u, BOT_INFO_BOT_MASK, bi->user, bi->host);
notice_lang(s_BotServ, u, BOT_INFO_BOT_REALNAME, bi->real);
tm = localtime(&bi->created);
strftime_lang(buf, sizeof(buf), u, STRFTIME_DATE_TIME_FORMAT, tm);
notice_lang(s_BotServ, u, BOT_INFO_BOT_CREATED, buf);
notice_lang(s_BotServ, u, BOT_INFO_BOT_OPTIONS,
getstring(u->na,
(bi->
flags & BI_PRIVATE) ? BOT_INFO_OPT_PRIVATE :
BOT_INFO_OPT_NONE));
notice_lang(s_BotServ, u, BOT_INFO_BOT_USAGE, bi->chancount);
if (is_services_admin(u))
send_bot_channels(u, bi);
} else if ((ci = cs_findchan(query))) {
if (!is_servadmin && !is_founder(u, ci)) {
notice_lang(s_BotServ, u, PERMISSION_DENIED);
return MOD_CONT;
}
if (ci->flags & CI_VERBOTEN) {
notice_lang(s_BotServ, u, CHAN_X_FORBIDDEN, query);
return MOD_CONT;
}
notice_lang(s_BotServ, u, BOT_INFO_CHAN_HEADER, ci->name);
if (ci->bi)
notice_lang(s_BotServ, u, BOT_INFO_CHAN_BOT, ci->bi->nick);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_BOT_NONE);
if (ci->botflags & BS_KICK_BADWORDS) {
if (ci->ttb[TTB_BADWORDS])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BADWORDS_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_BADWORDS]);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BADWORDS,
getstring(u->na, BOT_INFO_ACTIVE));
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BADWORDS,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_BOLDS) {
if (ci->ttb[TTB_BOLDS])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BOLDS_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_BOLDS]);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BOLDS,
getstring(u->na, BOT_INFO_ACTIVE));
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_BOLDS,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_CAPS) {
if (ci->ttb[TTB_CAPS])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_CAPS_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_CAPS], ci->capsmin,
ci->capspercent);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_CAPS_ON,
getstring(u->na, BOT_INFO_ACTIVE), ci->capsmin,
ci->capspercent);
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_CAPS_OFF,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_COLORS) {
if (ci->ttb[TTB_COLORS])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_COLORS_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_COLORS]);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_COLORS,
getstring(u->na, BOT_INFO_ACTIVE));
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_COLORS,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_FLOOD) {
if (ci->ttb[TTB_FLOOD])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_FLOOD_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_FLOOD], ci->floodlines,
ci->floodsecs);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_FLOOD_ON,
getstring(u->na, BOT_INFO_ACTIVE),
ci->floodlines, ci->floodsecs);
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_FLOOD_OFF,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_REPEAT) {
if (ci->ttb[TTB_REPEAT])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REPEAT_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_REPEAT], ci->repeattimes);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REPEAT_ON,
getstring(u->na, BOT_INFO_ACTIVE),
ci->repeattimes);
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REPEAT_OFF,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_REVERSES) {
if (ci->ttb[TTB_REVERSES])
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REVERSES_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_REVERSES]);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REVERSES,
getstring(u->na, BOT_INFO_ACTIVE));
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_REVERSES,
getstring(u->na, BOT_INFO_INACTIVE));
if (ci->botflags & BS_KICK_UNDERLINES) {
if (ci->ttb[TTB_UNDERLINES])
notice_lang(s_BotServ, u,
BOT_INFO_CHAN_KICK_UNDERLINES_BAN,
getstring(u->na, BOT_INFO_ACTIVE),
ci->ttb[TTB_UNDERLINES]);
else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_UNDERLINES,
getstring(u->na, BOT_INFO_ACTIVE));
} else
notice_lang(s_BotServ, u, BOT_INFO_CHAN_KICK_UNDERLINES,
getstring(u->na, BOT_INFO_INACTIVE));
end = buf;
*end = 0;
if (ci->botflags & BS_DONTKICKOPS) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s",
getstring(u->na, BOT_INFO_OPT_DONTKICKOPS));
need_comma = 1;
}
if (ci->botflags & BS_DONTKICKVOICES) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s%s",
need_comma ? commastr : "",
getstring(u->na, BOT_INFO_OPT_DONTKICKVOICES));
need_comma = 1;
}
if (ci->botflags & BS_FANTASY) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s%s",
need_comma ? commastr : "",
getstring(u->na, BOT_INFO_OPT_FANTASY));
need_comma = 1;
}
if (ci->botflags & BS_GREET) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s%s",
need_comma ? commastr : "",
getstring(u->na, BOT_INFO_OPT_GREET));
need_comma = 1;
}
if (ci->botflags & BS_NOBOT) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s%s",
need_comma ? commastr : "",
getstring(u->na, BOT_INFO_OPT_NOBOT));
need_comma = 1;
}
if (ci->botflags & BS_SYMBIOSIS) {
end += snprintf(end, sizeof(buf) - (end - buf), "%s%s",
need_comma ? commastr : "",
getstring(u->na, BOT_INFO_OPT_SYMBIOSIS));
need_comma = 1;
}
notice_lang(s_BotServ, u, BOT_INFO_CHAN_OPTIONS,
*buf ? buf : getstring(u->na, BOT_INFO_OPT_NONE));
} else
notice_lang(s_BotServ, u, BOT_INFO_NOT_FOUND, query);
return MOD_CONT;
}
/**
* The /ms read command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_read(User * u)
{
MemoInfo *mi;
ChannelInfo *ci;
char *numstr = strtok(NULL, " "), *chan = NULL;
int num, count;
if (numstr && *numstr == '#') {
chan = numstr;
numstr = strtok(NULL, " ");
if (!(ci = cs_findchan(chan))) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, chan);
return MOD_CONT;
} else if (!check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
} else {
if (!nick_identified(u)) {
notice_lang(s_MemoServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
return MOD_CONT;
}
mi = &u->na->nc->memos;
}
num = numstr ? atoi(numstr) : -1;
if (!numstr
|| (stricmp(numstr, "LAST") != 0 && stricmp(numstr, "NEW") != 0
&& num <= 0)) {
syntax_error(s_MemoServ, u, "READ", MEMO_READ_SYNTAX);
} else if (mi->memocount == 0) {
if (chan)
notice_lang(s_MemoServ, u, MEMO_X_HAS_NO_MEMOS, chan);
else
notice_lang(s_MemoServ, u, MEMO_HAVE_NO_MEMOS);
} else {
int i;
if (stricmp(numstr, "NEW") == 0) {
int readcount = 0;
for (i = 0; i < mi->memocount; i++) {
if (mi->memos[i].flags & MF_UNREAD) {
read_memo(u, i, mi, chan);
readcount++;
}
}
if (!readcount) {
if (chan)
notice_lang(s_MemoServ, u, MEMO_X_HAS_NO_NEW_MEMOS,
chan);
else
notice_lang(s_MemoServ, u, MEMO_HAVE_NO_NEW_MEMOS);
}
} else if (stricmp(numstr, "LAST") == 0) {
for (i = 0; i < mi->memocount - 1; i++);
read_memo(u, i, mi, chan);
} else { /* number[s] */
if (!process_numlist(numstr, &count, read_memo_callback, u,
mi, chan)) {
if (count == 1)
notice_lang(s_MemoServ, u, MEMO_DOES_NOT_EXIST, num);
else
notice_lang(s_MemoServ, u, MEMO_LIST_NOT_FOUND,
numstr);
}
}
}
return MOD_CONT;
}
/**
* List the memos (if any) for the source nick or given channel.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
static int do_list(User * u)
{
char *param = strtok(NULL, " "), *chan = NULL;
ChannelInfo *ci;
MemoInfo *mi;
Memo *m;
int i;
if (param && *param == '#') {
chan = param;
param = strtok(NULL, " ");
if (!(ci = cs_findchan(chan))) {
notice_lang(s_MemoServ, u, CHAN_X_NOT_REGISTERED, chan);
return MOD_CONT;
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_MemoServ, u, CHAN_X_FORBIDDEN, chan);
return MOD_CONT;
} else if (!check_access(u, ci, CA_MEMO)) {
notice_lang(s_MemoServ, u, ACCESS_DENIED);
return MOD_CONT;
}
mi = &ci->memos;
} else {
if (!nick_identified(u)) {
notice_lang(s_MemoServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
return MOD_CONT;
}
mi = &u->na->nc->memos;
}
if (param && !isdigit(*param) && stricmp(param, "NEW") != 0) {
syntax_error(s_MemoServ, u, "LIST", MEMO_LIST_SYNTAX);
} else if (mi->memocount == 0) {
if (chan)
notice_lang(s_MemoServ, u, MEMO_X_HAS_NO_MEMOS, chan);
else
notice_lang(s_MemoServ, u, MEMO_HAVE_NO_MEMOS);
} else {
int sent_header = 0;
if (param && isdigit(*param)) {
process_numlist(param, NULL, list_memo_callback, u,
mi, &sent_header, chan);
} else {
if (param) {
for (i = 0, m = mi->memos; i < mi->memocount; i++, m++) {
if (m->flags & MF_UNREAD)
break;
}
if (i == mi->memocount) {
if (chan)
notice_lang(s_MemoServ, u, MEMO_X_HAS_NO_NEW_MEMOS,
chan);
else
notice_lang(s_MemoServ, u, MEMO_HAVE_NO_NEW_MEMOS);
return MOD_CONT;
}
}
for (i = 0, m = mi->memos; i < mi->memocount; i++, m++) {
if (param && !(m->flags & MF_UNREAD))
continue;
list_memo(u, i, mi, &sent_header, param != NULL, chan);
}
}
}
return MOD_CONT;
}
