{ "CSMSG_NO_SELF_CLVL", "You cannot change your own access." },
{ "CSMSG_NO_BUMP_ACCESS", "You cannot give users access greater than or equal to your own." },
{ "CSMSG_MULTIPLE_OWNERS", "There is more than one owner in %s; please use $bCLVL$b, $bDELOWNER$b and/or $bADDOWNER$b instead." },
+ { "CSMSG_NO_OWNER", "There is no owner for %s; please use $bCLVL$b and/or $bADDOWNER$b instead." },
{ "CSMSG_TRANSFER_WAIT", "You must wait %s before you can give ownership of $b%s$b to someone else." },
{ "CSMSG_NO_TRANSFER_SELF", "You cannot give ownership to your own account." },
{ "CSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
{ "CSMSG_USET_AUTOOP", "$bAutoOp $b %s" },
{ "CSMSG_USET_AUTOVOICE", "$bAutoVoice $b %s" },
{ "CSMSG_USET_AUTOINVITE", "$bAutoInvite $b %s" },
+ { "CSMSG_USET_AUTOJOIN", "$bAutoJoin $b %s" },
{ "CSMSG_USET_INFO", "$bInfo $b %s" },
{ "CSMSG_USER_PROTECTED", "Sorry, $b%s$b is protected." },
{ "CSMSG_AUTOMODE_HOP", "#1 plus give halfops to everyone." },
{ "CSMSG_AUTOMODE_OP", "#1 plus give ops to everyone (not advised)" },
{ "CSMSG_AUTOMODE_MUTE", "Give half-op to halfops, and op to ops only." },
+ { "CSMSG_AUTOMODE_ONLYVOICE", "Just voice everyone with access." },
{ "CSMSG_PROTECT_ALL", "Non-users and users will be protected from those of equal or lower access." },
{ "CSMSG_PROTECT_EQUAL", "Users will be protected from those of equal or lower access." },
/* Other things */
{ "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
{ "CSMSG_LAST_INVALID", "Invalid argument. must be 1-200" },
+ { "CSMSG_DEFCON_NO_NEW_CHANNELS", "You cannot register new channels at this time, please try again soon." },
+ { "CSMSG_DEFCON_NO_MODE_CHANGE", "You cannot change the MODE at this time, please try again soon." },
{ NULL, NULL }
};
{ 'v', "CSMSG_AUTOMODE_VOICE" },
{ 'h', "CSMSG_AUTOMODE_HOP" },
{ 'o', "CSMSG_AUTOMODE_OP" },
- { 'm', "CSMSG_AUTOMODE_MUTE" }
+ { 'm', "CSMSG_AUTOMODE_MUTE" },
+ { 'l', "CSMSG_AUTOMODE_ONLYVOICE" }
}, protectValues[] = {
{ 'a', "CSMSG_PROTECT_ALL" },
{ 'e', "CSMSG_PROTECT_EQUAL" },
}
static int
-validate_op(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_op(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
{
struct chanData *cData = channel->channel_info;
struct userData *cs_victim;
|| (cs_victim->access < UL_OP /* cData->lvlOpts[lvlGiveOps]*/))
&& !check_user_level(channel, user, lvlEnfOps, 0, 0))
{
- send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
+ if(cmd)
+ reply("CSMSG_OPBY_LOCKED");
+ else
+ send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
return 0;
}
}
static int
-validate_halfop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_halfop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
{
struct chanData *cData = channel->channel_info;
struct userData *cs_victim;
|| (cs_victim->access < UL_HALFOP /* cData->lvlOpts[lvlGiveHalfOps] */))
&& !check_user_level(channel, user, lvlEnfHalfOps, 0, 0))
{
- send_message(user, chanserv, "CSMSG_HOPBY_LOCKED");
+ reply("CSMSG_HOPBY_LOCKED");
return 0;
}
static int
-validate_deop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_deop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
{
if(IsService(victim))
{
- send_message(user, chanserv, "MSG_SERVICE_IMMUNE", victim->nick);
+ reply("MSG_SERVICE_IMMUNE", victim->nick);
return 0;
}
if(protect_user(victim, user, channel->channel_info))
{
- send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
+ reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
}
}
static int
-validate_dehop(struct userNode *user, struct chanNode *channel, struct userNode *victim)
+validate_dehop(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim)
{
if(IsService(victim))
{
- send_message(user, chanserv, "MSG_SERVICE_IMMUNE", victim->nick);
+ reply("MSG_SERVICE_IMMUNE", victim->nick);
return 0;
}
if(protect_user(victim, user, channel->channel_info))
{
- send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
+ reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
}
struct do_not_register *dnr;
unsigned int n;
+ if (checkDefCon(DEFCON_NO_NEW_CHANNELS) && !IsOper(user)) {
+ reply("CSMSG_DEFCON_NO_NEW_CHANNELS");
+ return 0;
+ }
if(channel)
{
if(handle != user->handle_info)
reply("CSMSG_PROXY_SUCCESS", handle->handle, channel->name);
else
- reply("CSMSG_REG_SUCCESS", channel->name);
sprintf(reason, "%s registered to %s by %s.", channel->name, handle->handle, user->handle_info->handle);
- global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+ global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_REGISTERED_TO", channel->name,
+ handle->handle, user->handle_info->handle);
return 1;
}
struct chanNode *target;
struct modeNode *mn;
struct userData *uData;
- char reason[MAXLEN];
struct do_not_register *dnr;
int chanserv_join = 0, spamserv_join;
if (chanserv_join)
ss_cs_join_channel(target, spamserv_join);
- sprintf(reason, "%s moved to %s by %s.", channel->name, target->name, user->handle_info->handle);
if(!IsSuspended(target->channel_info))
{
char reason2[MAXLEN];
- sprintf(reason2, "Channel moved to %s by %s.", target->name, user->handle_info->handle);
- DelChannelUser(chanserv, channel, reason2, 0);
+ sprintf(reason2, "Channel moved to %s by %s.", target->name, user->handle_info->handle);
+ DelChannelUser(chanserv, channel, reason2, 0);
}
+
UnlockChannel(channel);
LockChannel(target);
- global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+ global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_CHANNEL_MOVED",
+ channel->name, target->name, user->handle_info->handle);
+
reply("CSMSG_MOVE_SUCCESS", target->name);
return 1;
}
/* trim_lamers.. */
static int
-cmd_trim_bans(struct userNode *user, struct chanNode *channel, unsigned long duration)
+cmd_trim_bans(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, unsigned long duration)
{
struct banData *bData, *next;
char interval[INTERVALLEN];
}
intervalString(interval, duration, user->handle_info);
- send_message(user, chanserv, "CSMSG_TRIMMED_LAMERS", count, channel->name, interval);
+ reply("CSMSG_TRIMMED_LAMERS", count, channel->name, interval);
return 1;
}
static int
-cmd_trim_users(struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration, int vacation)
+cmd_trim_users(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, unsigned short min_access, unsigned short max_access, unsigned long duration, int vacation)
{
struct userData *actor, *uData, *next;
char interval[INTERVALLEN];
actor = GetChannelUser(channel->channel_info, user->handle_info);
if(min_access > max_access)
{
- send_message(user, chanserv, "CSMSG_BAD_RANGE", min_access, max_access);
+ reply("CSMSG_BAD_RANGE", min_access, max_access);
return 0;
}
if((actor->access <= max_access) && !IsHelping(user))
{
- send_message(user, chanserv, "CSMSG_NO_ACCESS");
+ reply("CSMSG_NO_ACCESS");
return 0;
}
min_access = 1;
max_access = (actor->access > UL_OWNER) ? UL_OWNER : (actor->access - 1);
}
- send_message(user, chanserv, "CSMSG_TRIMMED_USERS", count, min_access, max_access, channel->name, intervalString(interval, duration, user->handle_info));
+ reply("CSMSG_TRIMMED_USERS", count, min_access, max_access, channel->name, intervalString(interval, duration, user->handle_info));
return 1;
}
if(!irccasecmp(argv[1], "lamers"))
{
- cmd_trim_bans(user, channel, duration); /* trim_lamers.. */
+ cmd_trim_bans(cmd, user, channel, duration); /* trim_lamers.. */
return 1;
}
else if(!irccasecmp(argv[1], "users"))
{
- cmd_trim_users(user, channel, 0, 0, duration, vacation);
+ cmd_trim_users(cmd, user, channel, 0, 0, duration, vacation);
return 1;
}
else if(parse_level_range(&min_level, &max_level, argv[1]))
{
- cmd_trim_users(user, channel, min_level, max_level, duration, vacation);
+ cmd_trim_users(cmd, user, channel, min_level, max_level, duration, vacation);
return 1;
}
else if((min_level = user_level_from_name(argv[1], UL_OWNER)))
{
- cmd_trim_users(user, channel, min_level, min_level, duration, vacation);
+ cmd_trim_users(cmd, user, channel, min_level, min_level, duration, vacation);
return 1;
}
else
return cmd_all(CSFUNC_ARGS, cmd_down);
}
-typedef int validate_func_t(struct userNode *user, struct chanNode *channel, struct userNode *victim);
+typedef int validate_func_t(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, struct userNode *victim);
typedef void process_func_t(unsigned int num, struct userNode **newops, struct chanNode *channel, struct userNode *who, int announce);
static int
change->args[valid].u.member = GetUserMode(channel, victim);
if(!change->args[valid].u.member)
continue;
- if(validate && !validate(user, channel, victim))
+ if(validate && !validate(cmd, user, channel, victim))
continue;
valid++;
}
}
if(IsUserAutoInvite(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
string_buffer_append(&sbuf, 'i');
+ if(IsUserAutoJoin(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
+ string_buffer_append(&sbuf, 'j');
if(uData->info)
string_buffer_append_printf(&sbuf, ")] %s", uData->info);
else
if(argc < 2)
{
+ if (checkDefCon(DEFCON_NO_MODE_CHANGE) && !IsOper(user)) {
+ reply("CSMSG_DEFCON_NO_MODE_CHANGE");
+ return 0;
+ }
+
change = &channel->channel_info->modes;
if(change->modes_set || change->modes_clear) {
modcmd_chanmode_announce(change);
reply("CSMSG_CHANNEL_VISITED", intervalString(buffer, now - cData->visited, user->handle_info));
privileged = IsStaff(user);
- if(privileged)
+ /* if(privileged) */
reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
- if(((uData && uData->access >= UL_COOWNER) || privileged) && cData->registrar)
+ if(/*((uData && uData->access >= UL_COOWNER) || privileged) && */cData->registrar)
reply("CSMSG_CHANNEL_REGISTRAR", cData->registrar);
if(privileged && (dnr = chanserv_is_dnr(channel->name, NULL)))
suspended->previous->revoked = now;
if(suspended->previous->expires)
timeq_del(suspended->previous->expires, chanserv_expire_suspension, suspended->previous, 0);
- sprintf(reason, "%s suspension modified by %s.", channel->name, suspended->suspender);
- global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+
+ global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_SUSPENSION_MODIFIED",
+ channel->name, suspended->suspender);
}
else
{
spamserv_cs_suspend(channel, expiry, 1, suspended->reason);
DelChannelUser(chanserv, channel, suspended->reason, 0);
reply("CSMSG_SUSPENDED", channel->name);
- sprintf(reason, "%s suspended by %s.", channel->name, suspended->suspender);
- global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+ global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_SUSPENDED_BY",
+ channel->name, suspended->suspender);
}
return 1;
}
static CHANSERV_FUNC(cmd_cunsuspend)
{
struct suspended *suspended;
- char message[MAXLEN];
if(!IsSuspended(channel->channel_info))
{
timeq_del(suspended->expires, chanserv_expire_suspension, suspended, 0);
chanserv_expire_suspension(suspended);
reply("CSMSG_UNSUSPENDED", channel->name);
- sprintf(message, "%s unsuspended by %s.", channel->name, user->handle_info->handle);
- global_message(MESSAGE_RECIPIENT_OPERS|MESSAGE_RECIPIENT_HELPERS, message);
+ global_message_args(MESSAGE_RECIPIENT_OPERS|MESSAGE_RECIPIENT_HELPERS, "CSMSG_UNSUSPENDED_BY",
+ channel->name, user->handle_info->handle);
return 1;
}
typedef void (*channel_search_func)(struct chanData *channel, void *data);
static search_t
-chanserv_search_create(struct userNode *user, unsigned int argc, char *argv[])
+chanserv_search_create(struct svccmd *cmd, struct userNode *user, unsigned int argc, char *argv[])
{
search_t search;
unsigned int i;
/* Assume all criteria require arguments. */
if(i == (argc - 1))
{
- send_message(user, chanserv, "MSG_MISSING_PARAMS", argv[i]);
+ reply("MSG_MISSING_PARAMS", argv[i]);
goto fail;
}
search->flags |= CHANNEL_SUSPENDED;
else
{
- send_message(user, chanserv, "CSMSG_INVALID_CFLAG", argv[i]);
+ reply("CSMSG_INVALID_CFLAG", argv[i]);
goto fail;
}
}
search->limit = strtoul(argv[++i], NULL, 10);
else
{
- send_message(user, chanserv, "MSG_INVALID_CRITERIA", argv[i]);
+ reply("MSG_INVALID_CRITERIA", argv[i]);
goto fail;
}
}
return 0;
}
- search = chanserv_search_create(user, argc - 2, argv + 2);
+ search = chanserv_search_create(cmd, user, argc - 2, argv + 2);
if(!search)
return 0;
if(argc > 1)
{
+ if (checkDefCon(DEFCON_NO_MODE_CHANGE) && !IsOper(user)) {
+ reply("CSMSG_DEFCON_NO_MODE_CHANGE");
+ return 0;
+ }
+
if(!check_user_level(channel, user, lvlEnfModes, 1, 0))
{
reply("CSMSG_NO_ACCESS");
reply("CSMSG_NOT_USER", channel->name);
return 0;
}
- if(uData->access < UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
+ if(uData->access < UL_HALFOP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
return user_binary_option("CSMSG_USET_AUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
else
return user_binary_option("CSMSG_USET_AUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
- /* TODO: add halfops error message? or is the op one generic enough? */
}
static MODCMD_FUNC(user_opt_autoinvite)
return user_binary_option("CSMSG_USET_AUTOINVITE", USER_AUTO_INVITE, CSFUNC_ARGS);
}
+static MODCMD_FUNC(user_opt_autojoin)
+{
+ return user_binary_option("CSMSG_USET_AUTOJOIN", USER_AUTO_JOIN, CSFUNC_ARGS);
+}
+
static MODCMD_FUNC(user_opt_info)
{
struct userData *uData;
{
char *options[] =
{
- "AutoOp", "AutoInvite", "Info"
+ "AutoOp", "AutoInvite", "AutoJoin", "Info"
};
if(!uset_shows_list.size)
struct giveownership *giveownership;
unsigned int force, override;
unsigned short co_access, new_owner_old_access;
- char reason[MAXLEN], transfer_reason[MAXLEN];
+ char transfer_reason[MAXLEN];
REQUIRE_PARAMS(2);
curr_user = GetChannelAccess(cData, user->handle_info);
reply("CSMSG_TRANSFER_WAIT", delay, channel->name);
return 0;
}
+ if (!curr_user) {
+ reply("CSMSG_NO_OWNER", channel->name);
+ return 0;
+ }
if(!(new_owner_hi = modcmd_get_handle_info(user, argv[1])))
return 0;
if(new_owner_hi == user->handle_info)
channel->channel_info->giveownership = giveownership;
reply("CSMSG_OWNERSHIP_GIVEN", channel->name, new_owner_hi->handle);
- sprintf(reason, "%s ownership transferred to %s by %s.", channel->name, new_owner_hi->handle, user->handle_info->handle);
- global_message(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, reason);
+ global_message_args(MESSAGE_RECIPIENT_OPERS | MESSAGE_RECIPIENT_HELPERS, "CSMSG_OWNERSHIP_TRANSFERRED",
+ channel->name, new_owner_hi->handle, user->handle_info->handle);
return 1;
}
return 1;
}
+static CHANSERV_FUNC(cmd_reply)
+{
+
+ REQUIRE_PARAMS(2);
+ unsplit_string(argv + 1, argc - 1, NULL);
+
+ if(channel)
+ send_channel_message(channel, cmd->parent->bot, "$b%s$b: %s", user->nick, unsplit_string(argv + 1, argc - 1, NULL));
+ else
+ send_message_type(4, user, cmd->parent->bot, "%s", unsplit_string(argv + 1, argc - 1, NULL));
+ return 1;
+}
+
static void
chanserv_adjust_limit(void *data)
{
/* non users getting automodes are handled above. */
if(IsUserAutoOp(uData) && cData->chOpts[chAutomode] != 'n')
{
- if(uData->access >= UL_OP )
+ /* just op everyone with access */
+ if(uData->access >= UL_PEON && cData->chOpts[chAutomode] == 'l')
+ modes |= MODE_VOICE;
+ /* or do their access level */
+ else if(uData->access >= UL_OP )
modes |= MODE_CHANOP;
else if(uData->access >= UL_HALFOP )
modes |= MODE_HALFOP;
return 0;
}
+static void
+chanserv_autojoin_channel(void *data)
+{
+ struct userData *channel;
+ struct userNode *user = data;
+
+ for(channel = user->handle_info->channels; channel; channel = channel->u_next)
+ {
+ struct chanNode *cn;
+ struct modeNode *mn;
+
+ if(IsUserSuspended(channel)
+ || IsSuspended(channel->channel)
+ || !(cn = channel->channel->channel))
+ continue;
+
+ mn = GetUserMode(cn, user);
+ if(!mn)
+ {
+ if(!IsUserSuspended(channel)
+ && IsUserAutoJoin(channel)
+ && (channel->access >= channel->channel->lvlOpts[lvlInviteMe])
+ && !self->burst
+ && !user->uplink->burst)
+ irc_svsjoin(chanserv, user, cn);
+ }
+ }
+}
+
static void
handle_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
{
for(channel = user->handle_info->channels; channel; channel = channel->u_next)
{
struct chanNode *cn;
+ struct chanData *cData;
struct modeNode *mn;
if(IsUserSuspended(channel)
|| IsSuspended(channel->channel)
|| !(cn = channel->channel->channel))
continue;
+ cData = cn->channel_info;
mn = GetUserMode(cn, user);
if(!mn)
{
if(channel->access >= UL_PRESENT)
channel->channel->visited = now;
- if(IsUserAutoOp(channel))
+ if(IsUserAutoOp(channel) && cData->chOpts[chAutomode] != 'n')
{
if(channel->access >= UL_OP )
change.args[0].mode = MODE_CHANOP;
if (user->handle_info->epithet)
irc_swhois(chanserv, user, user->handle_info->epithet);
+
+ /* process autojoin channels 5 seconds later as this sometimes
+ happens before autohide */
+ timeq_add(now + 5, chanserv_autojoin_channel, user);
}
static void
else if(change->args[ii].mode & MODE_CHANOP)
{
const struct userNode *victim = change->args[ii].u.member->user;
- if(IsService(victim) || validate_op(user, channel, (struct userNode*)victim))
+ if(IsService(victim) || validate_op(NULL, user, channel, (struct userNode*)victim))
continue;
if(!bounce)
bounce = mod_chanmode_alloc(change->argc + 1 - ii);
DEFINE_COMMAND(d, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
DEFINE_COMMAND(huggle, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
DEFINE_COMMAND(calc, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
+ DEFINE_COMMAND(reply, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
/* Channel options */
DEFINE_CHANNEL_OPTION(defaulttopic);
/* User options */
DEFINE_USER_OPTION(autoinvite);
+ DEFINE_USER_OPTION(autojoin);
DEFINE_USER_OPTION(info);
DEFINE_USER_OPTION(autoop);
projects / irc / evilnet / x3.git / blobdiff