/* chanserv.c - Channel service bot
* Copyright 2000-2004 srvx Development Team
*
- * This file is part of srvx.
+ * This file is part of x3.
*
* srvx is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#define KEY_GIVEOWNERSHIP_PERIOD "giveownership_timeout"
/* ChanServ database */
+#define KEY_VERSION_CONTROL "version_control"
#define KEY_CHANNELS "channels"
#define KEY_NOTE_TYPES "note_types"
+/* version control paramiter */
+#define KEY_VERSION_NUMBER "version_number"
+
/* Note type parameters */
#define KEY_NOTE_OPSERV_ACCESS "opserv_access"
#define KEY_NOTE_CHANNEL_ACCESS "channel_access"
/* Do-not-register channels */
{ "CSMSG_NOT_DNR", "$b%s$b is not a valid channel name or *account." },
- { "CSMSG_DNR_SEARCH_RESULTS", "The following do-not-registers were found:" },
- { "CSMSG_DNR_INFO", "$b%s$b is do-not-register (by $b%s$b): %s" },
- { "CSMSG_DNR_INFO_SET", "$b%s$b is do-not-register (set %s by $b%s$b): %s" },
+ { "CSMSG_DNR_SEARCH_RESULTS", "$bDo-Not-Register Channels$b" },
+ { "CSMSG_DNR_INFO", "$b%s$b (set by $b%s$b): %s" },
+ { "CSMSG_DNR_INFO_SET", "$b%s$b (set %s ago by $b%s$b): %s" },
{ "CSMSG_MORE_DNRS", "%d more do-not-register entries skipped." },
{ "CSMSG_DNR_CHANNEL", "Only network staff may register $b%s$b." },
{ "CSMSG_DNR_CHANNEL_MOVE", "Only network staff may move $b%s$b." },
{ "CSMSG_DELETED_YOU", "Your $b%d$b access has been deleted from $b%s$b." },
/* User management */
- { "CSMSG_ADDED_USER", "Added %s to the %s user list with access %d." },
+ { "CSMSG_ADDED_USER", "Added %s to the %s user list with access %s (%d)." },
{ "CSMSG_DELETED_USER", "Deleted %s (with access %d) from the %s user list." },
{ "CSMSG_BAD_RANGE", "Invalid access range; minimum (%d) must be greater than maximum (%d)." },
{ "CSMSG_DELETED_USERS", "Deleted accounts matching $b%s$b with access from $b%d$b to $b%d$b from the %s user list." },
{ "CSMSG_TRIMMED_USERS", "Trimmed $b%d users$b with access from %d to %d from the %s user list who were inactive for at least %s." },
- { "CSMSG_INCORRECT_ACCESS", "%s has access $b%d$b, not %s." },
- { "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with access %d)." },
+ { "CSMSG_INCORRECT_ACCESS", "%s has access $b%s$b, not %s." },
+ { "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with %s access)." },
{ "CSMSG_CANNOT_TRIM", "You must include a minimum inactivity duration of at least 60 seconds to trim." },
{ "CSMSG_NO_SELF_CLVL", "You cannot change your own access." },
{ "CSMSG_TOPIC_SET", "Topic is now '%s'." },
{ "CSMSG_NO_TOPIC", "$b%s$b does not have a default topic." },
{ "CSMSG_TOPICMASK_CONFLICT1", "I do not know how to make that topic work with the current topic mask in $b%s$b, which is: %s" },
- { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic at most %d characters and matches the topic mask pattern." },
+ { "CSMSG_TOPICMASK_CONFLICT2", "Please make sure your topic is at most %d characters and matches the topic mask pattern." },
{ "CSMSG_TOPIC_LOCKED", "The %s topic is locked." },
{ "CSMSG_MASK_BUT_NO_TOPIC", "Warning: $b%s$b does not have a default topic, but you just set the topic mask." },
{ "CSMSG_TOPIC_MISMATCH", "Warning: The default topic for $b%s$b does not match the topic mask; changing it anyway." },
{ "CSMSG_CONFIRM_DEFAULTS", "To reset %s's settings to the defaults, you must use 'set defaults %s'." },
{ "CSMSG_SETTINGS_DEFAULTED", "All settings for %s have been reset to default values." },
{ "CSMSG_BAD_SETLEVEL", "You cannot change any setting to above your level." },
+ /*
{ "CSMSG_BAD_GIVEVOICE", "You cannot change GiveVoice to above GiveHalfOps (%d)." },
{ "CSMSG_BAD_GIVEHOPS", "You cannot change GiveHalfOps to below GiveOps (%d)." },
{ "CSMSG_BAD_GIVEOPS", "You cannot change GiveOps to below GiveVoice (%d)." },
+ */
{ "CSMSG_BAD_SETTERS", "You cannot change Setters to above your level." },
{ "CSMSG_INVALID_MODE_LOCK", "$b%s$b is an invalid mode lock." },
{ "CSMSG_INVALID_NUMERIC", "$b%d$b is not a valid choice. Choose one:" },
{ "CSMSG_SET_DYNLIMIT", "$bDynLimit $b %s" },
{ "CSMSG_SET_OFFCHANNEL", "$bOffChannel $b %s" },
{ "CSMSG_SET_USERINFO", "$bUserInfo $b %d" },
+ /*
{ "CSMSG_SET_GIVE_VOICE", "$bGiveVoice $b %d" },
{ "CSMSG_SET_GIVE_HALFOPS", "$bGiveHalfOps $b %d" },
+ */
{ "CSMSG_SET_TOPICSNARF", "$bTopicSnarf $b %d" },
{ "CSMSG_SET_INVITEME", "$bInviteMe $b %d" },
{ "CSMSG_SET_ENFOPS", "$bEnfOps $b %d" },
{ "CSMSG_SET_ENFHALFOPS", "$bEnfHalfOps $b %d" },
+ /*
{ "CSMSG_SET_GIVE_OPS", "$bGiveOps $b %d" },
+ */
{ "CSMSG_SET_ENFMODES", "$bEnfModes $b %d" },
{ "CSMSG_SET_ENFTOPIC", "$bEnfTopic $b %d" },
{ "CSMSG_SET_PUBCMD", "$bPubCmd $b %d" },
{ "CSMSG_SET_SETTERS", "$bSetters $b %d" },
{ "CSMSG_SET_CTCPUSERS", "$bCTCPUsers $b %d" },
+ { "CSMSG_SET_VOICE", "$bvoice $b %d - %s" },
{ "CSMSG_SET_PROTECT", "$bProtect $b %d - %s" },
{ "CSMSG_SET_TOYS", "$bToys $b %d - %s" },
{ "CSMSG_SET_CTCPREACTION", "$bCTCPReaction$b %d - %s" },
{ "CSMSG_SET_TOPICREFRESH", "$bTopicRefresh$b %d - %s" },
- { "CSMSG_USET_NOAUTOOP", "$bNoAutoOp $b %s" },
- { "CSMSG_USET_NOAUTOVOICE", "$bNoAutoVoice $b %s" },
+ { "CSMSG_USET_AUTOOP", "$bAutoOp $b %s" },
+ { "CSMSG_USET_AUTOVOICE", "$bAutoVoice $b %s" },
{ "CSMSG_USET_AUTOINVITE", "$bAutoInvite $b %s" },
{ "CSMSG_USET_INFO", "$bInfo $b %s" },
{ "CSMSG_DEHALFOPPED_USERS", "DeHalfopped users in $b%s$b." },
{ "CSMSG_VOICED_USERS", "Voiced users in $b%s$b." },
{ "CSMSG_DEVOICED_USERS", "Devoiced users in $b%s$b." },
+ { "CSMSG_VOICE_NONE", "Noone will be auto-voiced" },
+ { "CSMSG_VOICE_PEON", "PEONs will be auto-voiced" },
+ { "CSMSG_VOICE_ALL", "Everyone will be auto-voiced" },
{ "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." },
{ "CSMSG_PROTECT_LOWER", "Users will be protected from those of lower access." },
{ "CSMSG_BANS_REMOVED", "Removed all channel bans from $b%s$b." },
/* Channel userlist */
- { "CSMSG_ACCESS_ALL_HEADER", "%s users from level %d to %d:" },
- { "CSMSG_ACCESS_SEARCH_HEADER", "%s users from level %d to %d matching %s:" },
+ { "CSMSG_ACCESS_ALL_HEADER", "$b%s Users From Level %s To %s$b" },
+ { "CSMSG_ACCESS_SEARCH_HEADER", "$b%s Users From Level %s To %s Matching %s$b" },
{ "CSMSG_INVALID_ACCESS", "$b%s$b is an invalid access level." },
- { "CSMSG_CHANGED_ACCESS", "%s now has access $b%d$b in %s." },
+ { "CSMSG_CHANGED_ACCESS", "%s now has access $b%s$b (%u) in %s." },
+ { "CSMSG_BANS_HEADER", "$bBans in %s$b" },
/* Channel note list */
{ "CSMSG_NOTELIST_HEADER", "Notes for $b%s$b:" },
{ "CSMSG_SQUAT_ACCESS", "$b%s$b does not have access to any channels." },
{ "CSMSG_INFOLINE_LIST", "Showing all channel entries for account $b%s$b:" },
{ "CSMSG_USER_NO_ACCESS", "%s lacks access to %s." },
- { "CSMSG_USER_HAS_ACCESS", "%s has access $b%d$b in %s." },
+ { "CSMSG_USER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s." },
{ "CSMSG_HELPER_NO_ACCESS", "%s lacks access to %s but has $bsecurity override$b enabled." },
- { "CSMSG_HELPER_HAS_ACCESS", "%s has access $b%d$b in %s and has $bsecurity override$b enabled." },
+ { "CSMSG_HELPER_HAS_ACCESS", "%s has $b%s$b access (%d) in %s and has $bsecurity override$b enabled." },
{ "CSMSG_LAZY_SMURF_TARGET", "%s is %s ($bIRCOp$b; not logged in)." },
{ "CSMSG_SMURF_TARGET", "%s is %s ($b%s$b)." },
{ "CSMSG_LAME_SMURF_TARGET", "%s is an IRC operator." },
{ "CSMSG_END_NAMES", "End of names in $b%s$b" },
/* Channel information */
- { "CSMSG_CHANNEL_INFO", "$b%s$b Information:" },
+ { "CSMSG_CHANNEL_INFO", "$bInformation About %s$b" },
+ { "CSMSG_BAR", "----------------------------------------"},
{ "CSMSG_CHANNEL_TOPIC", "$bDefault Topic: $b%s" },
{ "CSMSG_CHANNEL_MODES", "$bMode Lock: $b%s" },
{ "CSMSG_CHANNEL_NOTE", "$b%s:%*s$b%s" },
{ "CSMSG_CHANNEL_SUSPENDED_7", " %s ago by %s; revoked %s ago: %s" },
{ "CSMSG_CHANNEL_REGISTERED", "$bRegistered: $b%s ago." },
{ "CSMSG_CHANNEL_VISITED", "$bVisited: $b%s ago." },
+ { "CSMSG_CHANNEL_END", "---------------End of Info--------------"},
- { "CSMSG_PEEK_INFO", "$b%s$b Status:" },
+ { "CSMSG_PEEK_INFO", "$bStatus of %s$b" },
{ "CSMSG_PEEK_TOPIC", "$bTopic: $b%s" },
{ "CSMSG_PEEK_MODES", "$bModes: $b%s" },
{ "CSMSG_PEEK_USERS", "$bTotal users: $b%d" },
{ "CSMSG_PEEK_OPS", "$bOps:$b" },
{ "CSMSG_PEEK_NO_OPS", "$bOps: $bNone present" },
+ { "CSMSG_PEEK_END", "-------------End of Status--------------" },
/* Network information */
{ "CSMSG_NETWORK_INFO", "Network Information:" },
{ "CSMSG_ACTION_INVALID", "$b%s$b is not a recognized search action." },
{ "CSMSG_UNVISITED_HEADER", "Showing a maximum of %d channels unvisited for $b%s$b:" },
{ "CSMSG_UNVISITED_DATA", "%s: $b%s$b" },
- { "CSMSG_CHANNEL_SEARCH_RESULTS", "The following channels were found:" },
+ { "CSMSG_CHANNEL_SEARCH_RESULTS", "$bChannels Found Matching Search$b" },
/* Channel configuration */
{ "CSMSG_INVALID_OPTION", "$b%s$b is not a valid %s option." },
- { "CSMSG_CHANNEL_OPTIONS", "Channel Options:" },
+ { "CSMSG_CHANNEL_OPTIONS", "$bChannel Options for %s$b" },
+ { "CSMSG_CHANNEL_OPTIONS_END", "-------------End of Options-------------" },
{ "CSMSG_GREETING_TOO_LONG", "Your greeting ($b%d$b characters) must be shorter than $b%d$b characters." },
/* User settings */
{ "CSMSG_HUGGLES_YOU", "\001ACTION huggles you\001" },
/* Other things */
- { "CSMSG_EVENT_SEARCH_RESULTS", "The following channel events were found:" },
+ { "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
{ NULL, NULL }
};
#define CSFUNC_ARGS user, channel, argc, argv, cmd
#define CHANSERV_FUNC(NAME) MODCMD_FUNC(NAME)
-#define CHANSERV_SYNTAX() svccmd_send_help(user, chanserv, cmd)
+#define CHANSERV_SYNTAX() svccmd_send_help_brief(user, chanserv, cmd)
#define REQUIRE_PARAMS(N) if(argc < (N)) { \
reply("MSG_MISSING_PARAMS", argv[0]); \
CHANSERV_SYNTAX(); \
unsigned int max_chan_bans;
unsigned int max_userinfo_length;
- unsigned int use_registered_mode;
-
struct string_list *set_shows;
struct string_list *eightball;
struct string_list *old_ban_names;
char *title;
unsigned short level;
char ch;
-} accessLevels[] = {
+} accessLevels[] = { /* MUST be orderd less to most! */
{ "peon", "Peon", UL_PEON, '+' },
{ "halfop", "HalfOp", UL_HALFOP, '%' },
{ "op", "Op", UL_OP, '@' },
struct charOptionValues {
char value;
char *format_name;
-} protectValues[] = {
+} voiceValues[] = {
+ { 'n', "CSMSG_VOICE_NONE" },
+ { 'p', "CSMSG_VOICE_PEON" },
+ { 'a', "CSMSG_VOICE_ALL" }
+}, protectValues[] = {
{ 'a', "CSMSG_PROTECT_ALL" },
{ 'e', "CSMSG_PROTECT_EQUAL" },
{ 'l', "CSMSG_PROTECT_LOWER" },
unsigned char count;
struct charOptionValues *values;
} charOptions[] = {
- { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues), protectValues },
- { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
+ { "CSMSG_SET_VOICE", "voice", 'p', 99, ArrayLength(voiceValues), voiceValues },
+ { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues), protectValues },
+ { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
{ "CSMSG_SET_TOPICREFRESH", "topicrefresh", 'n', 8, ArrayLength(topicRefreshValues), topicRefreshValues },
{ "CSMSG_SET_CTCPREACTION", "ctcpreaction", 't', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues }
};
struct chanData *channelList;
static struct module *chanserv_module;
static unsigned int userCount;
+unsigned int chanserv_read_version = 0; /* db version control */
+
+#define CHANSERV_DB_VERSION 2
#define GetChannelUser(channel, handle) _GetChannelUser(channel, handle, 1, 0)
#define GetChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 0)
return level;
}
+char *
+user_level_name_from_level(int level)
+{
+ unsigned int ii;
+ char* highest;
+
+ highest = "None";
+ if(level >= 1)
+ highest = "Peon";
+ for(ii = 0; (ii < ArrayLength(accessLevels)); ii++)
+ if(level >= accessLevels[ii].level)
+ highest = accessLevels[ii].title;
+ return(highest);
+}
+
+
int
parse_level_range(unsigned short *minl, unsigned short *maxl, const char *arg)
{
ud->u_next->u_prev = ud;
ud->handle->channels = ud;
+ ud->flags = USER_FLAGS_DEFAULT;
return ud;
}
safestrncpy(bd->mask, mask, sizeof(bd->mask));
if(owner)
safestrncpy(bd->owner, owner, sizeof(bd->owner));
- bd->reason = reason ? strdup(reason) : NULL;
+ bd->reason = strdup(reason);
if(expires)
timeq_add(expires, expire_ban, bd);
timeq_del(0, NULL, channel, TIMEQ_IGNORE_FUNC | TIMEQ_IGNORE_WHEN);
- if(chanserv_conf.use_registered_mode)
+ if(off_channel > 0)
{
mod_chanmode_init(&change);
change.modes_clear |= MODE_REGISTERED;
/* Don't protect if no one is to be protected, someone is attacking
himself, or if the aggressor is an IRC Operator. */
- if(protect == 'n' || victim == aggressor || IsOper(aggressor))
+ if(protect == 'n' || victim == aggressor /* Opers dont get special treatment :/ || IsOper(aggressor) */)
return 0;
/* Don't protect if the victim isn't authenticated (because they
struct userData *cs_victim;
if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
- || (cs_victim->access < cData->lvlOpts[lvlGiveOps]))
+ || (cs_victim->access < UL_OP /* cData->lvlOpts[lvlGiveOps]*/))
&& !check_user_level(channel, user, lvlEnfOps, 0, 0))
{
send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
struct userData *cs_victim;
if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
- || (cs_victim->access < cData->lvlOpts[lvlGiveHalfOps]))
+ || (cs_victim->access < UL_HALFOP /* cData->lvlOpts[lvlGiveHalfOps] */))
&& !check_user_level(channel, user, lvlEnfHalfOps, 0, 0))
{
send_message(user, chanserv, "CSMSG_HOPBY_LOCKED");
}
static struct dnrList
-chanserv_find_dnrs(const char *chan_name, struct handle_info *handle)
+chanserv_find_dnrs(const char *chan_name, const char *handle)
{
struct dnrList list;
dict_iterator_t it;
struct do_not_register *dnr;
dnrList_init(&list);
- if(handle && (dnr = dict_find(handle_dnrs, handle->handle, NULL)))
+ if(handle && (dnr = dict_find(handle_dnrs, handle, NULL)))
dnrList_append(&list, dnr);
if(chan_name && (dnr = dict_find(plain_dnrs, chan_name, NULL)))
dnrList_append(&list, dnr);
}
static unsigned int
-chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_name, struct handle_info *handle)
+chanserv_show_dnrs(struct userNode *user, struct svccmd *cmd, const char *chan_name, const char *handle)
{
struct dnrList list;
struct do_not_register *dnr;
dict_iterator_t it;
reply("CSMSG_DNR_SEARCH_RESULTS");
+ reply("CSMSG_BAR");
matches = 0;
for(it = dict_first(handle_dnrs); it; it = iter_next(it))
{
}
reply("CSMSG_DNR_SEARCH_RESULTS");
+ reply("CSMSG_BAR");
if(*target == '*')
- matches = chanserv_show_dnrs(user, cmd, NULL, get_handle_info(target + 1));
+ matches = chanserv_show_dnrs(user, cmd, NULL, target + 1);
else
matches = chanserv_show_dnrs(user, cmd, target, NULL);
if(!matches)
static CHANSERV_FUNC(cmd_register)
{
- struct mod_chanmode *change;
struct handle_info *handle;
struct chanData *cData;
struct modeNode *mn;
return 0;
}
- if(!IsHelping(user) && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
+ if(!IsHelping(user)
+ && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
{
reply("CSMSG_MUST_BE_OPPED", channel->name);
return 0;
}
else
{
- if((argc < 2) || !IsChannelName(argv[1]))
+ if(argc < 2)
+ {
+ reply("MSG_MISSING_PARAMS", cmd->name);
+ svccmd_send_help_brief(user, chanserv, cmd);
+ return 0;
+ }
+ if(!IsChannelName(argv[1]))
{
reply("MSG_NOT_CHANNEL_NAME");
return 0;
if(!IsHelping(user))
reply("CSMSG_DNR_CHANNEL", chan_name);
else
- chanserv_show_dnrs(user, cmd, chan_name, handle);
+ chanserv_show_dnrs(user, cmd, chan_name, handle->handle);
return 0;
}
cData = register_channel(channel, user->handle_info->handle);
scan_user_presence(add_channel_user(cData, handle, UL_OWNER, 0, NULL), NULL);
cData->modes = chanserv_conf.default_modes;
- if(chanserv_conf.use_registered_mode)
+ if(off_channel > 0)
cData->modes.modes_set |= MODE_REGISTERED;
- change = mod_chanmode_dup(&cData->modes, 1);
- change->args[change->argc].mode = MODE_CHANOP;
- change->args[change->argc].u.member = AddChannelUser(chanserv, channel);
- change->argc++;
- mod_chanmode_announce(chanserv, channel, change);
- mod_chanmode_free(change);
+ if (IsOffChannel(cData))
+ {
+ mod_chanmode_announce(chanserv, channel, &cData->modes);
+ }
+ else
+ {
+ struct mod_chanmode *change = mod_chanmode_dup(&cData->modes, 1);
+ change->args[change->argc].mode = MODE_CHANOP;
+ change->args[change->argc].u.member = AddChannelUser(chanserv, channel);
+ change->argc++;
+ mod_chanmode_announce(chanserv, channel, change);
+ mod_chanmode_free(change);
+ }
/* Initialize the channel's max user record. */
cData->max = channel->members.used;
static CHANSERV_FUNC(cmd_move)
{
+ struct mod_chanmode change;
struct chanNode *target;
struct modeNode *mn;
struct userData *uData;
if(!IsHelping(user))
reply("CSMSG_DNR_CHANNEL_MOVE", argv[1]);
else
- chanserv_show_dnrs(user, cmd, argv[1], uData->handle);
+ chanserv_show_dnrs(user, cmd, argv[1], uData->handle->handle);
return 0;
}
}
}
+ mod_chanmode_init(&change);
if(!(target = GetChannel(argv[1])))
{
target = AddChannel(argv[1], now, NULL, NULL, NULL);
}
else if(!IsSuspended(channel->channel_info))
{
- struct mod_chanmode change;
- mod_chanmode_init(&change);
change.argc = 1;
change.args[0].mode = MODE_CHANOP;
change.args[0].u.member = AddChannelUser(chanserv, target);
mod_chanmode_announce(chanserv, target, &change);
}
+ if(off_channel > 0)
+ {
+ /* Clear MODE_REGISTERED from old channel, add it to new. */
+ change.argc = 0;
+ change.modes_clear = MODE_REGISTERED;
+ mod_chanmode_announce(chanserv, channel, &change);
+ change.modes_clear = 0;
+ change.modes_set = MODE_REGISTERED;
+ mod_chanmode_announce(chanserv, target, &change);
+ }
+
/* Move the channel_info to the target channel; it
shouldn't be necessary to clear timeq callbacks
for the old channel. */
if((actee = GetTrueChannelAccess(channel->channel_info, handle)))
{
- reply("CSMSG_USER_EXISTS", handle->handle, channel->name, actee->access);
+ reply("CSMSG_USER_EXISTS", handle->handle, channel->name, user_level_name_from_level(actee->access));
return 0;
}
actee = add_channel_user(channel->channel_info, handle, access, 0, NULL);
scan_user_presence(actee, NULL);
- reply("CSMSG_ADDED_USER", handle->handle, channel->name, access);
+ reply("CSMSG_ADDED_USER", handle->handle, channel->name, user_level_name_from_level(access), access);
return 1;
}
}
victim->access = new_access;
- reply("CSMSG_CHANGED_ACCESS", handle->handle, new_access, channel->name);
+ reply("CSMSG_CHANGED_ACCESS", handle->handle, user_level_name_from_level(new_access), new_access, channel->name);
return 1;
}
}
if(access != victim->access)
{
- reply("CSMSG_INCORRECT_ACCESS", handle->handle, victim->access, argv[1]);
+ reply("CSMSG_INCORRECT_ACCESS", handle->handle, user_level_name_from_level(victim->access), argv[1]);
return 0;
}
}
reply("CSMSG_GODMODE_UP", argv[0]);
return 0;
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveOps])
+ else if(uData->access >= UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
{
change.args[0].mode = MODE_CHANOP;
errmsg = "CSMSG_ALREADY_OPPED";
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveHalfOps])
+ else if(uData->access >= UL_HALFOP /*channel->channel_info->lvlOpts[lvlGiveHalfOps]*/)
{
change.args[0].mode = MODE_HALFOP;
errmsg = "CSMSG_ALREADY_HALFOPPED";
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON && (channel->channel_info->chOpts[chVoice] == 'p' || channel->channel_info->chOpts[chVoice] == 'a'))
{
change.args[0].mode = MODE_VOICE;
errmsg = "CSMSG_ALREADY_VOICED";
reply("CSMSG_MASK_PROTECTED", argv[1]);
return 0;
}
+ /* We dont actually want a victem count if were banning a mask manually, IMO -Rubin*/
+ if(cmd)
+ victimCount = 0; /* Dont deop etc ppl who match this */
+#ifdef entropy_lameness
if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user))
{
reply("CSMSG_LAME_MASK", argv[1]);
return 0;
}
+#endif
if((action == ACTION_KICK) && (victimCount == 0))
{
}
else if(ban)
{
+ /* WHAT DOES THIS DO?? -Rubin */
for(n = 0; n < chanserv_conf.old_ban_names->used; ++n)
{
extern const char *hidden_host_suffix;
if(!match[ii])
continue;
change->args[count].mode = MODE_REMOVE | MODE_BAN;
- change->args[count++].u.hostmask = bans->list[ii]->ban;
+ change->args[count++].u.hostmask = strdup(bans->list[ii]->ban);
}
+ assert(count == change->argc);
return change;
}
change = find_matching_bans(&channel->banlist, actee, mask);
if(change)
{
+ unsigned int ii;
+
modcmd_chanmode_announce(change);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
acted = 1;
}
for(ii=0; ii<channel->banlist.used; ii++)
{
change->args[ii].mode = MODE_REMOVE | MODE_BAN;
- change->args[ii].u.hostmask = channel->banlist.list[ii]->ban;
+ change->args[ii].u.hostmask = strdup(channel->banlist.list[ii]->ban);
}
modcmd_chanmode_announce(change);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
reply("CSMSG_BANS_REMOVED", channel->name);
return 1;
static CHANSERV_FUNC(cmd_open)
{
struct mod_chanmode *change;
+ unsigned int ii;
change = find_matching_bans(&channel->banlist, user, NULL);
if(!change)
change->modes_clear &= ~channel->channel_info->modes.modes_set;
modcmd_chanmode_announce(change);
reply("CSMSG_CHANNEL_OPENED", channel->name);
+ for(ii = 0; ii < change->argc; ++ii)
+ free((char*)change->args[ii].u.hostmask);
mod_chanmode_free(change);
return 1;
}
continue;
sbuf.used = 0;
string_buffer_append_printf(&sbuf, "[%s (%d", cData->channel->name, uData->access);
- if(uData->flags != USER_AUTO_OP)
+ if(uData->flags == USER_AUTO_OP)
string_buffer_append(&sbuf, ',');
if(IsUserSuspended(uData))
string_buffer_append(&sbuf, 's');
if(IsUserAutoOp(uData))
{
- if(uData->access >= cData->lvlOpts[lvlGiveOps])
+ if(uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/)
string_buffer_append(&sbuf, 'o');
- else if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+ else if(uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
string_buffer_append(&sbuf, 'h');
- else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON /*cData->lvlOpts[lvlGiveVoice]*/)
string_buffer_append(&sbuf, 'v');
}
if(IsUserAutoInvite(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
&& ((target_handle->opserv_level >= chanserv_conf.nodelete_level) || !IsProtected(channel->channel_info));
if((uData = GetTrueChannelAccess(channel->channel_info, target_handle)))
{
- reply((helping ? "CSMSG_HELPER_HAS_ACCESS" : "CSMSG_USER_HAS_ACCESS"), prefix, uData->access, channel->name);
+ reply((helping ? "CSMSG_HELPER_HAS_ACCESS" : "CSMSG_USER_HAS_ACCESS"), prefix, user_level_name_from_level(uData->access), uData->access, channel->name);
/* To prevent possible information leaks, only show infolines
* if the requestor is in the channel or it's their own
* handle. */
return 1;
}
+/* This is never used... */
static void
zoot_list(struct listData *list)
{
if(list->table.length == 1)
{
if(list->search)
- send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, list->lowest, list->highest, list->search);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
else
- send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, list->lowest, list->highest);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
msg = user_find_message(list->user, "MSG_NONE");
send_message_type(4, list->user, list->bot, " %s", msg);
}
if((curr == list->table.length) || (list->users[curr-1]->access < lowest))
{
if(list->search)
- send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, lowest, highest, list->search);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest), list->search);
else
- send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, lowest, highest);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(lowest), user_level_name_from_level(highest));
temp = list->table.contents[--start];
list->table.contents[start] = list->table.contents[0];
tmp_table.contents = list->table.contents + start;
{
const char *msg;
if(list->search)
- send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, list->lowest, list->highest, list->search);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
else
- send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, list->lowest, list->highest);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
table_send(list->bot, list->user->nick, 0, NULL, list->table);
if(list->table.length == 1)
{
lData.highest = highest;
lData.search = (argc > 1) ? argv[1] : NULL;
send_list = def_list;
+ /* What does the following line do exactly?? */
(void)zoot_list; /* since it doesn't show user levels */
+ /* this does nothing!! -rubin
if(user->handle_info)
{
switch(user->handle_info->userlist_style)
case HI_STYLE_ZOOT: send_list = def_list; break;
}
}
+ */
lData.users = alloca(channel->channel_info->userCount * sizeof(struct userData *));
matches = 0;
qsort(lData.users, matches, sizeof(lData.users[0]), userData_access_comp);
lData.table.length = matches+1;
- lData.table.width = 4;
+ lData.table.width = 5;
lData.table.flags = TABLE_NO_FREE;
lData.table.contents = malloc(lData.table.length*sizeof(*lData.table.contents));
ary = malloc(lData.table.width*sizeof(**lData.table.contents));
lData.table.contents[0] = ary;
ary[0] = "Access";
- ary[1] = "Account";
- ary[2] = "Last Seen";
- ary[3] = "Status";
+ ary[1] = "Level";
+ ary[2] = "Account";
+ ary[3] = "Last Seen";
+ ary[4] = "Status";
for(matches = 1; matches < lData.table.length; ++matches)
{
struct userData *uData = lData.users[matches-1];
ary = malloc(lData.table.width*sizeof(**lData.table.contents));
lData.table.contents[matches] = ary;
- ary[0] = strtab(uData->access);
- ary[1] = uData->handle->handle;
+ /* ary[0] = strtab(uData->access);*/
+ ary[0] = user_level_name_from_level(uData->access);
+ /* TODO: replace above with func that returns static string
+ * of userlevel for that level. eg OP/MANAGER etc. -rubin */
+ ary[1] = strtab(uData->access);
+ ary[2] = uData->handle->handle;
if(uData->present)
- ary[2] = "Here";
+ ary[3] = "Here";
else if(!uData->seen)
- ary[2] = "Never";
+ ary[3] = "Never";
else
- ary[2] = intervalString(seen, now - uData->seen, user->handle_info);
- ary[2] = strdup(ary[2]);
+ ary[3] = intervalString(seen, now - uData->seen, user->handle_info);
+ ary[3] = strdup(ary[3]);
if(IsUserSuspended(uData))
- ary[3] = "Suspended";
+ ary[4] = "Suspended";
else if(HANDLE_FLAGGED(uData->handle, FROZEN))
- ary[3] = "Vacation";
+ ary[4] = "Vacation";
else
- ary[3] = "Normal";
+ ary[4] = "Normal";
}
send_list(&lData);
for(matches = 1; matches < lData.table.length; ++matches)
{
- free((char*)lData.table.contents[matches][2]);
+ free((char*)lData.table.contents[matches][3]);
free(lData.table.contents[matches]);
}
free(lData.table.contents[0]);
else
search = NULL;
+ reply("CSMSG_BANS_HEADER", channel->name);
bans = alloca(channel->channel_info->banCount * sizeof(struct banData *));
for(ban = channel->channel_info->bans; ban; ban = ban->next)
tbl.contents[ii][3] = ban->reason;
}
table_send(cmd->parent->bot, user->nick, 0, NULL, tbl);
- reply("MSG_MATCH_COUNT", matches);
+ /* reply("MSG_MATCH_COUNT", matches); */
for(ii = 1; ii < tbl.length; ++ii)
{
free((char*)tbl.contents[ii][2]);
return 1;
}
+/* bad_topic
+ *
+ * return + if the user does NOT have the right to set the topic, and
+ * the topic is changed.
+ */
static int
bad_topic(struct chanNode *channel, struct userNode *user, const char *new_topic)
{
struct chanData *cData = channel->channel_info;
if(check_user_level(channel, user, lvlEnfTopic, 1, 0))
return 0;
- if(cData->topic_mask)
- return !match_ircglob(new_topic, cData->topic_mask);
else if(cData->topic)
return irccasecmp(new_topic, cData->topic);
else
return 0;
}
+/* conform_topic
+ *
+ * Makes a givin topic fit into a givin topic mask and returns
+ * the results.
+ *
+ * topic_mask - the mask to conform to
+ * topic - the topic to make conform
+ * new_topic - the pre-allocated char* to put the new topic into
+ *
+ * modifies: new_topic
+ */
+void
+conform_topic(char* topic_mask, char* topic, char *new_topic)
+{
+ //char *topic_mask = cData->topic_mask;
+ char tchar;
+ int pos=0, starpos=-1, dpos=0, len;
+
+ while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
+ {
+ switch(tchar)
+ {
+ case '*':
+ if(starpos != -1)
+ {
+ strcpy(new_topic, "");
+ return;
+ }
+ len = strlen(topic);
+ if((dpos + len) > TOPICLEN)
+ len = TOPICLEN + 1 - dpos;
+ memcpy(new_topic+dpos, topic, len);
+ dpos += len;
+ starpos = pos;
+ break;
+ case '\\': tchar = topic_mask[pos++]; /* and fall through */
+ default: new_topic[dpos++] = tchar; break;
+ }
+ }
+ if((dpos > TOPICLEN) || tchar)
+ {
+ strcpy(new_topic, "");
+ return;
+ }
+ new_topic[dpos] = 0;
+ return;
+}
+
static CHANSERV_FUNC(cmd_topic)
{
struct chanData *cData;
cData = channel->channel_info;
if(argc < 2)
{
- if(cData->topic)
- {
- SetChannelTopic(channel, chanserv, cData->topic, 1);
- reply("CSMSG_TOPIC_SET", cData->topic);
+ if(cData->topic)
+ {
+ SetChannelTopic(channel, chanserv, cData->topic, 1);
+ reply("CSMSG_TOPIC_SET", cData->topic);
return 1;
- }
+ }
reply("CSMSG_NO_TOPIC", channel->name);
return 0;
/* If they say "!topic *", use an empty topic. */
if((topic[0] == '*') && (topic[1] == 0))
topic[0] = 0;
+
if(bad_topic(channel, user, topic))
{
- char *topic_mask = cData->topic_mask;
- if(topic_mask)
+ reply("CSMSG_TOPIC_LOCKED", channel->name);
+ return 0;
+ }
+ else
+ {
+ /* If there is a topicmask set, and the new topic doesnt match, make it */
+ if(cData->topic_mask && !match_ircglob(topic, cData->topic_mask))
{
- char new_topic[TOPICLEN+1], tchar;
- int pos=0, starpos=-1, dpos=0, len;
+ char *topic_mask = cData->topic_mask;
+ char new_topic[TOPICLEN+1];
- while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
+ /* make a new topic fitting mask */
+ conform_topic(topic_mask, topic, new_topic);
+ if(!*new_topic)
{
- switch(tchar)
- {
- case '*':
- if(starpos != -1)
- goto bad_mask;
- len = strlen(topic);
- if((dpos + len) > TOPICLEN)
- len = TOPICLEN + 1 - dpos;
- memcpy(new_topic+dpos, topic, len);
- dpos += len;
- starpos = pos;
- break;
- case '\\': tchar = topic_mask[pos++]; /* and fall through */
- default: new_topic[dpos++] = tchar; break;
- }
- }
- if((dpos > TOPICLEN) || tchar)
- {
- bad_mask:
+ /* Topic couldnt fit into mask, was too long */
reply("CSMSG_TOPICMASK_CONFLICT1", channel->name, topic_mask);
reply("CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
return 0;
}
- new_topic[dpos] = 0;
SetChannelTopic(channel, chanserv, new_topic, 1);
- } else {
- reply("CSMSG_TOPIC_LOCKED", channel->name);
- return 0;
}
+ else /* No mask set, just set the topic */
+ SetChannelTopic(channel, chanserv, topic, 1);
}
- else
- SetChannelTopic(channel, chanserv, topic, 1);
if(check_user_level(channel, user, lvlTopicSnarf, 1, 0))
{
cData = channel->channel_info;
reply("CSMSG_CHANNEL_INFO", channel->name);
+ reply("CSMSG_BAR");
uData = GetChannelUser(cData, user->handle_info);
- if(uData && (uData->access >= cData->lvlOpts[lvlGiveOps]))
+ if(uData && (uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/))
{
mod_chanmode_format(&cData->modes, modes);
reply("CSMSG_CHANNEL_TOPIC", cData->topic);
reply("CSMSG_CHANNEL_SUSPENDED", channel->name);
show_suspension_info(cmd, user, cData->suspended);
}
+ reply("CSMSG_CHANNEL_END");
return 1;
}
irc_make_chanmode(channel, modes);
reply("CSMSG_PEEK_INFO", channel->name);
+ reply("CSMSG_BAR");
reply("CSMSG_PEEK_TOPIC", channel->topic);
reply("CSMSG_PEEK_MODES", modes);
reply("CSMSG_PEEK_USERS", channel->members.used);
}
else
reply("CSMSG_PEEK_NO_OPS");
+ reply("CSMSG_PEEK_END");
return 1;
}
continue;
uData = GetChannelAccess(cData, mn->user->handle_info);
- if(!cData->lvlOpts[lvlGiveOps]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveOps]))
+ if(uData && uData->access >= UL_OP /* cData->lvlOpts[lvlGiveOps]*/)
{
if(!(mn->modes & MODE_CHANOP))
{
changes->args[used++].u.member = mn;
}
}
- else if(!cData->lvlOpts[lvlGiveHalfOps]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveHalfOps]))
+ else if(uData && uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
{
if(!(mn->modes & MODE_HALFOP))
{
changes->args[used++].u.member = mn;
}
}
- else if(!cData->lvlOpts[lvlGiveVoice]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveVoice]))
+ else if(uData && uData->access >= UL_PEON /* cData->lvlOpts[lvlGiveVoice]*/)
{
if(mn->modes & MODE_CHANOP)
{
discrim.severities = 1 << LOG_COMMAND;
report.reporter = chanserv;
report.user = user;
- reply("CSMSG_EVENT_SEARCH_RESULTS");
+ reply("CSMSG_EVENT_SEARCH_RESULTS", channel->name);
+ reply("CSMSG_BAR");
matches = log_entry_search(&discrim, log_report_entry, &report);
if(matches)
reply("MSG_MATCH_COUNT", matches);
{
struct suspended *suspended = data;
struct chanNode *channel;
- struct mod_chanmode change;
if(!suspended->expires || (now < suspended->expires))
suspended->revoked = now;
channel = suspended->cData->channel;
suspended->cData->channel = channel;
suspended->cData->flags &= ~CHANNEL_SUSPENDED;
- mod_chanmode_init(&change);
- change.argc = 1;
- change.args[0].mode = MODE_CHANOP;
- change.args[0].u.member = AddChannelUser(chanserv, channel);
- mod_chanmode_announce(chanserv, channel, &change);
+ if(!IsOffChannel(suspended->cData))
+ {
+ struct mod_chanmode change;
+ mod_chanmode_init(&change);
+ change.argc = 1;
+ change.args[0].mode = MODE_CHANOP;
+ change.args[0].u.member = AddChannelUser(chanserv, channel);
+ mod_chanmode_announce(chanserv, channel, &change);
+ }
}
static CHANSERV_FUNC(cmd_csuspend)
search->limit = INT_MAX;
if(action == search_print)
+ {
reply("CSMSG_CHANNEL_SEARCH_RESULTS");
+ reply("CSMSG_BAR");
+ }
matches = chanserv_channel_search(search, action, user);
}
switch(option)
{
+ /* removing these level sets..
case lvlGiveVoice:
if(value > cData->lvlOpts[lvlGiveOps])
{
return 0;
}
break;
+ */
case lvlSetters:
/* This test only applies to owners, since non-owners
* trying to set an option to above their level get caught
{
return channel_level_option(lvlEnfHalfOps, CSFUNC_ARGS);
}
-
+/*
static MODCMD_FUNC(chan_opt_giveops)
{
return channel_level_option(lvlGiveOps, CSFUNC_ARGS);
{
return channel_level_option(lvlGiveHalfOps, CSFUNC_ARGS);
}
-
+*/
static MODCMD_FUNC(chan_opt_enfmodes)
{
return channel_level_option(lvlEnfModes, CSFUNC_ARGS);
return channel_level_option(lvlUserInfo, CSFUNC_ARGS);
}
+/*
static MODCMD_FUNC(chan_opt_givevoice)
{
return channel_level_option(lvlGiveVoice, CSFUNC_ARGS);
}
+*/
static MODCMD_FUNC(chan_opt_topicsnarf)
{
return 1;
}
+static MODCMD_FUNC(chan_opt_voice)
+{
+ return channel_multiple_option(chVoice, CSFUNC_ARGS);
+}
+
static MODCMD_FUNC(chan_opt_protect)
{
return channel_multiple_option(chProtect, CSFUNC_ARGS);
if(argc < 2)
{
- reply("CSMSG_CHANNEL_OPTIONS");
+ reply("CSMSG_CHANNEL_OPTIONS", channel->name);
+ reply("CSMSG_BAR");
for(ii = 0; ii < set_shows_list.used; ii++)
{
subcmd = set_shows_list.list[ii];
subcmd->command->func(user, channel, 1, argv+1, subcmd);
}
+ reply("CSMSG_CHANNEL_OPTIONS_END");
return 1;
}
return 1;
}
-static MODCMD_FUNC(user_opt_noautoop)
+static MODCMD_FUNC(user_opt_autoop)
{
struct userData *uData;
reply("CSMSG_NOT_USER", channel->name);
return 0;
}
- if(uData->access < channel->channel_info->lvlOpts[lvlGiveOps])
- return user_binary_option("CSMSG_USET_NOAUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
+ if(uData->access < UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
+ return user_binary_option("CSMSG_USET_AUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
else
- return user_binary_option("CSMSG_USET_NOAUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
+ 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)
{
char *options[] =
{
- "NoAutoOp", "AutoInvite", "Info"
+ "AutoOp", "AutoInvite", "Info"
};
if(!uset_shows_list.size)
new_owner = GetChannelAccess(cData, new_owner_hi);
if(!new_owner)
{
- reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
- return 0;
+ if(force)
+ {
+ new_owner = add_channel_user(cData, new_owner_hi, UL_COOWNER, 0, NULL);
+ }
+ else
+ {
+ reply("CSMSG_NO_CHAN_USER", new_owner_hi->handle, channel->name);
+ return 0;
+ }
}
if((chanserv_get_owned_count(new_owner_hi) >= chanserv_conf.max_owned) && !force)
{
if(!IsHelping(user))
reply("CSMSG_DNR_ACCOUNT", new_owner_hi->handle);
else
- chanserv_show_dnrs(user, cmd, NULL, new_owner_hi);
+ chanserv_show_dnrs(user, cmd, NULL, new_owner_hi->handle);
return 0;
}
if(new_owner->access >= UL_COOWNER)
if(channel->join_flooded)
{
- /* don't automatically give ops or voice during a join flood */
+ /* don't automatically give non users ops or voice during a join flood */
}
- else if(cData->lvlOpts[lvlGiveOps] == 0)
- modes |= MODE_CHANOP;
- else if(cData->lvlOpts[lvlGiveHalfOps] == 0)
- modes |= MODE_HALFOP;
- else if(cData->lvlOpts[lvlGiveVoice] == 0)
+ /* EVERYONE is to get voice */
+ else if(cData->chOpts[chVoice] == 'a')
modes |= MODE_VOICE;
greeting = cData->greeting;
uData = GetTrueChannelAccess(cData, handle);
if(uData && !IsUserSuspended(uData))
{
- /* Ops and above were handled by the above case. */
+ /* non users getting voice are handled above. */
if(IsUserAutoOp(uData))
{
- if(uData->access >= cData->lvlOpts[lvlGiveOps])
+ if(uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/)
modes |= MODE_CHANOP;
- if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+ if(uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
modes |= MODE_HALFOP;
- else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON && cData->chOpts[chVoice] == 'p')
modes |= MODE_VOICE;
}
if(uData->access >= UL_PRESENT)
if(IsUserAutoOp(channel))
{
- if(channel->access >= cn->channel_info->lvlOpts[lvlGiveOps])
+ if(channel->access >= UL_OP /* cn->channel_info->lvlOpts[lvlGiveOps] */)
change.args[0].mode = MODE_CHANOP;
- else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveHalfOps])
+ else if(channel->access >= UL_HALFOP /* cn->channel_info->lvlOpts[lvlGiveHalfOps]*/)
change.args[0].mode = MODE_HALFOP;
- else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveVoice])
+ else if(channel->access >= UL_PEON /* cn->channel_info->lvlOpts[lvlGiveVoice]*/)
change.args[0].mode = MODE_VOICE;
else
change.args[0].mode = 0;
struct banData *ban;
if((user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP|MODE_VOICE))
- || !channel->channel_info)
+ || !channel->channel_info
+ || IsSuspended(channel->channel_info))
continue;
for(jj = 0; jj < channel->banlist.used; ++jj)
if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
cData = channel->channel_info;
if(bad_topic(channel, user, channel->topic))
- {
+ { /* User doesnt have privs to set topics. Undo it */
send_message(user, chanserv, "CSMSG_TOPIC_LOCKED", channel->name);
- if(cData->topic_mask && match_ircglob(old_topic, cData->topic_mask))
- SetChannelTopic(channel, chanserv, old_topic, 1);
- else if(cData->topic)
- SetChannelTopic(channel, chanserv, cData->topic, 1);
+ SetChannelTopic(channel, chanserv, old_topic, 1);
return 1;
}
+ /* If there is a topic mask set, and the new topic doesnt match,
+ * set the topic to mask + new_topic */
+ if(cData->topic_mask && !match_ircglob(channel->topic, cData->topic_mask))
+ {
+ char new_topic[TOPICLEN+1];
+ conform_topic(cData->topic_mask, channel->topic, new_topic);
+ if(*new_topic)
+ {
+ SetChannelTopic(channel, chanserv, new_topic, 1);
+ /* and fall through to topicsnarf code below.. */
+ }
+ else /* Topic couldnt fit into mask, was too long */
+ {
+ SetChannelTopic(channel, chanserv, old_topic, 1);
+ send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT1", channel->name, cData->topic_mask);
+ send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
+ return 1;
+ }
+ }
/* With topicsnarf, grab the topic and save it as the default topic. */
if(check_user_level(channel, user, lvlTopicSnarf, 0, 0))
{
if(!bounce)
bounce = mod_chanmode_alloc(change->argc + 1 - ii);
bounce->args[bnc].mode = MODE_REMOVE | MODE_BAN;
- bounce->args[bnc].u.hostmask = ban;
+ bounce->args[bnc].u.hostmask = strdup(ban);
bnc++;
send_message(user, chanserv, "CSMSG_MASK_PROTECTED", ban);
}
{
if((bounce->argc = bnc) || bounce->modes_set || bounce->modes_clear)
mod_chanmode_announce(chanserv, channel, bounce);
+ for(ii = 0; ii < change->argc; ++ii)
+ if(bounce->args[ii].mode == (MODE_REMOVE | MODE_BAN))
+ free((char*)bounce->args[ii].u.hostmask);
mod_chanmode_free(bounce);
}
}
str = database_get_data(conf_node, KEY_INFO_DELAY, RECDB_QSTRING);
chanserv_conf.info_delay = str ? ParseInterval(str) : 180;
str = database_get_data(conf_node, KEY_MAX_GREETLEN, RECDB_QSTRING);
- chanserv_conf.greeting_length = str ? atoi(str) : 120;
+ chanserv_conf.greeting_length = str ? atoi(str) : 200;
str = database_get_data(conf_node, KEY_ADJUST_THRESHOLD, RECDB_QSTRING);
chanserv_conf.adjust_threshold = str ? atoi(str) : 15;
str = database_get_data(conf_node, KEY_ADJUST_DELAY, RECDB_QSTRING);
/* free form text */
"DefaultTopic", "TopicMask", "Greeting", "UserGreeting", "Modes",
/* options based on user level */
- "PubCmd", "InviteMe", "UserInfo", "GiveVoice", "GiveHalfOps", "GiveOps", "EnfOps",
+ "PubCmd", "InviteMe", "UserInfo",/* "GiveVoice", "GiveHalfOps", "GiveOps", */ "EnfOps",
"EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", "CtcpUsers",
/* multiple choice options */
"CtcpReaction", "Protect", "Toys", "TopicRefresh",
else
strlist = alloc_string_list(2);
chanserv_conf.old_ban_names = strlist;
- /* the variable itself is actually declared in proto-common.c; this is equally
- * parse issue. */
str = database_get_data(conf_node, "off_channel", RECDB_QSTRING);
- off_channel = (str && enabled_string(str)) ? 1 : 0;
- str = database_get_data(conf_node, "use_registered_mode", RECDB_QSTRING);
- chanserv_conf.use_registered_mode = (str && enabled_string(str)) ? 1 : 0;
+ off_channel = str ? atoi(str) : 0;
}
static void
uData = add_channel_user(chan, handle, access, last_seen, inf);
uData->flags = flags ? strtoul(flags, NULL, 0) : 0;
+
+ /* Upgrade: set autoop to the inverse of noautoop */
+ if(chanserv_read_version < 2)
+ {
+ /* if noautoop is true, set autoop false, and vice versa */
+ if(uData->flags & USER_NOAUTO_OP)
+ uData->flags = uData->flags & ~USER_AUTO_OP;
+ else
+ uData->flags = uData->flags | USER_AUTO_OP;
+ log_module(CS_LOG, LOG_INFO, "UPGRADE: to db version 2 from %u. Changing flag to %d for %s in %s.", chanserv_read_version, uData->flags, key, chan->channel->name);
+ }
+
}
static void
s_expires = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING);
owner = database_get_data(rd->d.object, KEY_OWNER, RECDB_QSTRING);
reason = database_get_data(rd->d.object, KEY_REASON, RECDB_QSTRING);
+ if (!reason || !owner)
+ return;
set_time = set ? (time_t)strtoul(set, NULL, 0) : now;
triggered_time = triggered ? (time_t)strtoul(triggered, NULL, 0) : 0;
else
expires_time = 0;
- if(expires_time && (expires_time < now))
+ if(!reason || (expires_time && (expires_time < now)))
return;
bData = add_channel_ban(chan, key, owner, set_time, triggered_time, expires_time, reason);
&& (argc = split_line(str, 0, ArrayLength(argv), argv))
&& (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE))) {
cData->modes = *modes;
- if(chanserv_conf.use_registered_mode)
+ if(off_channel > 0)
cData->modes.modes_set |= MODE_REGISTERED;
if(cData->modes.argc > 1)
cData->modes.argc = 1;
dnr->set = 0;
}
+static void
+chanserv_version_read(struct dict *section)
+{
+ /* global var.. */
+ char *str;
+ str = database_get_data(section, KEY_VERSION_NUMBER, RECDB_QSTRING);
+ if(str)
+ chanserv_read_version = atoi(str);
+ log_module(CS_LOG, LOG_DEBUG, "Chanserv db version is %d.", chanserv_read_version);
+}
+
static int
chanserv_saxdb_read(struct dict *database)
{
struct dict *section;
dict_iterator_t it;
+ if((section = database_get_data(database, KEY_VERSION_CONTROL, RECDB_OBJECT)))
+ chanserv_version_read(section);
+
if((section = database_get_data(database, KEY_NOTE_TYPES, RECDB_OBJECT)))
for(it = dict_first(section); it; it = iter_next(it))
chanserv_note_type_read(iter_key(it), iter_data(it));
dict_iterator_t it;
struct chanData *channel;
+ /* Version Control*/
+ saxdb_start_record(ctx, KEY_VERSION_CONTROL, 1);
+ saxdb_write_int(ctx, KEY_VERSION_NUMBER, CHANSERV_DB_VERSION);
+ saxdb_end_record(ctx);
+
/* Notes */
saxdb_start_record(ctx, KEY_NOTE_TYPES, 1);
for(it = dict_first(note_types); it; it = iter_next(it))
DEFINE_CHANNEL_OPTION(modes);
DEFINE_CHANNEL_OPTION(enfops);
DEFINE_CHANNEL_OPTION(enfhalfops);
- DEFINE_CHANNEL_OPTION(giveops);
+ /*DEFINE_CHANNEL_OPTION(giveops);
DEFINE_CHANNEL_OPTION(givehalfops);
+ */
+ DEFINE_CHANNEL_OPTION(voice);
DEFINE_CHANNEL_OPTION(protect);
DEFINE_CHANNEL_OPTION(enfmodes);
DEFINE_CHANNEL_OPTION(enftopic);
DEFINE_CHANNEL_OPTION(pubcmd);
- DEFINE_CHANNEL_OPTION(givevoice);
+ /*DEFINE_CHANNEL_OPTION(givevoice);
+ */
DEFINE_CHANNEL_OPTION(userinfo);
DEFINE_CHANNEL_OPTION(dynlimit);
DEFINE_CHANNEL_OPTION(topicsnarf);
DEFINE_CHANNEL_OPTION(ctcpusers);
DEFINE_CHANNEL_OPTION(ctcpreaction);
DEFINE_CHANNEL_OPTION(inviteme);
- if(off_channel)
+ if(off_channel > 1)
DEFINE_CHANNEL_OPTION(offchannel);
modcmd_register(chanserv_module, "set defaults", chan_opt_defaults, 1, 0, "access", "owner", NULL);
modcmd_register(chanserv_module, "set topic", chan_opt_defaulttopic, 1, 0, NULL);
/* User options */
- DEFINE_USER_OPTION(noautoop);
DEFINE_USER_OPTION(autoinvite);
DEFINE_USER_OPTION(info);
+ DEFINE_USER_OPTION(autoop);
/* Alias uset autovoice to uset autoop. */
- modcmd_register(chanserv_module, "uset noautovoice", user_opt_noautoop, 1, 0, NULL);
+ modcmd_register(chanserv_module, "uset autovoice", user_opt_autoop, 1, 0, NULL);
note_types = dict_new();
dict_set_free_data(note_types, chanserv_deref_note_type);
service_register(chanserv)->trigger = '!';
reg_chanmsg_func('\001', chanserv, chanserv_ctcp_check);
}
+
saxdb_register("ChanServ", chanserv_saxdb_read, chanserv_saxdb_write);
if(chanserv_conf.channel_expire_frequency)
next_refresh = (now + chanserv_conf.refresh_period - 1) / chanserv_conf.refresh_period * chanserv_conf.refresh_period;
timeq_add(next_refresh, chanserv_refresh_topics, NULL);
}
-
+
reg_exit_func(chanserv_db_cleanup);
message_register_table(msgtab);
}
projects / irc / evilnet / x3.git / blobdiff