*
* This file is part of x3.
*
- * srvx is free software; you can redistribute it and/or modify
+ * 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,
#include "chanserv.h"
#include "conf.h"
#include "global.h"
+#include "gline.h"
+#include "ioset.h"
#include "modcmd.h"
#include "opserv.h" /* for opserv_bad_channel() */
#include "saxdb.h"
+#include "shun.h"
+#include "spamserv.h"
#include "timeq.h"
#define CHANSERV_CONF_NAME "services/chanserv"
#define KEY_NODELETE_LEVEL "nodelete_level"
#define KEY_MAX_USERINFO_LENGTH "max_userinfo_length"
#define KEY_GIVEOWNERSHIP_PERIOD "giveownership_timeout"
+#define KEY_VALID_CHANNEL_REGEX "valid_channel_regex"
/* ChanServ database */
#define KEY_VERSION_CONTROL "version_control"
#define KEY_REVOKED "revoked"
#define KEY_SUSPEND_EXPIRES "suspend_expires"
#define KEY_SUSPEND_REASON "suspend_reason"
+#define KEY_GIVEOWNERSHIP "giveownership"
+#define KEY_STAFF_ISSUER "staff_issuer"
+#define KEY_OLD_OWNER "old_owner"
+#define KEY_TARGET "target"
+#define KEY_TARGET_ACCESS "target_access"
#define KEY_VISITED "visited"
#define KEY_TOPIC "topic"
#define KEY_GREETING "greeting"
#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"
#define KEY_EXPIRES "expires"
#define KEY_TRIGGERED "triggered"
+#define KEY_GOD_TIMEOUT "god_timeout"
+
#define CHANNEL_DEFAULT_FLAGS (CHANNEL_OFFCHANNEL)
#define CHANNEL_DEFAULT_OPTIONS "lmoooanpcnat"
{ "CSMSG_ALREADY_DOWN", "You are not opped, halfopped, or voiced in $b%s$b." },
{ "CSMSG_ALREADY_OPCHANNED", "There has been no net.join since the last opchan in $b%s$b." },
{ "CSMSG_OPCHAN_DONE", "I have (re-)opped myself in $b%s$b." },
+ { "CSMSG_NOT_IN_CHANNEL", "I am not in %s." },
/* Removing yourself from a channel. */
{ "CSMSG_NO_OWNER_DELETEME", "You cannot delete your owner access in $b%s$b." },
{ "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_BAD_SETLEVEL", "You cannot change any setting to above your level." },
{ "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_INVALID_NUMERIC", "$b%s$b is not a valid choice. Choose one:" },
{ "CSMSG_SET_DEFAULT_TOPIC", "$bDefaultTopic$b %s" },
{ "CSMSG_SET_TOPICMASK", "$bTopicMask $b %s" },
{ "CSMSG_SET_GREETING", "$bGreeting $b %s" },
{ "CSMSG_SET_TOYS", "$bToys $b %d - %s" },
{ "CSMSG_SET_CTCPREACTION", "$bCTCPReaction$b %d - %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." },
{ "CSMSG_DEVOICED_USERS", "Devoiced users in $b%s$b." },
{ "CSMSG_AUTOMODE_NONE", "Noone will be automatically oped, half-oped, or voiced." },
- { "CSMSG_AUTOMODE_NORMAL", "Give voice to peons, half-op to halfops, and op to ops." },
- { "CSMSG_AUTOMODE_VOICE", "Give voice to strangers." },
- { "CSMSG_AUTOMODE_HOP", "Give halfops to strangers." },
- { "CSMSG_AUTOMODE_OP", "Give ops to strangers (not advised)" },
- { "CSMSG_AUTOMODE_MUTE", "Give half-op to halfops, and op to ops (no voice to peons)." },
+ { "CSMSG_AUTOMODE_NORMAL", "Give voice to pals, half-op to halfops, and op to ops." },
+ { "CSMSG_AUTOMODE_VOICE", "#1 plus give voice to everyone." },
+ { "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." },
{ "CSMSG_TOPICREFRESH_12_HOURS", "Refresh every 12 hours." },
{ "CSMSG_TOPICREFRESH_24_HOURS", "Refresh every 24 hours." },
+ { "CSMSG_RESYNC_NEVER", "Never automaticly resync userlist." },
+ { "CSMSG_RESYNC_3_HOURS", "Resync userlist every 3 hours." },
+ { "CSMSG_RESYNC_6_HOURS", "Resync userlist every 6 hours." },
+ { "CSMSG_RESYNC_12_HOURS", "Resync userlist every 12 hours." },
+ { "CSMSG_RESYNC_24_HOURS", "Resync userlist every 24 hours." },
+
{ "CSMSG_CTCPREACTION_NONE", "CTCPs are allowed" },
{ "CSMSG_CTCPREACTION_KICK", "Kick on disallowed CTCPs" },
{ "CSMSG_CTCPREACTION_KICKBAN", "Kickban on disallowed CTCPs" },
{ "CSMSG_INVITED_USER", "Invited $b%s$b to join %s." },
{ "CSMSG_INVITING_YOU_REASON", "$b%s$b invites you to join %s: %s" },
{ "CSMSG_INVITING_YOU", "$b%s$b invites you to join %s." },
+ { "CSMSG_CANNOT_INVITE", "You cannot invite %s to %s." },
{ "CSMSG_ALREADY_PRESENT", "%s is already in $b%s$b." },
{ "CSMSG_YOU_ALREADY_PRESENT", "You are already in $b%s$b." },
{ "CSMSG_LOW_CHANNEL_ACCESS", "You lack sufficient access in %s to use this command." },
{ "CSMSG_BANS_REMOVED", "Removed all channel bans from $b%s$b." },
/* Channel userlist */
- { "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_ACCESS_ALL_HEADER_NORMAL", "$b%s Users From Level %s To %s$b" },
+ { "CSMSG_ACCESS_SEARCH_HEADER_NORMAL", "$b%s Users From Level %s To %s Matching %s$b" },
+ /* uncomment if needed to adujust styles (and change code below)
+ { "CSMSG_ACCESS_ALL_HEADER_CLEAN", "$b%s Users From Level %s To %s$b" },
+ { "CSMSG_ACCESS_SEARCH_HEADER_CLEAN", "$b%s Users From Level %s To %s Matching %s$b" },
+ { "CSMSG_ACCESS_ALL_HEADER_ADVANCED", "$b%s Users From Level %s To %s$b" },
+ { "CSMSG_ACCESS_SEARCH_HEADER_ADVANCED", "$b%s Users From Level %s To %s Matching %s$b" },
+ { "CSMSG_ACCESS_ALL_HEADER_CLASSIC", "$b%s Users From Level %s To %s$b" },
+ { "CSMSG_ACCESS_SEARCH_HEADER_CLASSIC", "$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%s$b (%u) in %s." },
{ "CSMSG_LAMERS_HEADER", "$bLamers in %s$b" },
{ "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_OWNERSHIP_HISTORY", "Ownership transfer history for $b%s$b" },
+ { "CSMSG_CHANNEL_OWNERSHIP_NORMAL", "from %s to %s (%d access) on %s" },
+ { "CSMSG_CHANNEL_OWNERSHIP_STAFF_REASON", "from %s to %s (%d access) by %s on %s reason: %s" },
+ { "CSMSG_CHANNEL_OWNERSHIP_STAFF", "from %s to %s (%d access) by %s on %s" },
{ "CSMSG_CHANNEL_END", "---------------End of Info--------------"},
+ { "CSMSG_CHANNEL_END_CLEAN", "End of Info"},
{ "CSMSG_PEEK_INFO", "$bStatus of %s$b" },
{ "CSMSG_PEEK_TOPIC", "$bTopic: $b%s" },
{ "CSMSG_DIE_ROLL", "A $b%lu$b shows on the %lu-sided die." },
{ "CSMSG_HUGGLES_HIM", "\001ACTION huggles %s\001" },
{ "CSMSG_HUGGLES_YOU", "\001ACTION huggles you\001" },
+ { "CSMSG_ROULETTE_LOADS", "\001ACTION loads the gun and sets it on the table\001" },
+ { "CSMSG_ROULETTE_NEW", "Please type %croulette to start a new round" } ,
+ { "CSMSG_ROULETTE_BETTER_LUCK", "Better luck next time, %s" },
+ { "CSMSG_ROULETTE_BANG", "Bang!!!" } ,
+ { "CSMSG_ROULETTE_CLICK", "Click" } ,
+
+ { "CSMSG_SPIN_WHEEL1", "\001ACTION spins the wheel of misfortune for: %s\001" } ,
+ { "CSMSG_SPIN_WHEEL2", "Round and round she goes, where she stops, nobody knows...!" } ,
+ { "CSMSG_SPIN_WHEEL3", "The wheel of misfortune has stopped on..." } ,
+
+ { "CSMSG_SPIN_PEER", "Peer: Peer's gonna eat you!!!!" } ,
+ { "CSMSG_SPIN_PARTALL", "Part all: Part all channels" } ,
+ { "CSMSG_SPIN_Gline", "Gline: /gline for random amount of time" } ,
+ { "CSMSG_SPIN_SHUN", "Shun: /shun for random amount of time" } ,
+ { "CSMSG_SPIN_NOTHING", "Nothing: Absolutely nothing" } ,
+ { "CSMSG_SPIN_RANDJOIN", "Random join: Join a bunch of random channels, then /part all of 'em several times" } ,
+ { "CSMSG_SPIN_ABUSEWHOIS", "Abuse whois: Abuse line added to /whois info" } ,
+ { "CSMSG_SPIN_KICKALL", "Kick all: /kick from each channel you're in" } ,
+ { "CSMSG_SPIN_NICKCHANGE", "Nick change: Random Nick Change" } ,
+ { "CSMSG_SPIN_KILL", "Kill: /kill" } ,
+ { "CSMSG_SPIN_SVSIGNORE", "Ignore: Services ignore for random amount of time" } ,
+ { "CSMSG_SPIN_SVSIGNORE_OPER", "Ignore: I'm trying REALLY hard to ignore you, but your IRCOp smell is overwhelming!" } ,
+ { "CSMSG_SPIN_KICKBANALL", "Kickban all: /kick and ban from each channel your're in" } ,
+ { "CSMSG_SPIN_UNKNOWN", "Error: I don't know how to '%s' you, so you live for now..." },
/* 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 }
};
struct userNode *chanserv;
dict_t note_types;
int off_channel;
+extern struct string_list *autojoin_channels;
static dict_t plain_dnrs, mask_dnrs, handle_dnrs;
static struct log_type *CS_LOG;
struct adduserPending* adduser_pendings = NULL;
unsigned int adduser_pendings_count = 0;
+unsigned long god_timeout;
static struct
{
unsigned int max_chan_users;
unsigned int max_chan_bans; /* lamers */
unsigned int max_userinfo_length;
+ unsigned int valid_channel_regex_set : 1;
+
+ regex_t valid_channel_regex;
struct string_list *set_shows;
struct string_list *eightball;
struct string_list *old_ban_names;
+ struct string_list *wheel;
const char *ctcp_short_ban_duration;
const char *ctcp_long_ban_duration;
NOTE_VIS_PRIVILEGED
};
+struct io_fd *socket_io_fd;
+extern struct cManagerNode cManager;
+
struct note_type
{
enum note_access_type set_access_type;
unsigned short level;
char ch;
} accessLevels[] = { /* MUST be orderd less to most! */
+ { "pal", "Pal", UL_PEON, '+' },
{ "peon", "Peon", UL_PEON, '+' },
{ "halfop", "HalfOp", UL_HALFOP, '%' },
{ "op", "Op", UL_OP, '@' },
unsigned int old_flag;
unsigned short flag_value;
} levelOptions[] = {
- { "CSMSG_SET_ENFOPS", "enfops", 300, 1, 0, 0 },
- { "CSMSG_SET_ENFHALFOPS", "enfhalfops", 300, 1, 0, 0 },
- { "CSMSG_SET_ENFMODES", "enfmodes", 200, 3, 0, 0 },
- { "CSMSG_SET_ENFTOPIC", "enftopic", 200, 4, 0, 0 },
- { "CSMSG_SET_PUBCMD", "pubcmd", 0, 5, 0, 0 },
- { "CSMSG_SET_SETTERS", "setters", 400, 7, 0, 0 },
- { "CSMSG_SET_USERINFO", "userinfo", 1, ~0, CHANNEL_INFO_LINES, 1 },
- { "CSMSG_SET_INVITEME", "inviteme", 1, ~0, CHANNEL_PEON_INVITE, 200 },
+ { "CSMSG_SET_ENFOPS", "enfops", 300, 1, 0, 0 },
+ { "CSMSG_SET_ENFHALFOPS", "enfhalfops", 300, 1, 0, 0 },
+ { "CSMSG_SET_ENFMODES", "enfmodes", 200, 3, 0, 0 },
+ { "CSMSG_SET_ENFTOPIC", "enftopic", 200, 4, 0, 0 },
+ { "CSMSG_SET_PUBCMD", "pubcmd", 0, 5, 0, 0 },
+ { "CSMSG_SET_SETTERS", "setters", 400, 7, 0, 0 },
+ { "CSMSG_SET_USERINFO", "userinfo", 1, ~0, CHANNEL_INFO_LINES, 1 },
+ { "CSMSG_SET_INVITEME", "inviteme", 1, ~0, CHANNEL_PEON_INVITE, 200 },
{ "CSMSG_SET_TOPICSNARF", "topicsnarf", 501, ~0, CHANNEL_TOPIC_SNARF, 1 }
};
{ '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" },
{ '3', "CSMSG_BANTIMEOUT_4H" },
{ '4', "CSMSG_BANTIMEOUT_1D" },
{ '5', "CSMSG_BANTIMEOUT_1W" }
+},
+resyncValues[] = {
+ { 'n', "CSMSG_RESYNC_NEVER" },
+ { '1', "CSMSG_RESYNC_3_HOURS" },
+ { '2', "CSMSG_RESYNC_6_HOURS" },
+ { '3', "CSMSG_RESYNC_12_HOURS" },
+ { '4', "CSMSG_RESYNC_24_HOURS" }
};
static const struct {
{ "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
{ "CSMSG_SET_TOPICREFRESH", "topicrefresh", 'n', 8, ArrayLength(topicRefreshValues), topicRefreshValues },
{ "CSMSG_SET_CTCPREACTION", "ctcpreaction", 'n', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues },
- { "CSMSG_SET_BANTIMEOUT", "bantimeout", '0', 11, ArrayLength(banTimeoutValues), banTimeoutValues }
+ { "CSMSG_SET_BANTIMEOUT", "bantimeout", '0', 11, ArrayLength(banTimeoutValues), banTimeoutValues },
+ { "CSMSG_SET_RESYNC", "resync", 'n', 12, ArrayLength(resyncValues), resyncValues },
};
struct userData *helperList;
#define CHANSERV_DB_VERSION 2
-#define GetChannelUser(channel, handle) _GetChannelUser(channel, handle, 1, 0)
#define GetChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 0)
#define GetTrueChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 1)
+void sputsock(const char *text, ...) PRINTF_LIKE(1, 2);
+
+void
+sputsock(const char *text, ...)
+{
+ va_list arg_list;
+ char buffer[MAXLEN];
+ int pos;
+
+ if (!cManager.uplink || cManager.uplink->state == DISCONNECTED) return;
+ buffer[0] = '\0';
+ va_start(arg_list, text);
+ pos = vsnprintf(buffer, MAXLEN - 2, text, arg_list);
+ va_end(arg_list);
+ if (pos < 0 || pos > (MAXLEN - 2)) pos = MAXLEN - 2;
+ buffer[pos] = 0;
+ log_replay(MAIN_LOG, true, buffer);
+ buffer[pos++] = '\n';
+ buffer[pos] = 0;
+ ioset_write(socket_io_fd, buffer, pos);
+}
+
unsigned short
user_level_from_name(const char *name, unsigned short clamp_level)
{
highest = "None";
if(level >= 1)
- highest = "Peon";
+ highest = "Pal";
for(ii = 0; (ii < ArrayLength(accessLevels)); ii++)
if(level >= accessLevels[ii].level)
highest = accessLevels[ii].title;
}
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
free(user->info);
free(user);
- if(do_gc && !channel->users && !IsProtected(channel))
+ if(do_gc && !channel->users && !IsProtected(channel)) {
+ spamserv_cs_unregister(NULL, channel->channel, lost_all_users, NULL);
unregister_channel(channel, "lost all users.");
+ }
}
static struct adduserPending*
}
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 void expire_ban(void *data);
-static struct banData*
+struct banData*
add_channel_ban(struct chanData *channel, const char *mask, char *owner, time_t set, time_t triggered, time_t expires, char *reason)
{
struct banData *bd;
/* Unregister the channel */
log_module(CS_LOG, LOG_INFO, "(%s) Channel registration expired.", channel->channel->name);
+ spamserv_cs_unregister(NULL, channel->channel, expire, NULL);
unregister_channel(channel, "registration expired.");
}
}
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;
}
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))
+ if(protect_user(victim, user, channel->channel_info, false))
{
- 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))
+ if(protect_user(victim, user, channel->channel_info, false))
{
- send_message(user, chanserv, "CSMSG_USER_PROTECTED", victim->nick);
+ reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
}
dict_iterator_t it;
reply("CSMSG_DNR_SEARCH_RESULTS");
- reply("CSMSG_BAR");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ 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(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
if(*target == '*')
matches = chanserv_show_dnrs(user, cmd, NULL, target + 1);
else
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 (chanserv_conf.valid_channel_regex_set) {
+ int err = regexec(&chanserv_conf.valid_channel_regex, argv[1], 0, 0, 0);
+ if (err) {
+ char buff[256];
+ buff[regerror(err, &chanserv_conf.valid_channel_regex, buff, sizeof(buff))] = 0;
+ log_module(CS_LOG, LOG_INFO, "regexec error: %s (%d)", buff, err);
+ }
+ if(err == REG_NOMATCH) {
+ reply("CSMSG_ILLEGAL_CHANNEL", argv[1]);
+ return 0;
+ }
+ }
+
if(new_channel)
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);
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;
}
sprintf(reason, "unregistered by %s.", user->handle_info->handle);
name = strdup(channel->name);
unregister_channel(cData, reason);
+ spamserv_cs_unregister(user, channel, manually, "unregistered");
reply("CSMSG_UNREG_SUCCESS", name);
free(name);
return 1;
}
+static void
+ss_cs_join_channel(struct chanNode *channel, int spamserv_join)
+{
+ extern struct userNode *spamserv;
+ struct mod_chanmode *change;
+
+ if(spamserv && spamserv_join && get_chanInfo(channel->name))
+ {
+ change = mod_chanmode_alloc(2);
+ change->argc = 2;
+ change->args[0].mode = MODE_CHANOP;
+ change->args[0].u.member = AddChannelUser(chanserv, channel);
+ change->args[1].mode = MODE_CHANOP;
+ change->args[1].u.member = AddChannelUser(spamserv, channel);
+ }
+ else
+ {
+ change = mod_chanmode_alloc(1);
+ change->argc = 1;
+ change->args[0].mode = MODE_CHANOP;
+ change->args[0].u.member = AddChannelUser(chanserv, channel);
+ }
+
+ mod_chanmode_announce(chanserv, channel, change);
+ mod_chanmode_free(change);
+}
+
static CHANSERV_FUNC(cmd_move)
{
struct mod_chanmode change;
struct chanNode *target;
struct modeNode *mn;
struct userData *uData;
- char reason[MAXLEN];
struct do_not_register *dnr;
+ int chanserv_join = 0, spamserv_join;
REQUIRE_PARAMS(2);
{
target = AddChannel(argv[1], now, NULL, NULL, NULL);
if(!IsSuspended(channel->channel_info))
- AddChannelUser(chanserv, target);
+ chanserv_join = 1;
}
else if(target->channel_info)
{
return 0;
}
else if(!IsSuspended(channel->channel_info))
- {
- change.argc = 1;
- change.args[0].mode = MODE_CHANOP;
- change.args[0].u.member = AddChannelUser(chanserv, target);
- mod_chanmode_announce(chanserv, target, &change);
- }
+ chanserv_join = 1;
if(off_channel > 0)
{
target->channel_info->channel = target;
channel->channel_info = NULL;
- reply("CSMSG_MOVE_SUCCESS", target->name);
+ spamserv_join = spamserv_cs_move_merge(user, channel, target, 1);
+
+ 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;
}
static void
merge_data(struct chanData *source, struct chanData *target)
{
+ /* Use more recent visited and owner-transfer time; use older
+ * registered time. Bitwise or may_opchan. Use higher max.
+ * Do not touch last_refresh, ban count or user counts.
+ */
if(source->visited > target->visited)
target->visited = source->visited;
+ if(source->registered < target->registered)
+ target->registered = source->registered;
+ if(source->ownerTransfer > target->ownerTransfer)
+ target->ownerTransfer = source->ownerTransfer;
+ if(source->may_opchan)
+ target->may_opchan = 1;
+ if(source->max > target->max)
+ target->max = source->max;
}
static void
struct userData *target_user;
struct chanNode *target;
char reason[MAXLEN];
+ int nodelete = 0;
REQUIRE_PARAMS(2);
return 0;
}
+ if (argc > 2) {
+ if (!irccasecmp("nodelete", argv[2]))
+ nodelete = 1;
+ }
+
if(!target->channel_info)
{
reply("CSMSG_NOT_REGISTERED", target->name);
/* Merge the channel structures and associated data. */
merge_channel(channel->channel_info, target->channel_info);
+ spamserv_cs_move_merge(user, channel, target, 0);
sprintf(reason, "merged into %s by %s.", target->name, user->handle_info->handle);
- unregister_channel(channel->channel_info, reason);
+ if (!nodelete)
+ unregister_channel(channel->channel_info, reason);
reply("CSMSG_MERGE_SUCCESS", target->name);
return 1;
}
reply("CSMSG_ALREADY_OPCHANNED", channel->name);
return 0;
}
+ if(!IsInChannel(channel,chanserv)) {
+ reply("CSMSG_NOT_IN_CHANNEL", channel->name);
+ return 0;
+ }
channel->channel_info->may_opchan = 0;
mod_chanmode_init(&change);
change.argc = 1;
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_mdelhalfop)
+{
+ return cmd_mdel_user(user, channel, UL_HALFOP, UL_OP-1, argv[1], cmd);
}
static CHANSERV_FUNC(cmd_mdelpeon)
{
- return cmd_mdel_user(user, channel, UL_PEON, UL_PEON, argv[1], cmd);
+ return cmd_mdel_user(user, channel, UL_PEON, UL_HALFOP-1, argv[1], cmd);
}
-static CHANSERV_FUNC(cmd_mdelhalfop)
+static CHANSERV_FUNC(cmd_mdelpal)
{
- 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 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)
+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;
}
{
next = uData->next;
- if((uData->seen > limit) || uData->present)
+ if((uData->seen > limit)
+ || uData->present
+ || (HANDLE_FLAGGED(uData->handle, FROZEN) && !vacation))
continue;
if(((uData->access >= min_access) && (uData->access <= max_access))
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;
}
{
unsigned long duration;
unsigned short min_level, max_level;
+ int vacation;
REQUIRE_PARAMS(3);
+ vacation = argc > 3 && !strcmp(argv[3], "vacation");
duration = ParseInterval(argv[2]);
if(duration < 60)
{
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);
+ 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);
+ 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);
+ 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++;
}
}
static int
-bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, int *victimCount, struct modeNode **victims)
+bad_channel_ban(struct chanNode *channel, struct userNode *user, const char *ban, unsigned int *victimCount, struct modeNode **victims)
{
unsigned int ii;
if(IsService(mn->user))
continue;
- if(!user_matches_glob(mn->user, ban, 1))
+ 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.
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))
+/* If i want to ban *.nl and theres 5 of them, what is it to the bot?!?
+// if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user))
+ And, ^^^^^^^^^ BAH!
+ We use x2 style over-mask detection instead because it doesnt stop channel owners from doing
+ reasonable bans, but does stop *@*, *@*a* *@*b* etc type masks. Yes, you can defeat it with
+ some creativity, but its not x3's job to be the ban censor anyway. */
+ if(is_overmask(argv[1]))
{
if(cmd)
reply("CSMSG_LAME_MASK", argv[1]);
return 0;
}
-#endif
if((action == ACTION_KICK) && (victimCount == 0))
{
}
}
- 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)
{
for(ii = count = 0; ii < bans->used; ++ii)
{
- match[ii] = user_matches_glob(actee, bans->list[ii]->ban, 1);
+ match[ii] = user_matches_glob(actee, bans->list[ii]->ban,
+ MATCH_USENICK | MATCH_VISIBLE);
if(match[ii])
count++;
}
while(ban)
{
if(actee)
- for( ; ban && !user_matches_glob(actee, ban->mask, 1);
+ for( ; ban && !user_matches_glob(actee, ban->mask, MATCH_USENICK | MATCH_VISIBLE);
ban = ban->next);
else
for( ; ban && !match_ircglobs(mask, ban->mask);
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
*/
static void
-def_list(struct listData *list)
+normal_list(struct listData *list)
{
const char *msg;
if(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);
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_NORMAL", 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, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
+ send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_NORMAL", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
if(list->table.length == 1)
{
msg = user_find_message(list->user, "MSG_NONE");
table_send(list->bot, list->user->nick, 0, NULL, list->table);
}
+/* if these need changed, uncomment and customize
+static void
+clean_list(struct listData *list)
+{
+ const char *msg;
+ if(list->search)
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_CLEAN", 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_CLEAN", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
+ if(list->table.length == 1)
+ {
+ msg = user_find_message(list->user, "MSG_NONE");
+ send_message_type(4, list->user, list->bot, " %s", msg);
+ }
+ else
+ table_send(list->bot, list->user->nick, 0, NULL, list->table);
+}
+
+static void
+advanced_list(struct listData *list)
+{
+ const char *msg;
+ if(list->search)
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_ADVANCED", 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_ADVANCED", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
+ if(list->table.length == 1)
+ {
+ msg = user_find_message(list->user, "MSG_NONE");
+ send_message_type(4, list->user, list->bot, " %s", msg);
+ }
+ else
+ table_send(list->bot, list->user->nick, 0, NULL, list->table);
+}
+
+static void
+classic_list(struct listData *list)
+{
+ const char *msg;
+ if(list->search)
+ send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER_CLASSIC", list->channel->name, list->lowest, list->highest, list->search);
+ else
+ send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER_CLASSIC", list->channel->name, list->lowest, list->highest);
+ if(list->table.length == 1)
+ {
+ msg = user_find_message(list->user, "MSG_NONE");
+ send_message_type(4, list->user, list->bot, " %s", msg);
+ }
+ else
+ table_send(list->bot, list->user->nick, 0, NULL, list->table);
+}
+*/
+
static int
userData_access_comp(const void *arg_a, const void *arg_b)
{
struct listData lData;
unsigned int matches;
const char **ary;
+ int i = 0;
+ int seen_index;
lData.user = user;
lData.bot = cmd->parent->bot;
lData.lowest = lowest;
lData.highest = highest;
lData.search = (argc > 1) ? argv[1] : NULL;
- send_list = def_list;
+ send_list = normal_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_DEF: send_list = def_list; break;
- case HI_STYLE_ZOOT: send_list = def_list; break;
- }
+ switch(user->handle_info->userlist_style)
+ {
+ case HI_STYLE_CLEAN:
+ send_list = clean_list;
+ break;
+ case HI_STYLE_ADVANCED:
+ send_list = advanced_list;
+ break;
+ case HI_STYLE_CLASSIC:
+ send_list = classic_list;
+ break;
+ case HI_STYLE_NORMAL:
+ default:
+ send_list = normal_list;
+ break;
+ }
}
*/
+ send_list = normal_list;
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 = 5;
lData.table.flags = TABLE_NO_FREE;
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 = 6; /* with level = 6 */
+ else
+ lData.table.width = 5; /* without = 5 */
ary = malloc(lData.table.width*sizeof(**lData.table.contents));
lData.table.contents[0] = ary;
- ary[0] = "Access";
- ary[1] = "Level";
- ary[2] = "Account";
- ary[3] = "Last Seen";
- ary[4] = "Status";
+ if(user->handle_info) {
+ switch(user->handle_info->userlist_style) {
+ case HI_STYLE_CLASSIC:
+ ary[i++] = "Level";
+ break;
+ case HI_STYLE_ADVANCED:
+ ary[i++] = "Access";
+ ary[i++] = "Level";
+ break;
+ case HI_STYLE_CLEAN:
+ ary[i++] = "Access";
+ break;
+ case HI_STYLE_NORMAL:
+ default:
+ ary[i++] = "Access";
+ break;
+ }
+ }
+ else {
+ ary[i++] = "Access";
+ }
+ ary[i++] = "Account";
+ 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];
char seen[INTERVALLEN];
+ i = 0;
ary = malloc(lData.table.width*sizeof(**lData.table.contents));
lData.table.contents[matches] = ary;
- /* ary[0] = strtab(uData->access);*/
- ary[0] = user_level_name_from_level(uData->access);
- ary[1] = strtab(uData->access);
- ary[2] = uData->handle->handle;
+ if(user->handle_info) {
+ switch(user->handle_info->userlist_style) {
+ case HI_STYLE_CLASSIC:
+ ary[i++] = strtab(uData->access);
+ break;
+ case HI_STYLE_ADVANCED:
+ ary[i++] = user_level_name_from_level(uData->access);
+ ary[i++] = strtab(uData->access);
+ break;
+ case HI_STYLE_CLEAN:
+ ary[i++] = user_level_name_from_level(uData->access);
+ break;
+ case HI_STYLE_NORMAL:
+ default:
+ ary[i++] = user_level_name_from_level(uData->access);
+ break;
+ }
+ }
+ else {
+ ary[i++] = user_level_name_from_level(uData->access);
+ }
+ ary[i++] = uData->handle->handle;
if(uData->present)
- ary[3] = "Here";
+ ary[i] = "Here";
else if(!uData->seen)
- ary[3] = "Never";
+ ary[i] = "Never";
else
- ary[3] = intervalString(seen, now - uData->seen, user->handle_info);
- ary[3] = strdup(ary[3]);
+ ary[i] = intervalString(seen, now - uData->seen, user->handle_info);
+ ary[i] = strdup(ary[i]);
+ i++;
if(IsUserSuspended(uData))
- ary[4] = "Suspended";
+ ary[i++] = "Suspended";
else if(HANDLE_FLAGGED(uData->handle, FROZEN))
- ary[4] = "Vacation";
+ ary[i++] = "Vacation";
else
- ary[4] = "Normal";
+ 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)
{
- free((char*)lData.table.contents[matches][3]);
+ /* Free strdup above */
+ free((char*)lData.table.contents[matches][seen_index]);
free(lData.table.contents[matches]);
}
free(lData.table.contents[0]);
{
struct adduserPending *ap;
reply("CSMSG_ADDUSER_PENDING_HEADER");
- reply("CSMSG_BAR");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
for(ap = adduser_pendings;ap;ap = ap->next)
reply("CSMSG_ADDUSER_PENDING_LIST", ap->channel->name, ap->user->nick);
reply("CSMSG_ADDUSER_PENDING_FOOTER");
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;
{
struct chanData *cData;
char *topic;
+ int p10 = 0;
+
+#ifdef WITH_PROTOCOL_P10
+ p10 = 1;
+#endif
cData = channel->channel_info;
if(argc < 2)
{
if(cData->topic)
{
- SetChannelTopic(channel, chanserv, cData->topic, 1);
+ /*XXX Why would we ever want to send chanserv as the setter? I dont understand -Rubin */
+ SetChannelTopic(channel, chanserv, p10 ? user : chanserv, cData->topic, 1);
reply("CSMSG_TOPIC_SET", cData->topic);
return 1;
}
reply("CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
return 0;
}
- SetChannelTopic(channel, chanserv, new_topic, 1);
+ SetChannelTopic(channel, chanserv, p10 ? user : chanserv, new_topic, 1);
}
else /* No mask set, just set the topic */
- SetChannelTopic(channel, chanserv, topic, 1);
+ SetChannelTopic(channel, chanserv, p10 ? user : chanserv, topic, 1);
}
if(check_user_level(channel, user, lvlTopicSnarf, 1, 0))
static CHANSERV_FUNC(cmd_mode)
{
+ struct userData *uData;
struct mod_chanmode *change;
+ short base_oplevel;
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);
return 1;
}
- change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED);
+ uData = GetChannelUser(channel->channel_info, user->handle_info);
+ if (!uData)
+ base_oplevel = MAXOPLEVEL;
+ else if (uData->access >= UL_OWNER)
+ base_oplevel = 1;
+ else
+ base_oplevel = 1 + UL_OWNER - uData->access;
+ change = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED, base_oplevel);
+
if(!change)
{
reply("MSG_INVALID_MODES", unsplit_string(argv+1, argc-1, NULL));
else
send_message(invite, chanserv, "CSMSG_INVITING_YOU", user->nick, channel->name);
}
+
+ if (invite->handle_info && invite->handle_info->ignores->used && (argc > 1)) {
+ unsigned int i;
+ for (i=0; i < invite->handle_info->ignores->used; i++) {
+ if (user_matches_glob(user, invite->handle_info->ignores->list[i], MATCH_USENICK)) {
+ reply("CSMSG_CANNOT_INVITE", argv[1], channel->name);
+ return 0;
+ }
+ }
+ }
+
irc_invite(chanserv, invite, channel);
if(argc > 1)
reply("CSMSG_INVITED_USER", argv[1], channel->name);
}
}
+static void
+show_giveownership_info(struct svccmd *cmd, struct userNode *user, struct giveownership *giveownership)
+{
+ char buf[MAXLEN];
+ const char *fmt = "%a %b %d %H:%M %Y";
+ strftime(buf, sizeof(buf), fmt, localtime(&giveownership->issued));
+
+ if(giveownership->staff_issuer)
+ {
+ if(giveownership->reason)
+ reply("CSMSG_CHANNEL_OWNERSHIP_STAFF_REASON", giveownership->old_owner,
+ giveownership->target, giveownership->target_access,
+ giveownership->staff_issuer, buf, giveownership->reason);
+ else
+ reply("CSMSG_CHANNEL_OWNERSHIP_STAFF", giveownership->old_owner,
+ giveownership->target, giveownership->target_access,
+ giveownership->staff_issuer, buf);
+ }
+ else
+ {
+ reply("CSMSG_CHANNEL_OWNERSHIP_NORMAL", giveownership->old_owner, giveownership->target, giveownership->target_access, buf);
+ }
+}
+
+
static CHANSERV_FUNC(cmd_info)
{
char modes[MAXLEN], buffer[INTERVALLEN];
cData = channel->channel_info;
reply("CSMSG_CHANNEL_INFO", channel->name);
- reply("CSMSG_BAR");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
uData = GetChannelUser(cData, user->handle_info);
if(uData && (uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/))
reply("CSMSG_CHANNEL_USERS", cData->userCount);
reply("CSMSG_CHANNEL_LAMERS", cData->banCount);
reply("CSMSG_CHANNEL_VISITED", intervalString(buffer, now - cData->visited, user->handle_info));
- reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
privileged = IsStaff(user);
- if(((uData && uData->access >= UL_COOWNER) || privileged) && cData->registrar)
+ /* if(privileged) */
+ reply("CSMSG_CHANNEL_REGISTERED", intervalString(buffer, now - cData->registered, user->handle_info));
+ if(/*((uData && uData->access >= UL_COOWNER) || privileged) && */cData->registrar)
reply("CSMSG_CHANNEL_REGISTRAR", cData->registrar);
if(privileged && (dnr = chanserv_is_dnr(channel->name, NULL)))
reply("CSMSG_CHANNEL_SUSPENDED", channel->name);
show_suspension_info(cmd, user, cData->suspended);
}
- reply("CSMSG_CHANNEL_END");
+ if(cData->giveownership && ((uData && (uData->access >= UL_COOWNER)) || IsStaff(user)))
+ {
+ struct giveownership *giveownership;
+ reply("CSMSG_CHANNEL_OWNERSHIP_HISTORY", channel->name);
+ for(giveownership = cData->giveownership; giveownership; giveownership = giveownership->previous)
+ show_giveownership_info(cmd, user, giveownership);
+ }
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_CHANNEL_END");
+ else
+ reply("CSMSG_CHANNEL_END_CLEAN");
return 1;
}
irc_make_chanmode(channel, modes);
reply("CSMSG_PEEK_INFO", channel->name);
- reply("CSMSG_BAR");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
reply("CSMSG_PEEK_TOPIC", channel->topic);
reply("CSMSG_PEEK_MODES", modes);
reply("CSMSG_PEEK_USERS", channel->members.used);
return 1;
}
-static CHANSERV_FUNC(cmd_resync)
+static void
+resync_channel(struct chanNode *channel)
{
struct mod_chanmode *changes;
struct chanData *cData = channel->channel_info;
unsigned int ii, used;
- changes = mod_chanmode_alloc(channel->members.used * 2);
+ /* 6 = worst case -ovh+ovh on everyone */
+ changes = mod_chanmode_alloc(channel->members.used * 6);
for(ii = used = 0; ii < channel->members.used; ++ii)
{
struct modeNode *mn = channel->members.list[ii];
if(IsService(mn->user))
continue;
+
uData = GetChannelAccess(cData, mn->user->handle_info);
- if(uData && uData->access >= UL_OP )
- {
- if(!(mn->modes & MODE_CHANOP))
- {
- changes->args[used].mode = MODE_CHANOP;
- changes->args[used++].u.member = mn;
- }
- }
- else if(uData && uData->access >= UL_HALFOP)
+
+ /* If the channel is in no-mode mode, de-mode EVERYONE */
+ if(cData->chOpts[chAutomode] == 'n')
{
- if(mn->modes & MODE_CHANOP)
- {
- changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
- changes->args[used++].u.member = mn;
- }
- if(!(mn->modes & MODE_HALFOP))
- {
- changes->args[used].mode = MODE_HALFOP;
- changes->args[used++].u.member = mn;
- }
+ if(mn->modes)
+ {
+ changes->args[used].mode = MODE_REMOVE | mn->modes;
+ changes->args[used++].u.member = mn;
+ }
}
- else if(uData && uData->access >= UL_PEON )
+ else /* Give various userlevels their modes.. */
{
- if(mn->modes & MODE_CHANOP)
+ if(uData && uData->access >= UL_OP )
{
- changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
- changes->args[used++].u.member = mn;
+ if(!(mn->modes & MODE_CHANOP))
+ {
+ changes->args[used].mode = MODE_CHANOP;
+ changes->args[used++].u.member = mn;
+ }
}
- if(mn->modes & MODE_HALFOP)
+ else if(uData && uData->access >= UL_HALFOP)
{
- changes->args[used].mode = MODE_REMOVE | MODE_HALFOP;
- changes->args[used++].u.member = mn;
+ if(mn->modes & MODE_CHANOP)
+ {
+ changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
+ changes->args[used++].u.member = mn;
+ }
+ if(!(mn->modes & MODE_HALFOP))
+ {
+ changes->args[used].mode = MODE_HALFOP;
+ changes->args[used++].u.member = mn;
+ }
}
- /* Don't voice peons if were in mode m */
- if(!(mn->modes & MODE_VOICE) && cData->chOpts[chAutomode] != 'm')
+ else if(uData && uData->access >= UL_PEON )
{
- changes->args[used].mode = MODE_VOICE;
- changes->args[used++].u.member = mn;
+ if(mn->modes & MODE_CHANOP)
+ {
+ changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
+ changes->args[used++].u.member = mn;
+ }
+ if(mn->modes & MODE_HALFOP)
+ {
+ changes->args[used].mode = MODE_REMOVE | MODE_HALFOP;
+ changes->args[used++].u.member = mn;
+ }
+ /* Don't voice peons if were in mode m */
+ if( cData->chOpts[chAutomode] == 'm')
+ {
+ if(mn->modes & MODE_VOICE)
+ {
+ changes->args[used].mode = MODE_REMOVE | MODE_VOICE;
+ changes->args[used++].u.member = mn;
+ }
+ }
+ /* otherwise, make user they do have voice */
+ else if(!(mn->modes & MODE_VOICE))
+ {
+ changes->args[used].mode = MODE_VOICE;
+ changes->args[used++].u.member = mn;
+ }
}
- }
- else
- {
- if(mn->modes)
+ else /* They arnt on the userlist.. */
{
- changes->args[used].mode = MODE_REMOVE | mn->modes;
- changes->args[used++].u.member = mn;
- }
+ /* If we voice everyone, but they dont.. */
+ if(cData->chOpts[chAutomode] == 'v')
+ {
+ /* Remove anything except v */
+ if(mn->modes & ~MODE_VOICE)
+ {
+ changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
+ changes->args[used++].u.member = mn;
+ }
+ /* Add v */
+ if(!(mn->modes & MODE_VOICE))
+ {
+ changes->args[used].mode = MODE_VOICE;
+ changes->args[used++].u.member = mn;
+ }
+ }
+ /* If we hop everyone, but they dont.. */
+ else if(cData->chOpts[chAutomode] == 'h')
+ {
+ /* Remove anything except h */
+ if(mn->modes & ~MODE_HALFOP)
+ {
+ changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_HALFOP);
+ changes->args[used++].u.member = mn;
+ }
+ /* Add h */
+ if(!(mn->modes & MODE_HALFOP))
+ {
+ changes->args[used].mode = MODE_HALFOP;
+ changes->args[used++].u.member = mn;
+ }
+ }
+ /* If we op everyone, but they dont.. */
+ else if(cData->chOpts[chAutomode] == 'o')
+ {
+ /* Remove anything except h */
+ if(mn->modes & ~MODE_CHANOP)
+ {
+ changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_CHANOP);
+ changes->args[used++].u.member = mn;
+ }
+ /* Add h */
+ if(!(mn->modes & MODE_CHANOP))
+ {
+ changes->args[used].mode = MODE_CHANOP;
+ changes->args[used++].u.member = mn;
+ }
+ }
+ /* they have no excuse for having modes, de-everything them */
+ else
+ {
+ if(mn->modes)
+ {
+ changes->args[used].mode = MODE_REMOVE | mn->modes;
+ changes->args[used++].u.member = mn;
+ }
+ }
+ }
}
}
changes->argc = used;
- modcmd_chanmode_announce(changes);
+ mod_chanmode_announce(chanserv, channel, changes);
mod_chanmode_free(changes);
+}
+
+static CHANSERV_FUNC(cmd_resync)
+{
+ resync_channel(channel);
reply("CSMSG_RESYNCED_USERS", channel->name);
return 1;
}
switch(ntype->set_access_type)
{
- case NOTE_SET_CHANNEL_ACCESS:
- if(!user->handle_info)
- return 0;
- if(!(uData = GetChannelUser(channel->channel_info, user->handle_info)))
- return 0;
- return uData->access >= ntype->set_access.min_ulevel;
- case NOTE_SET_CHANNEL_SETTER:
- return check_user_level(channel, user, lvlSetters, 1, 0);
- case NOTE_SET_PRIVILEGED: default:
- return IsHelping(user) && (user->handle_info->opserv_level >= ntype->set_access.min_opserv);
+ case NOTE_SET_CHANNEL_ACCESS:
+ if(!user->handle_info)
+ return 0;
+ if(!(uData = GetChannelUser(channel->channel_info, user->handle_info)))
+ return 0;
+ return uData->access >= ntype->set_access.min_ulevel;
+ case NOTE_SET_CHANNEL_SETTER:
+ return check_user_level(channel, user, lvlSetters, 1, 0);
+ case NOTE_SET_PRIVILEGED: default:
+ return IsHelping(user) && (user->handle_info->opserv_level >= ntype->set_access.min_opserv);
}
}
report.reporter = chanserv;
report.user = user;
reply("CSMSG_EVENT_SEARCH_RESULTS", channel->name);
- reply("CSMSG_BAR");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
matches = log_entry_search(&discrim, log_report_entry, &report);
if(matches)
reply("MSG_MATCH_COUNT", matches);
suspended->cData->flags &= ~CHANNEL_SUSPENDED;
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);
+ spamserv_cs_suspend(channel, 0, 0, NULL);
+ ss_cs_join_channel(channel, 1);
}
}
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
{
/* Mark the channel as suspended, then part. */
channel->channel_info->flags |= CHANNEL_SUSPENDED;
+ 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(action == search_print)
{
- reply("CSMSG_CHANNEL_SEARCH_RESULTS");
- reply("CSMSG_BAR");
+ reply("CSMSG_CHANNEL_SEARCH_RESULTS");
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
}
matches = chanserv_channel_search(search, action, user);
&& !match_ircglob(channel->channel_info->topic, channel->channel_info->topic_mask))
reply("CSMSG_TOPIC_MISMATCH", channel->name);
}
- SetChannelTopic(channel, chanserv, topic ? topic : "", 1);
+ SetChannelTopic(channel, chanserv, user, topic ? topic : "", 1);
}
if(channel->channel_info->topic)
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;
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");
{
memset(&channel->channel_info->modes, 0, sizeof(channel->channel_info->modes));
}
- else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1, MCP_KEY_FREE|MCP_REGISTERED)))
+ else if(!(new_modes = mod_chanmode_parse(channel, argv+1, argc-1,MCP_KEY_FREE|MCP_REGISTERED, 0)))
{
reply("CSMSG_INVALID_MODE_LOCK", unsplit_string(argv+1, argc-1, NULL));
return 0;
static MODCMD_FUNC(chan_opt_dynlimit)
{
+ struct mod_chanmode change;
+
+ if (argc > 1) {
+ if (disabled_string(argv[1])) {
+ mod_chanmode_init(&change);
+ change.modes_clear |= MODE_LIMIT;
+ mod_chanmode_announce(chanserv, channel, &change);
+ }
+ }
+
CHANNEL_BINARY_OPTION("CSMSG_SET_DYNLIMIT", CHANNEL_DYNAMIC_LIMIT);
}
if(!isdigit(argv[1][0]) || (index < 0) || (index >= count))
{
- reply("CSMSG_INVALID_NUMERIC", index);
+ reply("CSMSG_INVALID_NUMERIC", argv[1]);
/* Show possible values. */
for(index = 0; index < count; index++)
reply(charOptions[option].format_name, index, user_find_message(user, charOptions[option].values[index].format_name));
return channel_multiple_option(chTopicRefresh, CSFUNC_ARGS);
}
+static MODCMD_FUNC(chan_opt_resync)
+{
+ return channel_multiple_option(chResync, CSFUNC_ARGS);
+}
+
static struct svccmd_list set_shows_list;
static void
if(argc < 2)
{
- reply("CSMSG_CHANNEL_OPTIONS", channel->name);
- reply("CSMSG_BAR");
+ reply("CSMSG_CHANNEL_OPTIONS", channel->name);
+ if(user->handle_info && user->handle_info->userlist_style != HI_STYLE_CLEAN)
+ reply("CSMSG_BAR");
for(ii = 0; ii < set_shows_list.used; ii++)
{
subcmd = set_shows_list.list[ii];
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)
struct userData *new_owner, *curr_user;
struct chanData *cData = channel->channel_info;
struct do_not_register *dnr;
- unsigned int force;
- unsigned short co_access;
- char reason[MAXLEN];
+ struct giveownership *giveownership;
+ unsigned int force, override;
+ unsigned short co_access, new_owner_old_access;
+ char transfer_reason[MAXLEN];
REQUIRE_PARAMS(2);
curr_user = GetChannelAccess(cData, user->handle_info);
force = IsHelping(user) && (argc > 2) && !irccasecmp(argv[2], "force");
+
+ struct userData *uData = _GetChannelUser(channel->channel_info, user->handle_info, 1, 0);
+ override = ((cmd->effective_flags & MODCMD_REQUIRE_CHANUSER)
+ && (uData->access > 500)
+ && (!(uData = _GetChannelUser(channel->channel_info, user->handle_info, 0, 0))
+ || uData->access < 500));
+
+
if(!curr_user || (curr_user->access != UL_OWNER))
{
struct userData *owner = NULL;
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
{
chanserv_show_dnrs(user, cmd, NULL, new_owner_hi->handle);
return 0;
}
+
+ new_owner_old_access = new_owner->access;
if(new_owner->access >= UL_COOWNER)
co_access = new_owner->access;
else
if(curr_user)
curr_user->access = co_access;
cData->ownerTransfer = now;
+
+ giveownership = calloc(1, sizeof(*giveownership));
+ giveownership->issued = now;
+ giveownership->old_owner = strdup(curr_user->handle->handle);
+ giveownership->target = strdup(new_owner_hi->handle);
+ giveownership->target_access = new_owner_old_access;
+ if(override)
+ {
+ if(argc > (2 + force))
+ {
+ unsplit_string(argv + 2 + force, argc - 2 - force, transfer_reason);
+ giveownership->reason = strdup(transfer_reason);
+ }
+ giveownership->staff_issuer = strdup(user->handle_info->handle);
+ }
+
+ giveownership->previous = channel->channel_info->giveownership;
+ 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;
}
+static void
+chanserv_expire_user_suspension(void *data)
+{
+ struct userData *target = data;
+
+ target->expires = 0;
+ target->flags &= ~USER_SUSPENDED;
+}
+
static CHANSERV_FUNC(cmd_suspend)
{
struct handle_info *hi;
struct userData *self, *target;
+ time_t expiry;
- REQUIRE_PARAMS(2);
+ REQUIRE_PARAMS(3);
if(!(hi = modcmd_get_handle_info(user, argv[1]))) return 0;
self = GetChannelUser(channel->channel_info, user->handle_info);
if(!(target = GetTrueChannelAccess(channel->channel_info, hi)))
target->present = 0;
target->seen = now;
}
+ if(!strcmp(argv[2], "0"))
+ expiry = 0;
+ else
+ {
+ unsigned int duration;
+ if(!(duration = ParseInterval(argv[2])))
+ {
+ reply("MSG_INVALID_DURATION", argv[2]);
+ return 0;
+ }
+ expiry = now + duration;
+ }
+
+ target->expires = expiry;
+
+ if(target->expires)
+ timeq_add(target->expires, chanserv_expire_user_suspension, target);
+
target->flags |= USER_SUSPENDED;
reply("CSMSG_USER_SUSPENDED", hi->handle, channel->name);
return 1;
}
target->flags &= ~USER_SUSPENDED;
scan_user_presence(target, NULL);
+ timeq_del(target->expires, chanserv_expire_user_suspension, target, 0);
reply("CSMSG_USER_UNSUSPENDED", hi->handle, channel->name);
return 1;
}
if((refresh_num - cData->last_refresh) < (unsigned int)(1 << (opt - '1')))
continue;
if(cData->topic)
- SetChannelTopic(cData->channel, chanserv, cData->topic, 1);
+ SetChannelTopic(cData->channel, chanserv, chanserv, cData->topic, 1);
cData->last_refresh = refresh_num;
}
timeq_add(now + chanserv_conf.refresh_period, chanserv_refresh_topics, NULL);
}
+static void
+chanserv_auto_resync(UNUSED_ARG(void *data))
+{
+ unsigned int refresh_num = (now - self->link) / chanserv_conf.refresh_period;
+ struct chanData *cData;
+ char opt;
+
+ for(cData = channelList; cData; cData = cData->next)
+ {
+ if(IsSuspended(cData)) continue;
+ opt = cData->chOpts[chResync];
+ if(opt == 'n') continue;
+ if((refresh_num - cData->last_resync) < (unsigned int)(1 << (opt - '1'))) continue;
+ resync_channel(cData->channel);
+ cData->last_resync = refresh_num;
+ }
+ timeq_add(now + chanserv_conf.refresh_period, chanserv_auto_resync, NULL);
+}
+
static CHANSERV_FUNC(cmd_unf)
{
if(channel)
return 1;
}
+static CHANSERV_FUNC(cmd_roulette)
+{
+ if(channel) {
+ struct chanData *cData = channel->channel_info;
+
+ if (cData) {
+ if (cData->roulette_chamber) {
+ DelUser(user, chanserv, 1, "BANG - Don't stuff bullets into a loaded gun");
+ return 1;
+ }
+
+ send_target_message(1, channel->name, cmd->parent->bot, "CSMSG_ROULETTE_LOADS");
+ cData->roulette_chamber = 1 + rand() % 6;
+ }
+ }
+
+ return 1;
+}
+static CHANSERV_FUNC(cmd_shoot)
+{
+ if(channel) {
+ struct chanData *cData = channel->channel_info;
+
+ if (cData->roulette_chamber <= 0) {
+ struct service *service;
+ if ((service = service_find(chanserv->nick))) {
+ reply("CSMSG_ROULETTE_NEW", service->trigger);
+ }
+ return 1;
+ }
+
+ cData->roulette_chamber--;
+
+ if (cData->roulette_chamber == 0) {
+ reply("CSMSG_ROULETTE_BANG");
+ reply("CSMSG_ROULETTE_BETTER_LUCK", user->nick);
+ DelUser(user, chanserv, 1, "BANG!!!!");
+ } else
+ reply("CSMSG_ROULETTE_CLICK");
+ }
+
+ return 1;
+}
+
+static void
+chanserv_remove_abuse(void *data)
+{
+ char *remnick = data;
+ struct userNode *user;
+ /* sometimes the clone was killed and maybe even the user took their nick back
+ * (ie, an oper) so dont kill them here after all unless they are local. */
+ if( (user = GetUserH(remnick)) )
+ if(IsLocal(user) )
+ DelUser(user, NULL, 1, "");
+}
+
+int lamepart(struct userNode *nick) {
+ struct modeNode *mn;
+ unsigned int count, n;
+
+ for (n=count=0; n<nick->channels.used; n++) {
+ mn = nick->channels.list[n];
+ irc_svspart(chanserv, nick, mn->channel);
+ }
+
+ return 0;
+}
+
+static CHANSERV_FUNC(cmd_spin)
+{
+ if(!channel)
+ return 1;
+
+ int type = 0, lamep = 1;
+ char *tstr;
+
+ tstr = conf_get_data("server/type", RECDB_QSTRING);
+ if(tstr) {
+ type = atoi(tstr);
+ if (type > 6)
+ lamep = 0;
+ }
+
+
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_WHEEL1", user->nick);
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_WHEEL2");
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_WHEEL3");
+
+ if(chanserv_conf.wheel->used < 1) {
+ /* wheel actions not defined! eek */
+ return 1;
+ }
+
+ const char *wheel = chanserv_conf.wheel->list[ (int) ( (chanserv_conf.wheel->used) * (rand() / (RAND_MAX + 1.0)) ) ];
+ if(!wheel && *wheel)
+ return 1;
+
+/* enable this to be able to manually specify a result for testing:
+ log_module(MAIN_LOG, LOG_DEBUG,"Testing wheel randomness: %s\n", wheel);
+ if(argc > 1) {
+ wheel = argv[1];
+ }
+*/
+
+ /* connection reset by peer */
+ if (!strcasecmp(wheel, "peer")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_PEER");
+ if (type < 7)
+ irc_kill(chanserv, user, "Connection reset by peer");
+ else
+ irc_svsquit(chanserv, user, "Connection reset by peer");
+ }
+ /* part all channels */
+ else if (!strcasecmp(wheel, "partall")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_PARTALL");
+ if (lamep)
+ lamepart(user);
+ else
+ sputsock("%s SJ %s 0 "FMT_TIME_T, self->numeric, user->numeric, now);
+ }
+ /* random time gline */
+ else if (!strcasecmp(wheel, "gline")) {
+ char target[IRC_NTOP_MAX_SIZE + 3];
+ int wtime = 120 + rand() % 600;
+
+ strcpy(target, "*@");
+ strcat(target, user->hostname);
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_GLINE");
+
+ gline_add(chanserv->nick, target, wtime, "Reward for spinning the wheel of misfortune!", now, 1, 0);
+// irc_kill(chanserv, user, "Reward for spinning the wheel of misfortune!");
+ }
+ /* random shun */
+ else if (!strcasecmp(wheel, "shun")) {
+ char target[IRC_NTOP_MAX_SIZE + 3];
+ int wtime = 120 + rand() % 600;
+
+ strcpy(target, "*@");
+ strcat(target, user->hostname);
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_SHUN");
+
+ shun_add(chanserv->nick, target, wtime, "Reward for spinning the wheel of misfortune!", now, 1);
+ }
+ /* absolutely nothing */
+ else if (!strcasecmp(wheel, "nothing")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_NOTHING");
+ }
+ /* join random chans and part em several times */
+ else if (!strcasecmp(wheel, "randjoin")) {
+ int complete = 0;
+ int rndchans = 0;
+ int chango = 0;
+ int roundz0r = 0;
+
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_RANDJOIN");
+ while(complete != 1) {
+ if (rndchans != 15) {
+ chango = 120 + rand() % 600;
+ sputsock("%s SJ %s #%d "FMT_TIME_T, self->numeric, user->numeric, chango, now);
+ rndchans++;
+ } else {
+ if (roundz0r != 1) {
+ if (lamep)
+ lamepart(user);
+ else
+ sputsock("%s SJ %s 0 "FMT_TIME_T, self->numeric, user->numeric, now);
+ roundz0r = 1;
+ rndchans = 0;
+ } else {
+ if (lamep)
+ lamepart(user);
+ else
+ sputsock("%s SJ %s 0 "FMT_TIME_T, self->numeric, user->numeric, now);
+ complete = 1;
+ }
+ }
+ }
+ }
+ /* abuse line added to /whois */
+ else if (!strcasecmp(wheel, "abusewhois")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_ABUSEWHOIS");
+ irc_swhois(chanserv, user, "is being defecated on by services");
+ }
+ /* kick from each channel your in */
+ else if (!strcasecmp(wheel, "kickall")) {
+ unsigned int count, n;
+ struct modeNode *mn;
+
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_KICKALL");
+
+ for (n=count=0; n<user->channels.used; n++) {
+ mn = user->channels.list[n];
+ irc_kick(chanserv, user, mn->channel, "Reward for spinning the wheel of misfortune!");
+ }
+ }
+ /* random nick change */
+ else if (!strcasecmp(wheel, "nickchange")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_NICKCHANGE");
+
+ char *oldnick = NULL;
+ char *oldident = NULL;
+ char *oldhost = NULL;
+ char abusednick[NICKLEN] = "";
+ int abusednum = 1 + (int) (10000.0 * (rand() / (RAND_MAX + 1.0)));
+ struct userNode *clone;
+
+ oldnick = strdup(user->nick);
+ oldident = strdup(user->ident);
+ oldhost = strdup(user->hostname);
+
+ //snprintf(abusednick, NICKLEN, "Abused%d", abusednum+(1 + rand() % 120));
+ while (1) {
+ snprintf(abusednick, NICKLEN, "Abused%d", abusednum+(1 + rand() % 120));
+ log_module(MAIN_LOG, LOG_DEBUG, "Abused Nick: %s, Client Nick: %s", abusednick, user->nick);
+ if(!GetUserH(abusednick))
+ break;
+ }
+
+ SVSNickChange(user, abusednick);
+ irc_svsnick(chanserv, user, abusednick);
+
+ clone = AddClone(oldnick, oldident, oldhost, "I got abused by the wheel of misfortune :D");
+ timeq_add(now + 300, chanserv_remove_abuse, clone->nick);
+ }
+ /* kill */
+ else if (!strcasecmp(wheel, "kill")) {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_KILL");
+
+ DelUser(user, chanserv, 1, "Reward for spinning the wheel of misfortune!");
+ //irc_kill(chanserv, user, "Reward for spinning the wheel of misfortune!");
+ }
+ /* service ignore */
+ else if (!strcasecmp(wheel, "svsignore")) {
+ int gagged, ignoretime = 0;
+ char target[IRC_NTOP_MAX_SIZE + 13];
+
+ if(IsOper(user)) {
+ /* we cant gag opers, so just verbally abuse them */
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_SVSIGNORE_OPER");
+ return 1;
+ }
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_SVSIGNORE");
+
+ strcpy(target, "*!*@");
+ strcat(target, user->hostname);
+ ignoretime = now + (1 + rand() % 120);
+
+ gagged = gag_create(target, "wheelofabuse", "Reward for spinning the wheel of misfortune!", ignoretime);
+ }
+ /* kick and ban from each channel your in */
+ else if (!strcasecmp(wheel, "kickbanall")) {
+ unsigned int count, n;
+ struct modeNode *mn;
+ //char ban[IRC_NTOP_MAX_SIZE + 1];
+
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_KICKBANALL");
+
+ //snprintf(ban, sizeof(ban), "*!*@%s", user->hostname);
+ for (n=count=0; n<user->channels.used; n++) {
+ struct mod_chanmode *change;
+/* struct banData *bData; */
+ unsigned int exists;
+/* int duration = 300; */
+ char *ban;
+
+ ban = generate_hostmask(user, GENMASK_STRICT_HOST|GENMASK_ANY_IDENT|GENMASK_USENICK);
+
+ log_module(MAIN_LOG, LOG_DEBUG, "Generated ban %s", ban);
+ mn = user->channels.list[n];
+ if(mn->channel->banlist.used >= MAXBANS) {
+ reply("CSMSG_BANLIST_FULL", mn->channel->name);
+ free(ban);
+ continue;
+ }
+
+/* bData = add_channel_ban(mn->channel->channel_info, ban, chanserv->nick, now, now, now + duration, "Reward for spinning the wheel of misfortune!"); */
+
+ change = mod_chanmode_alloc(1);
+ change->args[0].mode = MODE_REMOVE|MODE_CHANOP|MODE_HALFOP|MODE_VOICE;
+ change->args[0].u.member = GetUserMode(mn->channel, user);
+ change->argc = 1;
+
+ mod_chanmode_announce(chanserv, mn->channel, change);
+ mod_chanmode_free(change);
+
+ exists = ChannelBanExists(mn->channel, ban);
+ if(!exists) {
+ change = mod_chanmode_alloc(1);
+ change->args[0].mode = MODE_BAN;
+ change->args[0].u.hostmask = ban;
+ change->argc = 1;
+ mod_chanmode_announce(chanserv, mn->channel, change);
+ mod_chanmode_free(change);
+ }
+
+ if(exists) {
+ reply("CSMSG_REDUNDANT_BAN", ban, mn->channel->name);
+ free(ban);
+ }
+
+ irc_kick(chanserv, user, mn->channel, "Reward for spinning the wheel of misfortune!");
+ }
+ }
+ else {
+ send_target_message(1, channel->name, chanserv, "CSMSG_SPIN_UNKNOWN", wheel);
+ }
+
+ return 1;
+}
+
#ifdef lame8ball
static CHANSERV_FUNC(cmd_8ball)
{
case 4: strcpy(tmp, "A gross kind of mucky %s.");
break;
case 5: strcpy(tmp, "Brilliant whiteish %s.");
- break;
- case 6: case 7: case 8: case 9: strcpy(tmp, "%s.");
- break;
- case 10: strcpy(tmp, "Solid %s.");
- break;
- case 11: strcpy(tmp, "Transparent %s.");
- break;
+ break;
+ case 6: case 7: case 8: case 9: strcpy(tmp, "%s.");
+ break;
+ case 10: strcpy(tmp, "Solid %s.");
+ break;
+ case 11: strcpy(tmp, "Transparent %s.");
+ break;
default: strcpy(outcome, "An invalid random number was generated.");
return;
}
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)
{
mod_chanmode_announce(chanserv, cData->channel, &cData->modes);
if(self->uplink && !self->uplink->burst && channel->channel_info->topic)
- SetChannelTopic(channel, chanserv, channel->channel_info->topic, 1);
+ SetChannelTopic(channel, chanserv, chanserv, channel->channel_info->topic, 1);
}
-/* Welcome to my worst nightmare. Warning: Read (or modify)
- the code below at your own risk. */
-static int
-handle_join(struct modeNode *mNode)
+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 userNode *user = mNode->user;
- struct chanNode *channel = mNode->channel;
struct chanData *cData;
- struct userData *uData = NULL;
struct banData *bData;
- struct handle_info *handle;
- unsigned int modes = 0, info = 0;
- char *greeting;
- if(IsLocal(user) || !channel->channel_info || IsSuspended(channel->channel_info))
+ if (!(chan = GetChannel(channel)))
return 0;
- cData = channel->channel_info;
- if(channel->members.used > cData->max)
- cData->max = channel->members.used;
+ if(!(cData = chan->channel_info))
+ return 0;
mod_chanmode_init(&change);
change.argc = 1;
- if(channel->banlist.used < MAXBANS)
+
+ if(chan->banlist.used < MAXBANS)
{
/* Not joining through a ban. */
for(bData = cData->bans;
- bData && !user_matches_glob(user, bData->mask, 1);
- bData = bData->next);
+ bData && !user_matches_glob(user, bData->mask, MATCH_USENICK);
+ bData = bData->next);
if(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);
+ 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
+handle_join(struct modeNode *mNode)
+{
+ struct mod_chanmode change;
+ struct userNode *user = mNode->user;
+ struct chanNode *channel = mNode->channel;
+ struct chanData *cData;
+ struct userData *uData = NULL;
+ struct banData *bData;
+ struct handle_info *handle;
+ unsigned int modes = 0, info = 0;
+ char *greeting;
+
+ if(IsLocal(user) || !channel || !channel->channel_info || IsSuspended(channel->channel_info))
+ return 0;
+
+ cData = channel->channel_info;
+ if(channel->members.used > cData->max)
+ cData->max = channel->members.used;
+
+#ifdef notdef
+ /* Check for bans. If they're joining through a ban, one of two
+ * cases applies:
+ * 1: Join during a netburst, by riding the break. Kick them
+ * unless they have ops or voice in the channel.
+ * 2: They're allowed to join through the ban (an invite in
+ * ircu2.10, or a +e on Hybrid, or something).
+ * If they're not joining through a ban, and the banlist is not
+ * full, see if they're on the banlist for the channel. If so,
+ * kickban them.
+ */
+ if(user->uplink->burst && !mNode->modes)
+ {
+ unsigned int ii;
+ for(ii = 0; ii < channel->banlist.used; ii++)
+ {
+ if(user_matches_glob(user, channel->banlist.list[ii]->ban, MATCH_USENICK))
+ {
+ /* Riding a netburst. Naughty. */
+ KickChannelUser(user, channel, chanserv, "User from far side of netsplit should have been banned - bye.");
+ return 1;
+ }
+ }
+ }
+#endif
+
+ if(user->handle_info)
+ {
+ handle = user->handle_info;
+ if(handle)
+ {
+ uData = GetTrueChannelAccess(cData, handle);
+ }
+ }
+
+
+ mod_chanmode_init(&change);
+ change.argc = 1;
+
+ /* 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)
+ {
+ /* 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, channel, &change);
+ KickChannelUser(user, channel, chanserv, kick_reason);
+ return 1;
+ }
+ }
+ }
/* ChanServ will not modify the limits in join-flooded channels.
It will also skip DynLimit processing when the user (or srvx)
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. */
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;
uData->present = 1;
}
}
+
+ /* If user joining normally (not during burst), apply op or voice,
+ * and send greeting/userinfo as appropriate.
+ */
if(!user->uplink->burst)
{
if(modes)
change.args[0].u.member = mNode;
mod_chanmode_announce(chanserv, channel, &change);
}
- if(greeting && !user->uplink->burst)
+ if(greeting)
send_message_type(4, user, chanserv, "(%s) %s", channel->name, greeting);
if(uData && info)
send_target_message(5, channel->name, chanserv, "[%s] %s", user->nick, uData->info);
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))
{
struct mod_chanmode change;
struct userData *channel;
- unsigned int ii, jj;
+ unsigned int ii, jj, i;
if(!user->handle_info)
return;
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, 1))
+ if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
break;
if(jj < channel->banlist.used)
continue;
for(ban = channel->channel_info->bans; ban; ban = ban->next)
{
char kick_reason[MAXLEN];
- if(!user_matches_glob(user, ban->mask, 1))
+ if(!user_matches_glob(user, ban->mask,MATCH_USENICK | MATCH_VISIBLE))
continue;
change.args[0].mode = MODE_BAN;
change.args[0].u.hostmask = ban->mask;
}
}
}
+
+ if (user->handle_info->ignores->used) {
+ for (i=0; i < user->handle_info->ignores->used; i++) {
+ irc_silence(user, user->handle_info->ignores->list[i], 1);
+ }
+ }
+
+ 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(bad_topic(channel, user, channel->topic))
{ /* User doesnt have privs to set topics. Undo it */
send_message(user, chanserv, "CSMSG_TOPIC_LOCKED", channel->name);
- SetChannelTopic(channel, chanserv, old_topic, 1);
+ SetChannelTopic(channel, chanserv, chanserv, old_topic, 1);
return 1;
}
/* If there is a topic mask set, and the new topic doesnt match,
conform_topic(cData->topic_mask, channel->topic, new_topic);
if(*new_topic)
{
- SetChannelTopic(channel, chanserv, new_topic, 1);
+ SetChannelTopic(channel, chanserv, user, 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);
+ SetChannelTopic(channel, chanserv, user, 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;
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);
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);
/* 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))
continue;
/* Look for a matching ban already on the channel. */
for(jj = 0; jj < channel->banlist.used; ++jj)
- if(user_matches_glob(user, channel->banlist.list[jj]->ban, 1))
+ if(user_matches_glob(user, channel->banlist.list[jj]->ban, MATCH_USENICK))
break;
/* 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)
{
- if(!user_matches_glob(user, bData->mask, 1))
+ if(!user_matches_glob(user, bData->mask, MATCH_USENICK | MATCH_VISIBLE))
continue;
change.args[0].u.hostmask = bData->mask;
mod_chanmode_announce(chanserv, channel, &change);
chanserv_conf.network_helper_epithet = str ? str : "a wannabe tyrant";
str = database_get_data(conf_node, KEY_SUPPORT_HELPER_EPITHET, RECDB_QSTRING);
chanserv_conf.support_helper_epithet = str ? str : "a wannabe tyrant";
+ str = database_get_data(conf_node, KEY_GOD_TIMEOUT, RECDB_QSTRING);
+ god_timeout = str ? ParseInterval(str) : 60*15;
str = database_get_data(conf_node, "default_modes", RECDB_QSTRING);
if(!str)
str = "+nt";
safestrncpy(mode_line, str, sizeof(mode_line));
ii = split_line(mode_line, 0, ArrayLength(modes), modes);
- if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE)) && (change->argc < 2))
+ if((change = mod_chanmode_parse(NULL, modes, ii, MCP_KEY_FREE, 0))
+ && (change->argc < 2))
{
chanserv_conf.default_modes = *change;
mod_chanmode_free(change);
}
+ str = database_get_data(conf_node, KEY_VALID_CHANNEL_REGEX, RECDB_QSTRING);
+ if (chanserv_conf.valid_channel_regex_set)
+ regfree(&chanserv_conf.valid_channel_regex);
+ if (str) {
+ int err = regcomp(&chanserv_conf.valid_channel_regex, str, REG_EXTENDED|REG_ICASE|REG_NOSUB);
+ chanserv_conf.valid_channel_regex_set = !err;
+ if (err) log_module(CS_LOG, LOG_ERROR, "Bad valid_channel_regex (error %d)", err);
+ } else {
+ chanserv_conf.valid_channel_regex_set = 0;
+ }
+ free_string_list(chanserv_conf.wheel);
+ strlist = database_get_data(conf_node, "wheel", RECDB_STRING_LIST);
+ if(strlist)
+ strlist = string_list_copy(strlist);
+ else
+ {
+ static const char *list[] = {
+ "peer", "partall", "gline", /* "shun", */
+ "nothing", "randjoin", "abusewhois", "kickall",
+ "nickchange", "kill", "svsignore", "kickbanall",
+ NULL};
+ unsigned int ii;
+ strlist = alloc_string_list(ArrayLength(list)-1);
+ for(ii=0; list[ii]; ii++)
+ string_list_append(strlist, strdup(list[ii]));
+ }
+ chanserv_conf.wheel = strlist;
+
free_string_list(chanserv_conf.set_shows);
strlist = database_get_data(conf_node, "set_shows", RECDB_STRING_LIST);
if(strlist)
"PubCmd", "InviteMe", "UserInfo","EnfOps",
"EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters",
/* multiple choice options */
- "AutoMode", "CtcpReaction", "Protect", "Toys", "TopicRefresh",
+ "AutoMode", "CtcpReaction", "Protect", "Toys", "TopicRefresh", "Resync",
/* binary options */
"DynLimit", "NoDelete", "BanTimeout",
/* delimiter */
* function list as invalid, so it will be initialized.
*/
set_shows_list.used = 0;
+
free_string_list(chanserv_conf.eightball);
strlist = database_get_data(conf_node, KEY_8BALL_RESPONSES, RECDB_STRING_LIST);
if(strlist)
string_list_append(strlist, strdup("Maybe so."));
}
chanserv_conf.eightball = strlist;
+
free_string_list(chanserv_conf.old_ban_names);
strlist = database_get_data(conf_node, KEY_OLD_BAN_NAMES, RECDB_STRING_LIST);
if(strlist)
{
struct handle_info *handle;
struct userData *uData;
- char *seen, *inf, *flags;
+ 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))
{
seen = database_get_data(rd->d.object, KEY_SEEN, RECDB_QSTRING);
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)
+ timeq_add(uData->expires, chanserv_expire_user_suspension, uData);
+ else
+ uData->flags &= ~USER_SUSPENDED;
+ }
/* Upgrade: set autoop to the inverse of noautoop */
if(chanserv_read_version < 2)
return suspended;
}
+static struct giveownership *
+chanserv_read_giveownership(dict_t obj)
+{
+ struct giveownership *giveownership = calloc(1, sizeof(*giveownership));
+ char *str;
+ dict_t previous;
+
+ str = database_get_data(obj, KEY_STAFF_ISSUER, RECDB_QSTRING);
+ giveownership->staff_issuer = str ? strdup(str) : NULL;
+
+ giveownership->old_owner = strdup(database_get_data(obj, KEY_OLD_OWNER, RECDB_QSTRING));
+
+ giveownership->target = strdup(database_get_data(obj, KEY_TARGET, RECDB_QSTRING));
+ giveownership->target_access = atoi(database_get_data(obj, KEY_TARGET_ACCESS, RECDB_QSTRING));
+
+ str = database_get_data(obj, KEY_REASON, RECDB_QSTRING);
+ giveownership->reason = str ? strdup(str) : NULL;
+ str = database_get_data(obj, KEY_ISSUED, RECDB_QSTRING);
+ giveownership->issued = str ? (time_t)strtoul(str, NULL, 0) : 0;
+
+ previous = database_get_data(obj, KEY_PREVIOUS, RECDB_OBJECT);
+ giveownership->previous = previous ? chanserv_read_giveownership(previous) : NULL;
+ return giveownership;
+}
+
static int
chanserv_channel_read(const char *key, struct record_data *hir)
{
struct suspended *suspended;
+ struct giveownership *giveownership;
struct mod_chanmode *modes;
struct chanNode *cNode;
struct chanData *cData;
cData->flags &= ~CHANNEL_SUSPENDED;
}
+ if((obj = database_get_data(hir->d.object, KEY_GIVEOWNERSHIP, RECDB_OBJECT)))
+ {
+ giveownership = chanserv_read_giveownership(obj);
+ cData->giveownership = giveownership;
+ }
+
if((!off_channel || !IsOffChannel(cData)) && !IsSuspended(cData)) {
struct mod_chanmode change;
mod_chanmode_init(&change);
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))
- && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE))) {
+ && (modes = mod_chanmode_parse(cNode, argv, argc, MCP_KEY_FREE, 0))) {
cData->modes = *modes;
if(off_channel > 0)
cData->modes.modes_set |= MODE_REGISTERED;
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_write_int(ctx, KEY_EXPIRES, uData->expires);
if(uData->info)
saxdb_write_string(ctx, KEY_INFO, uData->info);
saxdb_end_record(ctx);
saxdb_end_record(ctx);
}
+static void
+chanserv_write_giveownership(struct saxdb_context *ctx, const char *name, struct giveownership *giveownership)
+{
+ saxdb_start_record(ctx, name, 0);
+ if(giveownership->staff_issuer)
+ saxdb_write_string(ctx, KEY_STAFF_ISSUER, giveownership->staff_issuer);
+ if(giveownership->old_owner)
+ saxdb_write_string(ctx, KEY_OLD_OWNER, giveownership->old_owner);
+ if(giveownership->target)
+ saxdb_write_string(ctx, KEY_TARGET, giveownership->target);
+ if(giveownership->target_access)
+ saxdb_write_int(ctx, KEY_TARGET_ACCESS, giveownership->target_access);
+ if(giveownership->reason)
+ saxdb_write_string(ctx, KEY_REASON, giveownership->reason);
+ if(giveownership->issued)
+ saxdb_write_int(ctx, KEY_ISSUED, giveownership->issued);
+ if(giveownership->previous)
+ chanserv_write_giveownership(ctx, KEY_PREVIOUS, giveownership->previous);
+ saxdb_end_record(ctx);
+}
+
static void
chanserv_write_channel(struct saxdb_context *ctx, struct chanData *channel)
{
saxdb_write_string(ctx, KEY_TOPIC_MASK, channel->topic_mask);
if(channel->suspended)
chanserv_write_suspended(ctx, "suspended", channel->suspended);
+ if(channel->giveownership)
+ chanserv_write_giveownership(ctx, "giveownership", channel->giveownership);
saxdb_start_record(ctx, KEY_OPTIONS, 0);
saxdb_write_int(ctx, KEY_FLAGS, channel->flags);
}
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);
saxdb_start_record(ctx, ntype->name, 0);
switch(ntype->set_access_type)
{
- case NOTE_SET_CHANNEL_ACCESS:
- saxdb_write_int(ctx, KEY_NOTE_CHANNEL_ACCESS, ntype->set_access.min_ulevel);
- break;
- case NOTE_SET_CHANNEL_SETTER:
- saxdb_write_int(ctx, KEY_NOTE_SETTER_ACCESS, 1);
- break;
- case NOTE_SET_PRIVILEGED: default:
- saxdb_write_int(ctx, KEY_NOTE_OPSERV_ACCESS, ntype->set_access.min_opserv);
- break;
+ case NOTE_SET_CHANNEL_ACCESS:
+ saxdb_write_int(ctx, KEY_NOTE_CHANNEL_ACCESS, ntype->set_access.min_ulevel);
+ break;
+ case NOTE_SET_CHANNEL_SETTER:
+ saxdb_write_int(ctx, KEY_NOTE_SETTER_ACCESS, 1);
+ break;
+ case NOTE_SET_PRIVILEGED: default:
+ saxdb_write_int(ctx, KEY_NOTE_OPSERV_ACCESS, ntype->set_access.min_opserv);
+ break;
}
switch(ntype->visible_type)
{
- case NOTE_VIS_ALL: str = KEY_NOTE_VIS_ALL; break;
- case NOTE_VIS_CHANNEL_USERS: str = KEY_NOTE_VIS_CHANNEL_USERS; break;
- case NOTE_VIS_PRIVILEGED: default: str = KEY_NOTE_VIS_PRIVILEGED; break;
+ case NOTE_VIS_ALL: str = KEY_NOTE_VIS_ALL; break;
+ case NOTE_VIS_CHANNEL_USERS: str = KEY_NOTE_VIS_CHANNEL_USERS; break;
+ case NOTE_VIS_PRIVILEGED:
+ default: str = KEY_NOTE_VIS_PRIVILEGED; break;
}
saxdb_write_string(ctx, KEY_NOTE_VISIBILITY, str);
saxdb_write_int(ctx, KEY_NOTE_MAX_LENGTH, ntype->max_length);
dict_delete(note_types);
free_string_list(chanserv_conf.eightball);
free_string_list(chanserv_conf.old_ban_names);
+ free_string_list(chanserv_conf.wheel);
free_string_list(chanserv_conf.set_shows);
free(set_shows_list.list);
free(uset_shows_list.list);
void
init_chanserv(const char *nick)
{
+ struct chanNode *chan;
+ unsigned int i;
+
CS_LOG = log_register_type("ChanServ", "file:chanserv.log");
conf_register_reload(chanserv_conf_read);
reg_svccmd_unbind_func(handle_svccmd_unbind);
chanserv_module = module_register("ChanServ", CS_LOG, "chanserv.help", chanserv_expand_variable);
- DEFINE_COMMAND(register, 1, MODCMD_REQUIRE_AUTHED, "flags", "+acceptchan,+helping", NULL);
+ DEFINE_COMMAND(register, 1, MODCMD_REQUIRE_AUTHED, "flags", "+acceptchan,+channel", NULL);
DEFINE_COMMAND(noregister, 1, MODCMD_REQUIRE_AUTHED, "flags", "+helping", NULL);
DEFINE_COMMAND(allowregister, 2, 0, "template", "noregister", NULL);
DEFINE_COMMAND(move, 1, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "template", "register", NULL);
DEFINE_COMMAND(mdelmanager, 2, MODCMD_REQUIRE_CHANUSER, "access", "coowner", NULL);
DEFINE_COMMAND(mdelop, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
DEFINE_COMMAND(mdelpeon, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
+ DEFINE_COMMAND(mdelpal, 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);
+ DEFINE_COMMAND(roulette, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
+ DEFINE_COMMAND(shoot, 1, 0, "flags", "+nolog,+toy,+acceptchan", NULL);
+ DEFINE_COMMAND(spin, 1, MODCMD_REQUIRE_AUTHED, "spin", "+nolog,+toy,+acceptchan", NULL);
/* Channel options */
DEFINE_CHANNEL_OPTION(defaulttopic);
DEFINE_CHANNEL_OPTION(toys);
DEFINE_CHANNEL_OPTION(setters);
DEFINE_CHANNEL_OPTION(topicrefresh);
+ DEFINE_CHANNEL_OPTION(resync);
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);
time_t next_refresh;
next_refresh = (now + chanserv_conf.refresh_period - 1) / chanserv_conf.refresh_period * chanserv_conf.refresh_period;
timeq_add(next_refresh, chanserv_refresh_topics, NULL);
+ timeq_add(next_refresh, chanserv_auto_resync, NULL);
+ }
+
+ if (autojoin_channels && chanserv) {
+ for (i = 0; i < autojoin_channels->used; i++) {
+ chan = AddChannel(autojoin_channels->list[i], now, "+nt", NULL, NULL);
+ AddChannelUser(chanserv, chan)->modes |= MODE_CHANOP;
+ }
}
reg_exit_func(chanserv_db_cleanup);
message_register_table(msgtab);
}
+