*
* x3 is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
#define KEY_NOTES "notes"
#define KEY_TOPIC_MASK "topic_mask"
#define KEY_OWNER_TRANSFER "owner_transfer"
+#define KEY_MAXSETINFO "maxsetinfo"
/* User data */
#define KEY_LEVEL "level"
#define KEY_INFO "info"
#define KEY_SEEN "seen"
+#define KEY_ACCESSEXPIRY "accessexpiry"
+#define KEY_CLVLEXPIRY "clvlexpiry"
+#define KEY_LASTLEVEL "lastlevel"
/* Ban data */
#define KEY_OWNER "owner"
{ "CSMSG_DELETED_YOU", "Your $b%d$b access has been deleted from $b%s$b." },
/* User management */
+ { "CSMSG_AUTO_DELETED", "Your %s access has expired in %s." },
+ { "CSMSG_CLVL_EXPIRED", "Your CLVL access has expired in %s." },
{ "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_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_NO_BUMP_EXPIRY", "You cannot give users timed $bCLVL$b's when they already have timed access." },
{ "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_BAN_DONE", "Banned $b%s$b from %s." },
{ "CSMSG_REASON_CHANGE", "Reason for LAMER $b%s$b changed." },
{ "CSMSG_LAMER_EXTENDED", "Extended LAMER for $b%s$b, now expires in %s." },
- { "CSMSG_BAN_REMOVED", "Matching ban(s) and LAMER(s) in $b%s$b were removed." },
+ { "CSMSG_BAN_REMOVED", "Ban(s) and LAMER(s) matching $b%s$b were removed." },
{ "CSMSG_TRIMMED_LAMERS", "Trimmed $b%d LAMERs$b from the %s LAMER list that were inactive for at least %s." },
{ "CSMSG_REDUNDANT_BAN", "$b%s$b is already banned in %s." },
{ "CSMSG_REDUNDANT_LAMER", "$b%s$b is already LAMER'd in %s." },
{ "CSMSG_SET_TOPICREFRESH", "$bTopicRefresh$b %d - %s" },
{ "CSMSG_SET_RESYNC", "$bResync $b %d - %s" },
{ "CSMSG_SET_BANTIMEOUT", "$bBanTimeout $b %d - %s" },
+ { "CSMSG_SET_MAXSETINFO", "$bMaxSetInfo $b %d - maximum characters in a setinfo line." },
{ "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." },
}
static struct userData*
-add_channel_user(struct chanData *channel, struct handle_info *handle, unsigned short access, time_t seen, const char *info)
+add_channel_user(struct chanData *channel, struct handle_info *handle, unsigned short access, time_t seen, const char *info, time_t accessexpiry)
{
struct userData *ud;
ud->seen = seen;
ud->access = access;
ud->info = info ? strdup(info) : NULL;
+ ud->accessexpiry = accessexpiry ? accessexpiry : 0;
+ ud->clvlexpiry = 0;
+ ud->lastaccess = 0;
ud->prev = NULL;
ud->next = channel->users;
static void unregister_channel(struct chanData *channel, const char *reason);
+static void
+chanserv_expire_tempuser(void *data)
+{
+ struct userData *uData = data;
+ char *handle;
+
+ if (data) {
+ handle = strdup(uData->handle->handle);
+ if (uData->accessexpiry > 0) {
+ if (uData->present) {
+ struct userNode *user, *next_un = NULL;
+ struct handle_info *hi;
+
+ hi = get_handle_info(handle);
+ for (user = hi->users; user; user = next_un) {
+ struct mod_chanmode *change;
+ struct modeNode *mn;
+ unsigned int count = 0;
+
+ send_message(user, chanserv, "CSMSG_AUTO_DELETED", chanserv->nick, uData->channel->channel->name);
+ if (!(mn = GetUserMode(uData->channel->channel, user)) || !(mn->modes & MODE_CHANOP)) {
+ next_un = user->next_authed;
+ continue;
+ }
+
+ change = mod_chanmode_alloc(2);
+ change->args[count].mode = MODE_REMOVE | MODE_CHANOP;
+ change->args[count++].u.member = mn;
+
+ if (count) {
+ change->argc = count;
+ mod_chanmode_announce(chanserv, uData->channel->channel, change);
+ }
+ mod_chanmode_free(change);
+ next_un = user->next_authed;
+ }
+ }
+ del_channel_user(uData, 1);
+ }
+ }
+}
+
+static void
+chanserv_expire_tempclvl(void *data)
+{
+ struct userData *uData = data;
+ char *handle;
+
+ if (data) {
+ handle = strdup(uData->handle->handle);
+ if (uData->clvlexpiry > 0) {
+ int changemodes = 0;
+ unsigned int mode = 0;
+
+ if (((uData->lastaccess == UL_PEON) || (uData->lastaccess == UL_HALFOP)) && (uData->access >= UL_OP)) {
+ changemodes = 1;
+ mode = MODE_REMOVE | MODE_CHANOP;
+ } else if ((uData->lastaccess == UL_PEON) && (uData->access == UL_HALFOP)) {
+ changemodes = 1;
+ mode = MODE_REMOVE | MODE_HALFOP;
+ } else
+ changemodes = 0;
+
+ if (uData->present) {
+ struct userNode *user, *next_un = NULL;
+ struct handle_info *hi;
+
+ hi = get_handle_info(handle);
+ for (user = hi->users; user; user = next_un) {
+ struct mod_chanmode *change;
+ struct modeNode *mn;
+ unsigned int count = 0;
+
+ send_message(user, chanserv, "CSMSG_CLVL_EXPIRED", uData->channel->channel->name);
+ if (!(mn = GetUserMode(uData->channel->channel, user))) {
+ next_un = user->next_authed;
+ continue;
+ }
+
+ if (changemodes == 0) {
+ next_un = user->next_authed;
+ continue;
+ }
+
+ change = mod_chanmode_alloc(2);
+ change->args[count].mode = mode;
+ change->args[count++].u.member = mn;
+
+ if (count) {
+ change->argc = count;
+ mod_chanmode_announce(chanserv, uData->channel->channel, change);
+ }
+ mod_chanmode_free(change);
+ next_un = user->next_authed;
+ }
+ }
+
+ uData->access = uData->lastaccess;
+ uData->lastaccess = 0;
+ uData->clvlexpiry = 0;
+ }
+ }
+}
+
void
del_channel_user(struct userData *user, int do_gc)
{
channel->userCount--;
userCount--;
+ timeq_del(0, chanserv_expire_tempuser, user, TIMEQ_IGNORE_WHEN);
+ timeq_del(0, chanserv_expire_tempclvl, user, TIMEQ_IGNORE_WHEN);
+
if(user->prev)
user->prev->next = user->next;
else
}
else
{
- actee = add_channel_user(ap->channel->channel_info, ap->user->handle_info, ap->level, 0, NULL);
+ actee = add_channel_user(ap->channel->channel_info, ap->user->handle_info, ap->level, 0, NULL, 0);
scan_user_presence(actee, NULL);
}
del_adduser_pending(ap);
}
static int
-protect_user(const struct userNode *victim, const struct userNode *aggressor, struct chanData *channel)
+protect_user(const struct userNode *victim, const struct userNode *aggressor, struct chanData *channel, int protect_invitables)
{
char protect = channel->chOpts[chProtect];
struct userData *cs_victim, *cs_aggressor;
- /* 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 /* Opers dont get special treatment :/ || IsOper(aggressor) */)
- return 0;
+ /* If victim access level is greater than set invitelevel, don't let
+ * us kick them, but don't consider it punishment if someone else does
+ */
+
+ if(victim == aggressor)
+ return 0;
/* Don't protect if the victim isn't authenticated (because they
can't be a channel user), unless we are to protect non-users
also. */
+
cs_victim = GetChannelAccess(channel, victim->handle_info);
+
+ /* If they have enough access to invite themselvs through a ban,
+ * and its us kicking them, don't. -Rubin */
+ if(protect_invitables==true && cs_victim && (cs_victim->access >= channel->lvlOpts[lvlInviteMe]))
+ return 1;
+
+ if(protect == 'n')
+ return 0;
+
if(protect != 'a' && !cs_victim)
return 0;
/* Protect if the aggressor isn't a user because at this point,
the aggressor can only be less than or equal to the victim. */
+
+ /* Not protected from chanserv except above */
+ /* XXX: need to generic-ize chanserv to "one of x3's services" somehow.. */
+ if(aggressor == chanserv)
+ return 0;
+
cs_aggressor = GetChannelAccess(channel, aggressor->handle_info);
if(!cs_aggressor)
return 1;
return 0;
}
- if(protect_user(victim, user, channel->channel_info))
+ if(protect_user(victim, user, channel->channel_info, false))
{
reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
return 0;
}
- if(protect_user(victim, user, channel->channel_info))
+ if(protect_user(victim, user, channel->channel_info, false))
{
reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
channel = AddChannel(argv[1], now, NULL, NULL, NULL);
cData = register_channel(channel, user->handle_info->handle);
- scan_user_presence(add_channel_user(cData, handle, UL_OWNER, 0, NULL), NULL);
+ scan_user_presence(add_channel_user(cData, handle, UL_OWNER, 0, NULL, 0), NULL);
cData->modes = chanserv_conf.default_modes;
if(off_channel > 0)
cData->modes.modes_set |= MODE_REGISTERED;
/* Initialize the channel's max user record. */
cData->max = channel->members.used;
+ cData->maxsetinfo = chanserv_conf.max_userinfo_length;
if(handle != user->handle_info)
reply("CSMSG_PROXY_SUCCESS", handle->handle, channel->name);
return 0;
}
- actee = add_channel_user(channel->channel_info, handle, access, 0, NULL);
+ time_t accessexpiry = 0;
+ unsigned int duration = 0;
+ if (argc > 3) {
+ if ((duration = ParseInterval(argv[3])))
+ accessexpiry = now + duration;
+ }
+
+ actee = add_channel_user(channel->channel_info, handle, access, 0, NULL, accessexpiry);
scan_user_presence(actee, NULL);
+
+ if (duration > 0)
+ timeq_add(accessexpiry, chanserv_expire_tempuser, actee);
+
reply("CSMSG_ADDED_USER", handle->handle, channel->name, user_level_name_from_level(access), access);
return 1;
}
return 0;
}
+ time_t clvlexpiry = 0;
+ unsigned int duration = 0;
+ if (argc > 3) {
+ if ((duration = ParseInterval(argv[3])))
+ clvlexpiry = now + duration;
+ }
+
+ if (duration > 0) {
+ if (victim->accessexpiry > 0) {
+ reply("CSMSG_NO_BUMP_EXPIRY");
+ return 0;
+ }
+
+ victim->clvlexpiry = clvlexpiry;
+ victim->lastaccess = victim->access;
+ timeq_add(clvlexpiry, chanserv_expire_tempclvl, victim);
+ }
+
victim->access = new_access;
reply("CSMSG_CHANGED_ACCESS", handle->handle, user_level_name_from_level(new_access), new_access, channel->name);
return 1;
if(argc > 2)
{
access = user_level_from_name(argv[1], UL_OWNER);
+ char *useraccess = user_level_name_from_level(victim->access);
if(!access)
{
reply("CSMSG_INVALID_ACCESS", argv[1]);
return 0;
}
- if(access != victim->access)
+ if(strcasecmp(argv[1], useraccess))
{
reply("CSMSG_INCORRECT_ACCESS", handle->handle, user_level_name_from_level(victim->access), argv[1]);
return 0;
static CHANSERV_FUNC(cmd_mdelcoowner)
{
- return cmd_mdel_user(user, channel, UL_COOWNER, UL_COOWNER, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_COOWNER, UL_OWNER-1, argv[1], cmd);
}
static CHANSERV_FUNC(cmd_mdelmanager)
{
- return cmd_mdel_user(user, channel, UL_MANAGER, UL_MANAGER, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_MANAGER, UL_COOWNER-1, argv[1], cmd);
}
static CHANSERV_FUNC(cmd_mdelop)
{
- return cmd_mdel_user(user, channel, UL_OP, UL_OP, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_OP, UL_MANAGER-1, argv[1], cmd);
}
-static CHANSERV_FUNC(cmd_mdelpeon)
+static CHANSERV_FUNC(cmd_mdelhalfop)
{
- return cmd_mdel_user(user, channel, UL_PEON, UL_PEON, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_HALFOP, UL_OP-1, argv[1], cmd);
}
-static CHANSERV_FUNC(cmd_mdelhalfop)
+static CHANSERV_FUNC(cmd_mdelpeon)
{
- return cmd_mdel_user(user, channel, UL_HALFOP, UL_HALFOP, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_PEON, UL_HALFOP-1, argv[1], cmd);
}
+static CHANSERV_FUNC(cmd_levels)
+{
+ struct helpfile_table tbl;
+ int ii = 0;
+
+ tbl.length = 6 + 1; // 6 levels
+ tbl.width = 4;
+ tbl.flags = 0;
+ tbl.contents = calloc(tbl.length,sizeof(tbl.contents[0]));
+ tbl.contents[0] = calloc(tbl.width,sizeof(tbl.contents[0][0]));
+ tbl.contents[0][0] = "Level";
+ tbl.contents[0][1] = "From";
+ tbl.contents[0][2] = "-";
+ tbl.contents[0][3] = "To";
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_OWNER));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_OWNER);
+ tbl.contents[ii][2] = msnprintf(2, " ");
+ tbl.contents[ii][3] = msnprintf(1, "");
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_COOWNER));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_COOWNER);
+ tbl.contents[ii][2] = msnprintf(2, "-");
+ tbl.contents[ii][3] = msnprintf(4, "%d", UL_OWNER-1);
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_MANAGER));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_MANAGER);
+ tbl.contents[ii][2] = msnprintf(2, "-");
+ tbl.contents[ii][3] = msnprintf(4, "%d", UL_COOWNER-1);
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_OP));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_OP);
+ tbl.contents[ii][2] = msnprintf(2, "-");
+ tbl.contents[ii][3] = msnprintf(4, "%d", UL_MANAGER-1);
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_HALFOP));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_HALFOP);
+ tbl.contents[ii][2] = msnprintf(2, "-");
+ tbl.contents[ii][3] = msnprintf(4, "%d", UL_OP-1);
+
+ tbl.contents[++ii] = calloc(tbl.width, sizeof(tbl.contents[0][0]));
+ tbl.contents[ii][0] = strdup(user_level_name_from_level(UL_PEON));
+ tbl.contents[ii][1] = msnprintf(4, "%d", UL_PEON);
+ tbl.contents[ii][2] = msnprintf(2, "-");
+ tbl.contents[ii][3] = msnprintf(4, "%d", UL_HALFOP-1);
+
+ table_send(cmd->parent->bot, user->nick, 0, NULL, tbl);
+ return 0;
+
+/*
+ reply("CSMSG_LEVELS_HEADER");
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_OWNER), UL_OWNER, UL_OWNER);
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_COOWNER), UL_COOWNER, UL_OWNER-1);
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_MANAGER), UL_MANAGER, UL_COOWNER-1);
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_OP), UL_OP, UL_MANAGER-1);
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_HALFOP), UL_HALFOP, UL_OP-1);
+ reply("CSMSG_LEVELS", user_level_name_from_level(UL_PEON), UL_PEON, UL_HALFOP-1);
+ reply("CSMSG_BAR");
+ */
+}
+
/* trim_lamers.. */
static int
cmd_trim_bans(struct svccmd *cmd, struct userNode *user, struct chanNode *channel, unsigned long duration)
if(!user_matches_glob(mn->user, ban, MATCH_USENICK | MATCH_VISIBLE))
continue;
- if(protect_user(mn->user, user, channel->channel_info))
+ if(protect_user(mn->user, user, channel->channel_info, false))
return 1;
if(victims)
return 0;
}
- if(protect_user(victim, user, channel->channel_info))
+ if(protect_user(victim, user, channel->channel_info, false))
{
// This translates to send_message(user, cmd->parent->bot, ...)
// if user is x3 (ctcp action) cmd is null and segfault.
}
}
- if(action & ACTION_KICK)
+ if(action & ACTION_ADD_LAMER)
+ {
+ char kick_reason[MAXLEN];
+ sprintf(kick_reason, "(%s) %s", user->nick, reason);
+
+ for(n = 0; n < victimCount; n++) {
+ if(!protect_user(victims[n]->user, user, channel->channel_info, true)) {
+ KickChannelUser(victims[n]->user, channel, chanserv, kick_reason);
+ }
+ }
+ }
+ else if(action & ACTION_KICK)
{
char kick_reason[MAXLEN];
sprintf(kick_reason, "(%s) %s", user->nick, reason);
- for(n = 0; n < victimCount; n++)
+ for(n = 0; n < victimCount; n++) {
KickChannelUser(victims[n]->user, channel, chanserv, kick_reason);
+ }
}
if(!cmd)
if(argc < 2)
target_handle = user->handle_info;
- else if(!IsHelping(user))
+ else if(!(target_handle = modcmd_get_handle_info(user, argv[1])))
+ return 0;
+ else if(!IsHelping(user) && target_handle != user->handle_info)
{
reply("CSMSG_MYACCESS_SELF_ONLY", argv[0]);
return 0;
}
- else if(!(target_handle = modcmd_get_handle_info(user, argv[1])))
- return 0;
-
if(!target_handle->channels)
{
reply("CSMSG_SQUAT_ACCESS", target_handle->handle);
}
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
lData.table.contents = malloc(lData.table.length*sizeof(*lData.table.contents));
if(user->handle_info && user->handle_info->userlist_style == HI_STYLE_ADVANCED)
- lData.table.width = 5; /* with level = 5 */
+ lData.table.width = 6; /* with level = 6 */
else
- lData.table.width = 4; /* without = 4 */
+ lData.table.width = 5; /* without = 5 */
ary = malloc(lData.table.width*sizeof(**lData.table.contents));
lData.table.contents[0] = ary;
if(user->handle_info) {
ary[i] = "Last Seen";
seen_index = i++;
ary[i++] = "Status";
+ ary[i++] = "Expiry";
for(matches = 1; matches < lData.table.length; ++matches)
{
struct userData *uData = lData.users[matches-1];
ary[i++] = "Vacation";
else
ary[i++] = "Normal";
+
+ if ((uData->accessexpiry > 0) || (uData->clvlexpiry > 0)) {
+ char delay[INTERVALLEN];
+ time_t diff;
+
+ if (uData->accessexpiry > 0) {
+ diff = uData->accessexpiry - now;
+ intervalString(delay, diff, user->handle_info);
+ } else {
+ diff = uData->clvlexpiry - now;
+ intervalString(delay, diff, user->handle_info);
+ }
+ ary[i++] = delay;
+ } else
+ ary[i++] = "Never";
}
+
send_list(&lData);
for(matches = 1; matches < lData.table.length; ++matches)
{
if(!matches)
{
table_send(cmd->parent->bot, user->nick, 0, NULL, tbl);
- reply("MSG_NONE");
+/* reply("MSG_NONE"); */
free(tbl.contents[0]);
free(tbl.contents);
return 0;
return opt_greeting_common(user, cmd, argc, argv, "CSMSG_SET_USERGREETING", &channel->channel_info->user_greeting);
}
+static MODCMD_FUNC(chan_opt_maxsetinfo)
+{
+ unsigned int charmax;
+
+ if(argc > 1) {
+ charmax = atoi(argv[1]);
+ if ((charmax > 0) && (charmax < chanserv_conf.max_userinfo_length))
+ channel->channel_info->maxsetinfo = charmax;
+ }
+
+ reply("CSMSG_SET_MAXSETINFO", channel->channel_info->maxsetinfo);
+ return 1;
+}
+
static MODCMD_FUNC(chan_opt_modes)
{
struct mod_chanmode *new_modes;
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;
{
size_t bp;
infoline = unsplit_string(argv + 1, argc - 1, NULL);
- if(strlen(infoline) > chanserv_conf.max_userinfo_length)
+ if(strlen(infoline) > channel->channel_info->maxsetinfo)
{
- reply("CSMSG_INFOLINE_TOO_LONG", chanserv_conf.max_userinfo_length);
+ reply("CSMSG_INFOLINE_TOO_LONG", channel->channel_info->maxsetinfo);
return 0;
}
bp = strcspn(infoline, "\001");
{
char *options[] =
{
- "AutoOp", "AutoInvite", "Info"
+ "AutoOp", "AutoInvite", "AutoJoin", "Info"
};
if(!uset_shows_list.size)
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)
{
if(force)
{
- new_owner = add_channel_user(cData, new_owner_hi, UL_COOWNER, 0, NULL);
+ new_owner = add_channel_user(cData, new_owner_hi, UL_COOWNER, 0, NULL, 0);
}
else
{
giveownership = calloc(1, sizeof(*giveownership));
giveownership->issued = now;
- giveownership->old_owner = curr_user->handle->handle;
- giveownership->target = new_owner_hi->handle;
+ giveownership->old_owner = strdup(curr_user->handle->handle);
+ giveownership->target = strdup(new_owner_hi->handle);
giveownership->target_access = new_owner_old_access;
if(override)
{
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)
{
SetChannelTopic(channel, chanserv, chanserv, channel->channel_info->topic, 1);
}
+int
+trace_check_bans(struct userNode *user, struct chanNode *chan)
+{
+ struct banData *bData;
+ struct mod_chanmode *change;
+
+ change = find_matching_bans(&chan->banlist, user, NULL);
+ if (change)
+ return 1;
+
+ /* lamer list */
+ if (chan->channel_info) {
+ for(bData = chan->channel_info->bans; bData; bData = bData->next) {
+
+ if(!user_matches_glob(user, bData->mask, MATCH_USENICK))
+ continue;
+
+ if(bData)
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+int
+check_bans(struct userNode *user, const char *channel)
+{
+ struct chanNode *chan;
+ struct mod_chanmode change;
+ struct chanData *cData;
+ struct banData *bData;
+
+ if (!(chan = GetChannel(channel)))
+ return 0;
+
+ if(!(cData = chan->channel_info))
+ return 0;
+
+ mod_chanmode_init(&change);
+ change.argc = 1;
+
+ if(chan->banlist.used < MAXBANS)
+ {
+ /* Not joining through a ban. */
+ for(bData = cData->bans;
+ bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
+ bData = bData->next);
+
+ if(bData)
+ {
+ char kick_reason[MAXLEN];
+ sprintf(kick_reason, "(%s) %s", bData->owner, bData->reason);
+
+ bData->triggered = now;
+ if(bData != cData->bans)
+ {
+ /* Shuffle the ban to the head of the list. */
+ if(bData->next)
+ bData->next->prev = bData->prev;
+ if(bData->prev)
+ bData->prev->next = bData->next;
+
+ bData->prev = NULL;
+ bData->next = cData->bans;
+
+ if(cData->bans)
+ cData->bans->prev = bData;
+
+ cData->bans = bData;
+ }
+
+ change.args[0].mode = MODE_BAN;
+ change.args[0].u.hostmask = bData->mask;
+ mod_chanmode_announce(chanserv, chan, &change);
+ KickChannelUser(user, chan, chanserv, kick_reason);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+int
+channel_user_is_exempt(struct userNode *user, struct chanNode *channel)
+{
+ unsigned int ii;
+ for(ii = 0; ii < channel->exemptlist.used; ii++)
+ {
+ if(user_matches_glob(user, channel->exemptlist.list[ii]->exempt, MATCH_USENICK))
+ return true;
+ }
+ return false;
+}
+
+
/* Welcome to my worst nightmare. Warning: Read (or modify)
the code below at your own risk. */
static int
unsigned int modes = 0, info = 0;
char *greeting;
- if(IsLocal(user) || !channel->channel_info || IsSuspended(channel->channel_info))
+ if(IsLocal(user) || !channel || !channel->channel_info || IsSuspended(channel->channel_info))
return 0;
cData = channel->channel_info;
}
#endif
+ if(user->handle_info)
+ {
+ handle = user->handle_info;
+ if(handle)
+ {
+ uData = GetTrueChannelAccess(cData, handle);
+ }
+ }
+
+
mod_chanmode_init(&change);
change.argc = 1;
- if(channel->banlist.used < MAXBANS)
- {
- /* Not joining through a ban. */
- for(bData = cData->bans;
- bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
- bData = bData->next);
- if(bData)
+ /* TODO: maybe only people above inviteme level? -Rubin */
+ /* We don't kick people with access */
+ if(!uData && !channel_user_is_exempt(user, channel))
+ {
+ if(channel->banlist.used < MAXBANS)
{
- char kick_reason[MAXLEN];
- sprintf(kick_reason, "(%s) %s", bData->owner, bData->reason);
+ /* Not joining through a ban. */
+ for(bData = cData->bans;
+ bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
+ bData = bData->next);
- bData->triggered = now;
- if(bData != cData->bans)
+ if(bData)
{
- /* Shuffle the ban to the head of the list. */
- if(bData->next)
- bData->next->prev = bData->prev;
- if(bData->prev)
- bData->prev->next = bData->next;
+ char kick_reason[MAXLEN];
+ sprintf(kick_reason, "(%s) %s", bData->owner, bData->reason);
- bData->prev = NULL;
- bData->next = cData->bans;
+ bData->triggered = now;
+ if(bData != cData->bans)
+ {
+ /* Shuffle the ban to the head of the list. */
+ if(bData->next)
+ bData->next->prev = bData->prev;
+ if(bData->prev)
+ bData->prev->next = bData->next;
+
+ bData->prev = NULL;
+ bData->next = cData->bans;
+
+ if(cData->bans)
+ cData->bans->prev = bData;
+ cData->bans = bData;
+ }
- if(cData->bans)
- cData->bans->prev = bData;
- cData->bans = bData;
+ change.args[0].mode = MODE_BAN;
+ change.args[0].u.hostmask = bData->mask;
+ mod_chanmode_announce(chanserv, channel, &change);
+ KickChannelUser(user, channel, chanserv, kick_reason);
+ return 1;
}
-
- change.args[0].mode = MODE_BAN;
- change.args[0].u.hostmask = bData->mask;
- mod_chanmode_announce(chanserv, channel, &change);
- KickChannelUser(user, channel, chanserv, kick_reason);
- return 1;
}
}
greeting = cData->greeting;
if(user->handle_info)
{
- handle = user->handle_info;
+/* handle = user->handle_info; */
if(IsHelper(user) && !IsHelping(user))
{
}
}
- uData = GetTrueChannelAccess(cData, handle);
+/* uData = GetTrueChannelAccess(cData, handle); */
if(uData && !IsUserSuspended(uData))
{
/* non users getting automodes are handled above. */
return 0;
}
+static void
+chanserv_autojoin_channels(struct userNode *user)
+{
+ struct userData *channel;
+
+ 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;
|| !channel->channel_info
|| IsSuspended(channel->channel_info))
continue;
+ if(protect_user(user, chanserv, channel->channel_info, true))
+ continue;
for(jj = 0; jj < channel->banlist.used; ++jj)
if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
break;
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_channels, user);
+ chanserv_autojoin_channels(user);
}
static void
|| (kicker->handle_info && kicker->handle_info == victim->handle_info))
return;
- if(protect_user(victim, kicker, channel->channel_info))
+ if(protect_user(victim, kicker, channel->channel_info, false))
{
const char *reason = user_find_message(kicker, "CSMSG_USER_PROTECTED_KICK");
KickChannelUser(kicker, channel, chanserv, reason);
if((change->args[ii].mode & (MODE_REMOVE|MODE_CHANOP)) == (MODE_REMOVE|MODE_CHANOP))
{
const struct userNode *victim = change->args[ii].u.member->user;
- if(!protect_user(victim, user, channel->channel_info))
+ if(!protect_user(victim, user, channel->channel_info, false))
continue;
if(!bounce)
bounce = mod_chanmode_alloc(change->argc + 1 - ii);
/* Need not check for bans if they're opped or voiced. */
/* TODO: does this make sense in automode v, h, and o? *
* lets still enforce on voice people anyway, and see how that goes -Rubin */
- if(user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP /*|MODE_VOICE */))
+ if(user->channels.list[ii]->modes & (MODE_CHANOP|MODE_HALFOP|MODE_VOICE ))
continue;
/* Need not check for bans unless channel registration is active. */
if(!channel->channel_info || IsSuspended(channel->channel_info))
/* Need not act if we found one. */
if(jj < channel->banlist.used)
continue;
+ /* don't kick someone on the userlist */
+ if(protect_user(user, chanserv, channel->channel_info, true))
+ continue;
/* Look for a matching ban in this channel. */
for(bData = channel->channel_info->bans; bData; bData = bData->next)
{
{
struct handle_info *handle;
struct userData *uData;
- char *seen, *inf, *flags, *expires;
+ char *seen, *inf, *flags, *expires, *accessexpiry, *clvlexpiry, *lstacc;
time_t last_seen;
- unsigned short access;
+ unsigned short access, lastaccess = 0;
if(rd->type != RECDB_OBJECT || !dict_size(rd->d.object))
{
last_seen = seen ? (signed)strtoul(seen, NULL, 0) : now;
flags = database_get_data(rd->d.object, KEY_FLAGS, RECDB_QSTRING);
expires = database_get_data(rd->d.object, KEY_EXPIRES, RECDB_QSTRING);
+ accessexpiry = database_get_data(rd->d.object, KEY_ACCESSEXPIRY, RECDB_QSTRING);
+ clvlexpiry = database_get_data(rd->d.object, KEY_CLVLEXPIRY, RECDB_QSTRING);
+ lstacc = database_get_data(rd->d.object, KEY_LASTLEVEL, RECDB_QSTRING);
+ lastaccess = lstacc ? atoi(lstacc) : 0;
+
handle = get_handle_info(key);
if(!handle)
{
return;
}
- uData = add_channel_user(chan, handle, access, last_seen, inf);
+ uData = add_channel_user(chan, handle, access, last_seen, inf, 0);
uData->flags = flags ? strtoul(flags, NULL, 0) : 0;
uData->expires = expires ? strtoul(expires, NULL, 0) : 0;
+ uData->accessexpiry = accessexpiry ? strtoul(accessexpiry, NULL, 0) : 0;
+ if (uData->accessexpiry > 0)
+ timeq_add(uData->accessexpiry, chanserv_expire_tempuser, uData);
+
+ uData->clvlexpiry = clvlexpiry ? strtoul(clvlexpiry, NULL, 0) : 0;
+ if (uData->clvlexpiry > 0)
+ timeq_add(uData->clvlexpiry, chanserv_expire_tempclvl, uData);
+
+ uData->lastaccess = lastaccess;
+
if((uData->flags & USER_SUSPENDED) && uData->expires)
{
if(uData->expires > now)
str = database_get_data(channel, KEY_TOPIC, RECDB_QSTRING);
cData->topic = str ? strdup(str) : NULL;
+ str = database_get_data(channel, KEY_MAXSETINFO, RECDB_QSTRING);
+ cData->maxsetinfo = str ? strtoul(str, NULL, 0) : chanserv_conf.max_userinfo_length;
+
if(!IsSuspended(cData)
&& (str = database_get_data(channel, KEY_MODES, RECDB_QSTRING))
&& (argc = split_line(str, 0, ArrayLength(argv), argv))
saxdb_start_record(ctx, uData->handle->handle, 0);
saxdb_write_int(ctx, KEY_LEVEL, uData->access);
saxdb_write_int(ctx, KEY_SEEN, uData->seen);
+ saxdb_write_int(ctx, KEY_ACCESSEXPIRY, uData->accessexpiry);
+ saxdb_write_int(ctx, KEY_CLVLEXPIRY, uData->clvlexpiry);
+ saxdb_write_int(ctx, KEY_LASTLEVEL, uData->lastaccess);
if(uData->flags)
saxdb_write_int(ctx, KEY_FLAGS, uData->flags);
if(uData->expires)
}
saxdb_end_record(ctx);
+ if (channel->maxsetinfo)
+ saxdb_write_int(ctx, KEY_MAXSETINFO, channel->maxsetinfo);
+
if(channel->modes.modes_set || channel->modes.modes_clear)
{
mod_chanmode_format(&channel->modes, buf);
DEFINE_COMMAND(mdelpeon, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
DEFINE_COMMAND(mdelhalfop, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
+ DEFINE_COMMAND(levels, 1, 0, NULL);
+
DEFINE_COMMAND(trim, 3, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
DEFINE_COMMAND(opchan, 1, MODCMD_REQUIRE_REGCHAN|MODCMD_NEVER_CSUSPEND, "access", "1", NULL);
DEFINE_COMMAND(clvl, 3, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
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);
DEFINE_CHANNEL_OPTION(ctcpreaction);
DEFINE_CHANNEL_OPTION(bantimeout);
DEFINE_CHANNEL_OPTION(inviteme);
+ DEFINE_CHANNEL_OPTION(maxsetinfo);
if(off_channel > 1)
DEFINE_CHANNEL_OPTION(offchannel);
modcmd_register(chanserv_module, "set defaults", chan_opt_defaults, 1, 0, "access", "owner", NULL);
/* User options */
DEFINE_USER_OPTION(autoinvite);
+ DEFINE_USER_OPTION(autojoin);
DEFINE_USER_OPTION(info);
DEFINE_USER_OPTION(autoop);
reg_exit_func(chanserv_db_cleanup);
message_register_table(msgtab);
}
+