#define KEY_GIVEOWNERSHIP_PERIOD "giveownership_timeout"
/* ChanServ database */
+#define KEY_VERSION_CONTROL "version_control"
#define KEY_CHANNELS "channels"
#define KEY_NOTE_TYPES "note_types"
+/* version control paramiter */
+#define KEY_VERSION_NUMBER "version_number"
+
/* Note type parameters */
#define KEY_NOTE_OPSERV_ACCESS "opserv_access"
#define KEY_NOTE_CHANNEL_ACCESS "channel_access"
#define KEY_FLAGS "flags"
#define KEY_OPTIONS "options"
#define KEY_USERS "users"
-#define KEY_BANS "bans"
+#define KEY_BANS "bans" /* for lamers */
#define KEY_MAX "max"
#define KEY_NOTES "notes"
#define KEY_TOPIC_MASK "topic_mask"
{ "CSMSG_REG_SUCCESS", "You now have ownership of $b%s$b." },
{ "CSMSG_PROXY_SUCCESS", "%s now has ownership of $b%s$b." },
{ "CSMSG_ALREADY_REGGED", "$b%s$b is registered to someone else." },
- { "CSMSG_MUST_BE_OPPED", "You must be a channel operator in $b%s$b to register it." },
+ { "CSMSG_MUST_BE_OPPED", "You must be a channel operator (+o) in $b%s$b to register it." },
{ "CSMSG_PROXY_FORBIDDEN", "You may not register a channel for someone else." },
- { "CSMSG_OWN_TOO_MANY", "%s already owns enough channels (at least %d); use FORCE to override." },
+ { "CSMSG_OWN_TOO_MANY", "%s already owns more than the limit of %d channels. Use FORCE to override." },
+ { "CSMSG_YOU_OWN_TOO_MANY", "You already own more than the limit of %d channels. Ask a staff member for help." },
+ { "CSMSG_ANOTHER_SERVICE", "Another service bot is in that channel already. Ask a staff member for help." },
/* Do-not-register channels */
{ "CSMSG_NOT_DNR", "$b%s$b is not a valid channel name or *account." },
{ "CSMSG_UNREG_SUCCESS", "$b%s$b has been unregistered." },
{ "CSMSG_UNREG_NODELETE", "$b%s$b is protected from unregistration." },
{ "CSMSG_CHAN_SUSPENDED", "$b$C$b access to $b%s$b has been temporarily suspended (%s)." },
- { "CSMSG_CONFIRM_UNREG", "To confirm this unregistration, you must use 'unregister %s'." },
+ { "CSMSG_CONFIRM_UNREG", "To confirm this unregistration, you must use 'unregister %s %s'." },
/* Channel moving */
{ "CSMSG_MOVE_SUCCESS", "Channel registration has been moved to $b%s$b." },
{ "CSMSG_NO_CHAN_USER", "%s lacks access to $b%s$b." },
{ "CSMSG_NO_ACCESS", "You lack sufficient access to use this command." },
{ "CSMSG_NOT_REGISTERED", "$b%s$b has not been registered with $b$C$b." },
- { "CSMSG_MAXIMUM_BANS", "This channel has reached the ban count limit of $b%d$b." },
+ { "CSMSG_MAXIMUM_LAMERS", "This channel has reached the lamer count limit of $b%d$b." },
{ "CSMSG_MAXIMUM_USERS", "This channel has reached the user count limit of $b%d$b." },
{ "CSMSG_ILLEGAL_CHANNEL", "$b%s$b is an illegal channel, and cannot be registered." },
{ "CSMSG_GODMODE_UP", "You may not use $b%s$b to op yourself unless you are on the user list. Use the $bop$b command instead." },
{ "CSMSG_TRIMMED_USERS", "Trimmed $b%d users$b with access from %d to %d from the %s user list who were inactive for at least %s." },
{ "CSMSG_INCORRECT_ACCESS", "%s has access $b%s$b, not %s." },
{ "CSMSG_USER_EXISTS", "%s is already on the $b%s$b user list (with %s access)." },
+ { "CSMSG_ADDUSER_PENDING", "I have sent him/her a message letting them know, and if they auth or register soon, I will finish adding them automatically." },
+ { "CSMSG_ADDUSER_PENDING_ALREADY", "He or she is already pending addition to %s once he/she auths with $b$N$b." },
+ { "CSMSG_ADDUSER_PENDING_HEADER", "Users to add to channels pending logins:" }, /* Remove after testing? */
+ { "CSMSG_ADDUSER_PENDING_LIST", "Channel %s user %s" }, /* Remove after testing? */
+ { "CSMSG_ADDUSER_PENDING_FOOTER", "--------- End of pending list ----------" }, /* Remove after testing? */
+ /*{ "CSMSG_ADDUSER_PENDING_NOTINCHAN", "That user is not in %s, and is not auth'd." }, */
+ { "CSMSG_ADDUSER_PENDING_TARGET", "Channel Services bot here: %s would like to add you to my userlist in channel %s, but you are not authenticated to $b$N$b. Please authenticate now and you will be added. If you do not have an account, type /msg $N help register" },
{ "CSMSG_CANNOT_TRIM", "You must include a minimum inactivity duration of at least 60 seconds to trim." },
{ "CSMSG_NO_SELF_CLVL", "You cannot change your own access." },
{ "CSMSG_OWNERSHIP_GIVEN", "Ownership of $b%s$b has been transferred to account $b%s$b." },
/* Ban management */
- { "CSMSG_BAN_ADDED", "Permanently banned $b%s$b from %s." },
- { "CSMSG_TIMED_BAN_ADDED", "Banned $b%s$b from %s for %s." },
+ { "CSMSG_LAMER_ADDED", "Added $b%s$b to %s LAMERs." },
+ { "CSMSG_TIMED_LAMER_ADDED", "LAMERed $b%s$b on %s for %s." },
{ "CSMSG_KICK_BAN_DONE", "Kickbanned $b%s$b from %s." },
{ "CSMSG_BAN_DONE", "Banned $b%s$b from %s." },
- { "CSMSG_REASON_CHANGE", "Reason for ban $b%s$b changed." },
- { "CSMSG_BAN_EXTENDED", "Extended ban for $b%s$b expires in %s." },
- { "CSMSG_BAN_REMOVED", "Matching ban(s) for $b%s$b removed." },
- { "CSMSG_TRIMMED_BANS", "Trimmed $b%d bans$b from the %s ban list that were inactive for at least %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_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_DURATION_TOO_LOW", "Timed bans must last for at least 15 seconds." },
{ "CSMSG_DURATION_TOO_HIGH", "Timed bans must last for less than 2 years." },
{ "CSMSG_LAME_MASK", "$b%s$b is a little too general. Try making it more specific." },
{ "CSMSG_MASK_PROTECTED", "Sorry, ban for $b%s$b conflicts with a protected user's hostmask." },
{ "CSMSG_NO_MATCHING_USERS", "No one in $b%s$b has a hostmask matching $b%s$b." },
- { "CSMSG_BAN_NOT_FOUND", "Sorry, no ban found for $b%s$b." },
+ { "CSMSG_BAN_NOT_FOUND", "Sorry, no ban or LAMER found: $b%s$b." },
{ "CSMSG_BANLIST_FULL", "The $b%s$b channel ban list is $bfull$b." },
{ "CSMSG_INVALID_TRIM", "$b%s$b isn't a valid trim target." },
{ "CSMSG_CONFIRM_DEFAULTS", "To reset %s's settings to the defaults, you must use 'set defaults %s'." },
{ "CSMSG_SETTINGS_DEFAULTED", "All settings for %s have been reset to default values." },
{ "CSMSG_BAD_SETLEVEL", "You cannot change any setting to above your level." },
+ /*
{ "CSMSG_BAD_GIVEVOICE", "You cannot change GiveVoice to above GiveHalfOps (%d)." },
{ "CSMSG_BAD_GIVEHOPS", "You cannot change GiveHalfOps to below GiveOps (%d)." },
{ "CSMSG_BAD_GIVEOPS", "You cannot change GiveOps to below GiveVoice (%d)." },
+ */
{ "CSMSG_BAD_SETTERS", "You cannot change Setters to above your level." },
{ "CSMSG_INVALID_MODE_LOCK", "$b%s$b is an invalid mode lock." },
{ "CSMSG_INVALID_NUMERIC", "$b%d$b is not a valid choice. Choose one:" },
{ "CSMSG_SET_USERGREETING", "$bUserGreeting$b %s" },
{ "CSMSG_SET_MODES", "$bModes $b %s" },
{ "CSMSG_SET_NODELETE", "$bNoDelete $b %s" },
- { "CSMSG_SET_DYNLIMIT", "$bDynLimit $b %s" },
+ { "CSMSG_SET_DYNLIMIT", "$bDynLimit $b %s - +l joinflood protection." },
{ "CSMSG_SET_OFFCHANNEL", "$bOffChannel $b %s" },
- { "CSMSG_SET_USERINFO", "$bUserInfo $b %d" },
+ { "CSMSG_SET_USERINFO", "$bUserInfo $b %d - and above userinfos are shown." },
+ /*
{ "CSMSG_SET_GIVE_VOICE", "$bGiveVoice $b %d" },
{ "CSMSG_SET_GIVE_HALFOPS", "$bGiveHalfOps $b %d" },
+ */
{ "CSMSG_SET_TOPICSNARF", "$bTopicSnarf $b %d" },
- { "CSMSG_SET_INVITEME", "$bInviteMe $b %d" },
- { "CSMSG_SET_ENFOPS", "$bEnfOps $b %d" },
- { "CSMSG_SET_ENFHALFOPS", "$bEnfHalfOps $b %d" },
+ { "CSMSG_SET_INVITEME", "$bInviteMe $b %d - Userlevel required to invite self." },
+ { "CSMSG_SET_ENFOPS", "$bEnfOps $b %d - level and above can op unknown users." },
+ { "CSMSG_SET_ENFHALFOPS", "$bEnfHalfOps $b %d - level and above can hop unknown users." },
+ /*
{ "CSMSG_SET_GIVE_OPS", "$bGiveOps $b %d" },
- { "CSMSG_SET_ENFMODES", "$bEnfModes $b %d" },
- { "CSMSG_SET_ENFTOPIC", "$bEnfTopic $b %d" },
- { "CSMSG_SET_PUBCMD", "$bPubCmd $b %d" },
- { "CSMSG_SET_SETTERS", "$bSetters $b %d" },
- { "CSMSG_SET_CTCPUSERS", "$bCTCPUsers $b %d" },
+ */
+ { "CSMSG_SET_ENFMODES", "$bEnfModes $b %d - and above can change channel modes." },
+ { "CSMSG_SET_ENFTOPIC", "$bEnfTopic $b %d - and above can set the topic." },
+ { "CSMSG_SET_PUBCMD", "$bPubCmd $b %d - and above can use public commands." },
+ { "CSMSG_SET_SETTERS", "$bSetters $b %d - and above can change these settings." },
+/* { "CSMSG_SET_CTCPUSERS", "$bCTCPUsers $b %d - and above can use ctcps." }, */
+ { "CSMSG_SET_VOICE", "$bvoice $b %d - %s" },
{ "CSMSG_SET_PROTECT", "$bProtect $b %d - %s" },
{ "CSMSG_SET_TOYS", "$bToys $b %d - %s" },
{ "CSMSG_SET_CTCPREACTION", "$bCTCPReaction$b %d - %s" },
{ "CSMSG_SET_TOPICREFRESH", "$bTopicRefresh$b %d - %s" },
- { "CSMSG_USET_NOAUTOOP", "$bNoAutoOp $b %s" },
- { "CSMSG_USET_NOAUTOVOICE", "$bNoAutoVoice $b %s" },
+ { "CSMSG_USET_AUTOOP", "$bAutoOp $b %s" },
+ { "CSMSG_USET_AUTOVOICE", "$bAutoVoice $b %s" },
{ "CSMSG_USET_AUTOINVITE", "$bAutoInvite $b %s" },
{ "CSMSG_USET_INFO", "$bInfo $b %s" },
{ "CSMSG_DEHALFOPPED_USERS", "DeHalfopped users in $b%s$b." },
{ "CSMSG_VOICED_USERS", "Voiced users in $b%s$b." },
{ "CSMSG_DEVOICED_USERS", "Devoiced users in $b%s$b." },
+ { "CSMSG_VOICE_NONE", "Noone will be auto-voiced" },
+ { "CSMSG_VOICE_PEON", "PEONs will be auto-voiced" },
+ { "CSMSG_VOICE_ALL", "Everyone will be auto-voiced" },
{ "CSMSG_PROTECT_ALL", "Non-users and users will be protected from those of equal or lower access." },
{ "CSMSG_PROTECT_EQUAL", "Users will be protected from those of equal or lower access." },
{ "CSMSG_PROTECT_LOWER", "Users will be protected from those of lower access." },
{ "CSMSG_TOPICREFRESH_6_HOURS", "Refresh every 6 hours." },
{ "CSMSG_TOPICREFRESH_12_HOURS", "Refresh every 12 hours." },
{ "CSMSG_TOPICREFRESH_24_HOURS", "Refresh every 24 hours." },
+ { "CSMSG_CTCPREACTION_NONE", "CTCPs are allowed" },
{ "CSMSG_CTCPREACTION_KICK", "Kick on disallowed CTCPs" },
{ "CSMSG_CTCPREACTION_KICKBAN", "Kickban on disallowed CTCPs" },
{ "CSMSG_CTCPREACTION_SHORTBAN", "Short timed ban on disallowed CTCPs" },
{ "CSMSG_BAD_INFOLINE", "You may not use the character \\%03o in your infoline." },
{ "CSMSG_KICK_DONE", "Kicked $b%s$b from %s." },
- { "CSMSG_NO_BANS", "No channel bans found on $b%s$b." },
+ { "CSMSG_NO_BANS", "No bans found on $b%s$b." },
{ "CSMSG_BANS_REMOVED", "Removed all channel bans from $b%s$b." },
/* Channel userlist */
{ "CSMSG_ACCESS_SEARCH_HEADER", "$b%s Users From Level %s To %s Matching %s$b" },
{ "CSMSG_INVALID_ACCESS", "$b%s$b is an invalid access level." },
{ "CSMSG_CHANGED_ACCESS", "%s now has access $b%s$b (%u) in %s." },
- { "CSMSG_BANS_HEADER", "$bBans in %s$b" },
+ { "CSMSG_LAMERS_HEADER", "$bLamers in %s$b" },
/* Channel note list */
{ "CSMSG_NOTELIST_HEADER", "Notes for $b%s$b:" },
{ "CSMSG_CHANNEL_MODES", "$bMode Lock: $b%s" },
{ "CSMSG_CHANNEL_NOTE", "$b%s:%*s$b%s" },
{ "CSMSG_CHANNEL_MAX", "$bRecord Visitors: $b%i" },
- { "CSMSG_CHANNEL_OWNER", "$bOwner: $b%s" },
- { "CSMSG_CHANNEL_BANS", "$bBan Count: $b%i" },
+ { "CSMSG_CHANNEL_OWNER", "$bOwner: $b%s" },
+ { "CSMSG_CHANNEL_LAMERS", "$bLamer Count: $b%i" },
{ "CSMSG_CHANNEL_USERS", "$bTotal User Count: $b%i" },
{ "CSMSG_CHANNEL_REGISTRAR", "$bRegistrar: $b%s" },
{ "CSMSG_CHANNEL_SUSPENDED", "$b%s$b is suspended:" },
{ "CSMSG_NETWORK_INFO", "Network Information:" },
{ "CSMSG_NETWORK_SERVERS", "$bServers: $b%i" },
{ "CSMSG_NETWORK_USERS", "$bTotal Users: $b%i" },
- { "CSMSG_NETWORK_BANS", "$bTotal Ban Count: $b%i" },
+ { "CSMSG_NETWORK_LAMERS", "$bTotal Lamer Count: $b%i" },
{ "CSMSG_NETWORK_CHANUSERS", "$bTotal User Count: $b%i" },
{ "CSMSG_NETWORK_OPERS", "$bIRC Operators: $b%i" },
{ "CSMSG_NETWORK_CHANNELS","$bRegistered Channels: $b%i" },
/* User settings */
{ "CSMSG_USER_OPTIONS", "User Options:" },
- { "CSMSG_USER_PROTECTED", "That user is protected." },
+// { "CSMSG_USER_PROTECTED", "That user is protected." },
/* Toys */
{ "CSMSG_UNF_RESPONSE", "I don't want to be part of your sick fantasies!" },
/* Other things */
{ "CSMSG_EVENT_SEARCH_RESULTS", "$bChannel Events for %s$b" },
+ { "CSMSG_LAST_INVALID", "Invalid argument. must be 1-200" },
{ NULL, NULL }
};
/* eject_user and unban_user flags */
#define ACTION_KICK 0x0001
#define ACTION_BAN 0x0002
-#define ACTION_ADD_BAN 0x0004
-#define ACTION_ADD_TIMED_BAN 0x0008
+#define ACTION_ADD_LAMER 0x0004
+#define ACTION_ADD_TIMED_LAMER 0x0008
#define ACTION_UNBAN 0x0010
-#define ACTION_DEL_BAN 0x0020
+#define ACTION_DEL_LAMER 0x0020
/* The 40 allows for [+-ntlksimprD] and lots of fudge factor. */
#define MODELEN 40 + KEYLEN
int off_channel;
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;
static struct
{
unsigned int max_owned;
unsigned int max_chan_users;
- unsigned int max_chan_bans;
+ unsigned int max_chan_bans; /* lamers */
unsigned int max_userinfo_length;
struct string_list *set_shows;
{ "helper", "BUG:", UL_HELPER, 'X' }
};
+/* If you change this, change the enum in chanserv.h also, or stack smashing will commence. */
static const struct {
char *format_name;
char *db_name;
unsigned int old_flag;
unsigned short flag_value;
} levelOptions[] = {
- { "CSMSG_SET_GIVE_VOICE", "givevoice", 100, ~0, CHANNEL_VOICE_ALL, 0 },
- { "CSMSG_SET_GIVE_HALFOPS", "givehalfops", 150, ~0, CHANNEL_HOP_ALL, 0 },
- { "CSMSG_SET_GIVE_OPS", "giveops", 200, 2, 0, 0 },
+// { "CSMSG_SET_GIVE_VOICE", "givevoice", 100, ~0, CHANNEL_VOICE_ALL, 0 },
+// { "CSMSG_SET_GIVE_HALFOPS", "givehalfops", 150, ~0, CHANNEL_HOP_ALL, 0 },
+// { "CSMSG_SET_GIVE_OPS", "giveops", 200, 2, 0, 0 }, // these 3 need removed, but causes segs if its still in the db..
{ "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_CTCPUSERS", "ctcpusers", 0, 9, 0, 0 },
+// { "CSMSG_SET_CTCPUSERS", "ctcpusers", 0, 9, 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 }
struct charOptionValues {
char value;
char *format_name;
-} protectValues[] = {
+} voiceValues[] = {
+ { 'n', "CSMSG_VOICE_NONE" },
+ { 'p', "CSMSG_VOICE_PEON" },
+ { 'a', "CSMSG_VOICE_ALL" }
+}, protectValues[] = {
{ 'a', "CSMSG_PROTECT_ALL" },
{ 'e', "CSMSG_PROTECT_EQUAL" },
{ 'l', "CSMSG_PROTECT_LOWER" },
{ '3', "CSMSG_TOPICREFRESH_12_HOURS" },
{ '4', "CSMSG_TOPICREFRESH_24_HOURS" }
}, ctcpReactionValues[] = {
+ { 'n', "CSMSG_CTCPREACTION_NONE" },
{ 'k', "CSMSG_CTCPREACTION_KICK" },
{ 'b', "CSMSG_CTCPREACTION_KICKBAN" },
{ 't', "CSMSG_CTCPREACTION_SHORTBAN" },
unsigned char count;
struct charOptionValues *values;
} charOptions[] = {
- { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues), protectValues },
- { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
+ { "CSMSG_SET_VOICE", "voice", 'p', 99, ArrayLength(voiceValues), voiceValues },
+ { "CSMSG_SET_PROTECT", "protect", 'l', 0, ArrayLength(protectValues), protectValues },
+ { "CSMSG_SET_TOYS", "toys", 'p', 6, ArrayLength(toysValues), toysValues },
{ "CSMSG_SET_TOPICREFRESH", "topicrefresh", 'n', 8, ArrayLength(topicRefreshValues), topicRefreshValues },
- { "CSMSG_SET_CTCPREACTION", "ctcpreaction", 't', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues }
+ { "CSMSG_SET_CTCPREACTION", "ctcpreaction", 'n', 10, ArrayLength(ctcpReactionValues), ctcpReactionValues }
};
struct userData *helperList;
struct chanData *channelList;
static struct module *chanserv_module;
static unsigned int userCount;
+unsigned int chanserv_read_version = 0; /* db version control */
+
+#define CHANSERV_DB_VERSION 2
#define GetChannelUser(channel, handle) _GetChannelUser(channel, handle, 1, 0)
#define GetChannelAccess(channel, handle) _GetChannelUser(channel, handle, 0, 0)
|| IsService(user)
|| !ircncasecmp(text, "ACTION ", 7))
return;
- /* Figure out the minimum level needed to CTCP the channel */
- if(check_user_level(channel, user, lvlCTCPUsers, 1, 0))
- return;
+ /* We dont punish people we know -Rubin
+ * * Figure out the minimum level needed to CTCP the channel *
+ *
+ * if(check_user_level(channel, user, lvlCTCPUsers, 1, 0))
+ * return;
+ */
+ /* If they are a user of the channel, they are exempt */
+ if(_GetChannelUser(channel->channel_info, user->handle_info, 0, 0))
+ return;
/* We need to enforce against them; do so. */
eflags = 0;
argv[0] = text;
if(GetUserMode(channel, user))
eflags |= ACTION_KICK;
switch(channel->channel_info->chOpts[chCTCPReaction]) {
- default: case 'k': /* just do the kick */ break;
+ default: case 'n': return;
+ case 'k':
+ eflags |= ACTION_KICK;
+ break;
case 'b':
eflags |= ACTION_BAN;
break;
case 't':
- eflags |= ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN;
+ eflags |= ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER;
argv[argc++] = (char*)chanserv_conf.ctcp_short_ban_duration;
break;
case 'T':
- eflags |= ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN;
+ eflags |= ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER;
argv[argc++] = (char*)chanserv_conf.ctcp_long_ban_duration;
break;
}
ud->u_next->u_prev = ud;
ud->handle->channels = ud;
+ ud->flags = USER_FLAGS_DEFAULT;
return ud;
}
unregister_channel(channel, "lost all users.");
}
+static struct adduserPending*
+add_adduser_pending(struct chanNode *channel, struct userNode *user, int level)
+{
+ struct adduserPending *ap;
+ ap = calloc(1,sizeof(struct adduserPending));
+ ap->channel = channel;
+ ap->user = user;
+ ap->level = level;
+ ap->created = time(NULL);
+
+ /* ap->prev defaults to NULL already.. */
+ ap->next = adduser_pendings;
+ if(adduser_pendings)
+ adduser_pendings->prev = ap;
+ adduser_pendings = ap;
+ adduser_pendings_count++;
+ return(ap);
+}
+
+static void
+del_adduser_pending(struct adduserPending *ap)
+{
+ if(ap->prev)
+ ap->prev->next = ap->next;
+ else
+ adduser_pendings = ap->next;
+
+ if(ap->next)
+ ap->next->prev = ap->prev;
+ free(ap);
+}
+
+static void expire_adduser_pending();
+
+/* find_adduser_pending(channel, user) will find an arbitrary record
+ * from user, channel, or user and channel.
+ * if user or channel are NULL, they will match any records.
+ */
+static struct adduserPending*
+find_adduser_pending(struct chanNode *channel, struct userNode *user)
+{
+ struct adduserPending *ap;
+
+ expire_adduser_pending(); /* why not here.. */
+
+ if(!channel && !user) /* 2 nulls matches all */
+ return(adduser_pendings);
+ for(ap = adduser_pendings;ap;ap = ap->next)
+ {
+ if((channel == ap->channel && (user == NULL || user == ap->user)) || (user==ap->user && channel==NULL))
+ return ap;
+ }
+ return NULL;
+}
+
+
+/* Remove all pendings for a user or channel
+ *
+ * called in nickserv.c DelUser() and proto-* unregister_channel()
+ */
+void
+wipe_adduser_pending(struct chanNode *channel, struct userNode *user)
+{
+ struct adduserPending *ap;
+
+ /* So this is a bit wastefull, i hate dealing with linked lists.
+ * if its a problem we'll rewrite it right */
+ while((ap = find_adduser_pending(channel, user))) {
+ del_adduser_pending(ap);
+ }
+}
+
+/* Called from nickserv.c cmd_auth after someone auths */
+void
+process_adduser_pending(struct userNode *user)
+{
+ struct adduserPending *ap;
+ if(!user->handle_info)
+ return; /* not associated with an account */
+ while((ap = find_adduser_pending(NULL, user)))
+ {
+ struct userData *actee;
+ if(GetTrueChannelAccess(ap->channel->channel_info, ap->user->handle_info))
+ {
+ /* Already on the userlist. do nothing*/
+ }
+ else
+ {
+ actee = add_channel_user(ap->channel->channel_info, ap->user->handle_info, ap->level, 0, NULL);
+ scan_user_presence(actee, NULL);
+ }
+ del_adduser_pending(ap);
+ }
+}
+
+static void
+expire_adduser_pending()
+{
+ struct adduserPending *ap, *ap_next;
+ ap = adduser_pendings;
+ while(ap)
+ {
+ if((ap->created + ADDUSER_PENDING_EXPIRE) < time(NULL))
+ { /* expire it */
+ ap_next = ap->next; /* save next */
+ del_adduser_pending(ap); /* free and relink */
+ ap = ap_next; /* advance */
+ }
+ else
+ ap = ap->next;
+ }
+}
+
static void expire_ban(void *data);
static struct banData*
timeq_add(expires, expire_ban, bd);
bd->prev = NULL;
- bd->next = channel->bans;
+ bd->next = channel->bans; /* lamers */
if(channel->bans)
channel->bans->prev = bd;
channel->bans = bd;
}
static void
-expire_ban(void *data)
+expire_ban(void *data) /* lamer.. */
{
struct banData *bd = data;
if(!IsSuspended(bd->channel))
up:
- Channel information.
- Channel users.
- - Channel bans.
+ - Channel bans. (lamers)
- Channel suspension data.
+ - adduser_pending data.
- Timeq entries. (Except timed bans, which are handled elsewhere.)
*/
mod_chanmode_announce(chanserv, channel->channel, &change);
}
+ wipe_adduser_pending(channel->channel, NULL);
+
while(channel->users)
del_channel_user(channel->users, 0);
/* Don't protect if no one is to be protected, someone is attacking
himself, or if the aggressor is an IRC Operator. */
- if(protect == 'n' || victim == aggressor || IsOper(aggressor))
+ if(protect == 'n' || victim == aggressor /* Opers dont get special treatment :/ || IsOper(aggressor) */)
return 0;
/* Don't protect if the victim isn't authenticated (because they
struct userData *cs_victim;
if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
- || (cs_victim->access < cData->lvlOpts[lvlGiveOps]))
+ || (cs_victim->access < UL_OP /* cData->lvlOpts[lvlGiveOps]*/))
&& !check_user_level(channel, user, lvlEnfOps, 0, 0))
{
send_message(user, chanserv, "CSMSG_OPBY_LOCKED");
struct userData *cs_victim;
if((!(cs_victim = GetChannelUser(cData, victim->handle_info))
- || (cs_victim->access < cData->lvlOpts[lvlGiveHalfOps]))
+ || (cs_victim->access < UL_HALFOP /* cData->lvlOpts[lvlGiveHalfOps] */))
&& !check_user_level(channel, user, lvlEnfHalfOps, 0, 0))
{
send_message(user, chanserv, "CSMSG_HOPBY_LOCKED");
char *chan_name;
unsigned int new_channel, force=0;
struct do_not_register *dnr;
+ unsigned int n;
+
if(channel)
{
return 0;
}
- if(!IsHelping(user)
- && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
+ if(!IsHelping(user) && (!(mn = GetUserMode(channel, user)) || !(mn->modes & MODE_CHANOP)))
{
reply("CSMSG_MUST_BE_OPPED", channel->name);
return 0;
return 0;
force = (argc > (new_channel+2)) && !irccasecmp(argv[new_channel+2], "force");
dnr = chanserv_is_dnr(chan_name, handle);
+
+ /* Check if they are over the limit.. */
+ if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
+ {
+ reply("CSMSG_OWN_TOO_MANY", handle->handle, chanserv_conf.max_owned);
+ return 0;
+ }
+
}
else
{
- handle = user->handle_info;
+ handle = user->handle_info;
dnr = chanserv_is_dnr(chan_name, handle);
+ /* Check if they are over the limit.. */
+ if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
+ {
+ reply("CSMSG_YOU_OWN_TOO_MANY", chanserv_conf.max_owned);
+ return 0;
+ }
+ /* Check if another service is in the channel */
+ if(channel)
+ for(n = 0; n < channel->members.used; n++)
+ {
+ mn = channel->members.list[n];
+ if((mn && mn->user && (mn->user->modes & FLAGS_SERVICE)) || IsLocal(mn->user))
+ {
+ reply("CSMSG_ANOTHER_SERVICE");
+ return 0;
+ }
+ }
}
if(dnr && !force)
{
return 0;
}
+ /* now handled above for message specilization *
if((chanserv_get_owned_count(handle) >= chanserv_conf.max_owned) && !force)
{
reply("CSMSG_OWN_TOO_MANY", handle->handle, chanserv_conf.max_owned);
return 0;
}
+ */
if(new_channel)
channel = AddChannel(argv[1], now, NULL, NULL, NULL);
confirm_string = make_confirmation_string(uData);
if((argc < 2) || strcmp(argv[1], confirm_string))
{
- reply("CSMSG_CONFIRM_UNREG", confirm_string);
+ reply("CSMSG_CONFIRM_UNREG", channel->name, confirm_string);
return 0;
}
}
}
if(!(handle = modcmd_get_handle_info(user, argv[1])))
+ {
+ // 'kevin must first authenticate with AuthServ.' is sent to user
+ struct userNode *unode;
+ unode = GetUserH(argv[1]); /* find user struct by nick */
+ if(unode)
+ {
+ if(find_adduser_pending(channel, unode)) {
+ reply("CSMSG_ADDUSER_PENDING_ALREADY", channel->name);
+ }
+ else {
+ if(IsInChannel(channel, unode)) {
+ reply("CSMSG_ADDUSER_PENDING");
+ add_adduser_pending(channel, unode, access);
+ send_message_type(1,unode, chanserv, "CSMSG_ADDUSER_PENDING_TARGET", user->nick, channel->name);
+ }
+ /* this results in user must auth AND not in chan errors. too confusing..
+ else {
+ reply("CSMSG_ADDUSER_PENDING_NOTINCHAN", channel->name);
+ }
+ */
+ }
+ }
return 0;
+ }
if((actee = GetTrueChannelAccess(channel->channel_info, handle)))
{
}
+/* trim_lamers.. */
static int
cmd_trim_bans(struct userNode *user, struct chanNode *channel, unsigned long duration)
{
}
intervalString(interval, duration, user->handle_info);
- send_message(user, chanserv, "CSMSG_TRIMMED_BANS", count, channel->name, interval);
+ send_message(user, chanserv, "CSMSG_TRIMMED_LAMERS", count, channel->name, interval);
return 1;
}
return 0;
}
- if(!irccasecmp(argv[1], "bans"))
+ if(!irccasecmp(argv[1], "lamers"))
{
- cmd_trim_bans(user, channel, duration);
+ cmd_trim_bans(user, channel, duration); /* trim_lamers.. */
return 1;
}
else if(!irccasecmp(argv[1], "users"))
reply("CSMSG_GODMODE_UP", argv[0]);
return 0;
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveOps])
+ else if(uData->access >= UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
{
change.args[0].mode = MODE_CHANOP;
errmsg = "CSMSG_ALREADY_OPPED";
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveHalfOps])
+ else if(uData->access >= UL_HALFOP /*channel->channel_info->lvlOpts[lvlGiveHalfOps]*/)
{
change.args[0].mode = MODE_HALFOP;
errmsg = "CSMSG_ALREADY_HALFOPPED";
}
- else if(uData->access >= channel->channel_info->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON && (channel->channel_info->chOpts[chVoice] == 'p' || channel->channel_info->chOpts[chVoice] == 'a'))
{
change.args[0].mode = MODE_VOICE;
errmsg = "CSMSG_ALREADY_VOICED";
char *reason = "Bye.", *ban, *name;
char interval[INTERVALLEN];
- offset = (action & ACTION_ADD_TIMED_BAN) ? 3 : 2;
+ offset = (action & ACTION_ADD_TIMED_LAMER) ? 3 : 2;
REQUIRE_PARAMS(offset);
if(argc > offset)
{
if(IsService(victim))
{
- reply("MSG_SERVICE_IMMUNE", victim->nick);
+ if(cmd)
+ reply("MSG_SERVICE_IMMUNE", victim->nick);
return 0;
}
if((action == ACTION_KICK) && !victimCount)
{
- reply("MSG_CHANNEL_USER_ABSENT", victim->nick, channel->name);
+ if(cmd)
+ reply("MSG_CHANNEL_USER_ABSENT", victim->nick, channel->name);
return 0;
}
if(protect_user(victim, user, channel->channel_info))
{
- reply("CSMSG_USER_PROTECTED", victim->nick);
+ // This translates to send_message(user, cmd->parent->bot, ...)
+ // if user is x3 (ctcp action) cmd is null and segfault.
+ if(cmd)
+ reply("CSMSG_USER_PROTECTED", victim->nick);
return 0;
}
{
if(!is_ircmask(argv[1]))
{
- reply("MSG_NICK_UNKNOWN", argv[1]);
+ if(cmd)
+ reply("MSG_NICK_UNKNOWN", argv[1]);
return 0;
}
if(bad_channel_ban(channel, user, argv[1], &victimCount, victims))
{
- reply("CSMSG_MASK_PROTECTED", argv[1]);
+ if(cmd)
+ reply("CSMSG_MASK_PROTECTED", argv[1]);
return 0;
}
/* We dont actually want a victem count if were banning a mask manually, IMO -Rubin*/
#ifdef entropy_lameness
if((victimCount > 4) && ((victimCount * 3) > channel->members.used) && !IsOper(user))
{
- reply("CSMSG_LAME_MASK", argv[1]);
+ if(cmd)
+ reply("CSMSG_LAME_MASK", argv[1]);
return 0;
}
#endif
if((action == ACTION_KICK) && (victimCount == 0))
{
- reply("CSMSG_NO_MATCHING_USERS", channel->name, argv[1]);
+ if(cmd)
+ reply("CSMSG_NO_MATCHING_USERS", channel->name, argv[1]);
return 0;
}
that 'ban' is a valid ban mask before sanitizing it. */
sanitize_ircmask(ban);
- if(action & ACTION_ADD_BAN)
+ if(action & ACTION_ADD_LAMER)
{
struct banData *bData, *next;
- if(channel->channel_info->banCount >= chanserv_conf.max_chan_bans)
+ if(channel->channel_info->banCount >= chanserv_conf.max_chan_bans) /* ..lamers.. */
{
- reply("CSMSG_MAXIMUM_BANS", chanserv_conf.max_chan_bans);
+ if(cmd)
+ reply("CSMSG_MAXIMUM_LAMERS", chanserv_conf.max_chan_bans); /* ..lamers.. */
free(ban);
return 0;
}
- if(action & ACTION_ADD_TIMED_BAN)
+ if(action & ACTION_ADD_TIMED_LAMER)
{
duration = ParseInterval(argv[2]);
if(duration < 15)
{
- reply("CSMSG_DURATION_TOO_LOW");
+ if(cmd)
+ reply("CSMSG_DURATION_TOO_LOW");
free(ban);
return 0;
}
else if(duration > (86400 * 365 * 2))
{
- reply("CSMSG_DURATION_TOO_HIGH");
+ if(cmd)
+ reply("CSMSG_DURATION_TOO_HIGH");
free(ban);
return 0;
}
}
+ /* lamers... */
for(bData = channel->channel_info->bans; bData; bData = next)
{
if(match_ircglobs(bData->mask, ban))
if(!cmd)
{
- /* automated kickban */
+ /* automated kickban, dont reply */
}
else if(duration)
- reply("CSMSG_BAN_EXTENDED", ban, intervalString(interval, duration, user->handle_info));
+ reply("CSMSG_LAMER_EXTENDED", ban, intervalString(interval, duration, user->handle_info));
else
- reply("CSMSG_BAN_ADDED", name, channel->name);
+ reply("CSMSG_LAMER_ADDED", name, channel->name);
goto post_add_ban;
}
}
if(cmd)
- reply("CSMSG_REDUNDANT_BAN", name, channel->name);
+ reply("CSMSG_REDUNDANT_LAMER", name, channel->name);
free(ban);
return 0;
{
/* No response, since it was automated. */
}
- else if(action & ACTION_ADD_BAN)
+ else if(action & ACTION_ADD_LAMER)
{
if(duration)
- reply("CSMSG_TIMED_BAN_ADDED", name, channel->name, intervalString(interval, duration, user->handle_info));
+ reply("CSMSG_TIMED_LAMER_ADDED", name, channel->name, intervalString(interval, duration, user->handle_info));
else
- reply("CSMSG_BAN_ADDED", name, channel->name);
+ reply("CSMSG_LAMER_ADDED", name, channel->name);
}
else if((action & (ACTION_BAN | ACTION_KICK)) == (ACTION_BAN | ACTION_KICK))
reply("CSMSG_KICK_BAN_DONE", name, channel->name);
return eject_user(CSFUNC_ARGS, ACTION_BAN);
}
-static CHANSERV_FUNC(cmd_addban)
+static CHANSERV_FUNC(cmd_addlamer)
{
- return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_BAN);
+ return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_LAMER);
}
-static CHANSERV_FUNC(cmd_addtimedban)
+static CHANSERV_FUNC(cmd_addtimedlamer)
{
- return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_BAN | ACTION_ADD_TIMED_BAN);
+ return eject_user(CSFUNC_ARGS, ACTION_KICK | ACTION_BAN | ACTION_ADD_LAMER | ACTION_ADD_TIMED_LAMER);
}
static struct mod_chanmode *
}
}
- if(action & ACTION_DEL_BAN)
+ if(action & ACTION_DEL_LAMER)
{
struct banData *ban, *next;
- ban = channel->channel_info->bans;
+ ban = channel->channel_info->bans; /* lamers */
while(ban)
{
if(actee)
return unban_user(CSFUNC_ARGS, ACTION_UNBAN);
}
-static CHANSERV_FUNC(cmd_delban)
+static CHANSERV_FUNC(cmd_dellamer)
{
/* it doesn't necessarily have to remove the channel ban - may want
to make that an option. */
- return unban_user(CSFUNC_ARGS, ACTION_UNBAN | ACTION_DEL_BAN);
+ return unban_user(CSFUNC_ARGS, ACTION_UNBAN | ACTION_DEL_LAMER);
}
static CHANSERV_FUNC(cmd_unbanme)
/* remove permanent bans if the user has the proper access. */
if(uData->access >= UL_MANAGER)
- flags |= ACTION_DEL_BAN;
+ flags |= ACTION_DEL_LAMER;
argv[1] = user->nick;
return unban_user(user, channel, 2, argv, cmd, flags);
continue;
sbuf.used = 0;
string_buffer_append_printf(&sbuf, "[%s (%d", cData->channel->name, uData->access);
- if(uData->flags != USER_AUTO_OP)
+ if(uData->flags == USER_AUTO_OP)
string_buffer_append(&sbuf, ',');
if(IsUserSuspended(uData))
string_buffer_append(&sbuf, 's');
if(IsUserAutoOp(uData))
{
- if(uData->access >= cData->lvlOpts[lvlGiveOps])
+ if(uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/)
string_buffer_append(&sbuf, 'o');
- else if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+ else if(uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
string_buffer_append(&sbuf, 'h');
- else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON /*cData->lvlOpts[lvlGiveVoice]*/)
string_buffer_append(&sbuf, 'v');
}
if(IsUserAutoInvite(uData) && (uData->access >= cData->lvlOpts[lvlInviteMe]))
return 1;
}
-/* This is never used... */
+/* This is never used...
static void
zoot_list(struct listData *list)
{
}
}
}
+*/
static void
def_list(struct listData *list)
send_message(list->user, list->bot, "CSMSG_ACCESS_SEARCH_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest), list->search);
else
send_message(list->user, list->bot, "CSMSG_ACCESS_ALL_HEADER", list->channel->name, user_level_name_from_level(list->lowest), user_level_name_from_level(list->highest));
- table_send(list->bot, list->user->nick, 0, NULL, list->table);
if(list->table.length == 1)
{
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
lData.search = (argc > 1) ? argv[1] : NULL;
send_list = def_list;
/* What does the following line do exactly?? */
- (void)zoot_list; /* since it doesn't show user levels */
+ /*(void)zoot_list; ** since it doesn't show user levels */
/* this does nothing!! -rubin
if(user->handle_info)
lData.table.contents[matches] = ary;
/* ary[0] = strtab(uData->access);*/
ary[0] = user_level_name_from_level(uData->access);
- /* TODO: replace above with func that returns static string
- * of userlevel for that level. eg OP/MANAGER etc. -rubin */
ary[1] = strtab(uData->access);
ary[2] = uData->handle->handle;
if(uData->present)
return 1;
}
+/* Remove this now that debugging is over? or improve it for
+ * users? Would it be better tied into USERS somehow? -Rubin */
+static CHANSERV_FUNC(cmd_pending)
+{
+ struct adduserPending *ap;
+ reply("CSMSG_ADDUSER_PENDING_HEADER");
+ 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");
+ return 1;
+}
+
static CHANSERV_FUNC(cmd_users)
{
return cmd_list_users(CSFUNC_ARGS, 1, UL_OWNER);
return cmd_list_users(CSFUNC_ARGS, 1, UL_HALFOP-1);
}
-static CHANSERV_FUNC(cmd_bans)
+static CHANSERV_FUNC(cmd_lamers)
{
struct helpfile_table tbl;
unsigned int matches = 0, timed = 0, ii;
char t_buffer[INTERVALLEN], e_buffer[INTERVALLEN], *search;
const char *msg_never, *triggered, *expires;
- struct banData *ban, **bans;
+ struct banData *ban, **bans; /* lamers */
if(argc > 1)
search = argv[1];
else
search = NULL;
- reply("CSMSG_BANS_HEADER", channel->name);
- bans = alloca(channel->channel_info->banCount * sizeof(struct banData *));
+ reply("CSMSG_LAMERS_HEADER", channel->name);
+ bans = alloca(channel->channel_info->banCount * sizeof(struct banData *)); /* lamers */
+ /* lamers */
for(ban = channel->channel_info->bans; ban; ban = ban->next)
{
if(search && !match_ircglobs(search, ban->mask))
return 1;
}
+/* bad_topic
+ *
+ * return + if the user does NOT have the right to set the topic, and
+ * the topic is changed.
+ */
static int
bad_topic(struct chanNode *channel, struct userNode *user, const char *new_topic)
{
struct chanData *cData = channel->channel_info;
if(check_user_level(channel, user, lvlEnfTopic, 1, 0))
return 0;
- if(cData->topic_mask)
- return !match_ircglob(new_topic, cData->topic_mask);
else if(cData->topic)
return irccasecmp(new_topic, cData->topic);
else
return 0;
}
+/* conform_topic
+ *
+ * Makes a givin topic fit into a givin topic mask and returns
+ * the results.
+ *
+ * topic_mask - the mask to conform to
+ * topic - the topic to make conform
+ * new_topic - the pre-allocated char* to put the new topic into
+ *
+ * modifies: new_topic
+ */
+void
+conform_topic(char* topic_mask, char* topic, char *new_topic)
+{
+ //char *topic_mask = cData->topic_mask;
+ char tchar;
+ int pos=0, starpos=-1, dpos=0, len;
+
+ while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
+ {
+ switch(tchar)
+ {
+ case '*':
+ if(starpos != -1)
+ {
+ strcpy(new_topic, "");
+ return;
+ }
+ len = strlen(topic);
+ if((dpos + len) > TOPICLEN)
+ len = TOPICLEN + 1 - dpos;
+ memcpy(new_topic+dpos, topic, len);
+ dpos += len;
+ starpos = pos;
+ break;
+ case '\\': tchar = topic_mask[pos++]; /* and fall through */
+ default: new_topic[dpos++] = tchar; break;
+ }
+ }
+ if((dpos > TOPICLEN) || tchar)
+ {
+ strcpy(new_topic, "");
+ return;
+ }
+ new_topic[dpos] = 0;
+ return;
+}
+
static CHANSERV_FUNC(cmd_topic)
{
struct chanData *cData;
cData = channel->channel_info;
if(argc < 2)
{
- if(cData->topic)
- {
- SetChannelTopic(channel, chanserv, cData->topic, 1);
- reply("CSMSG_TOPIC_SET", cData->topic);
+ if(cData->topic)
+ {
+ SetChannelTopic(channel, chanserv, cData->topic, 1);
+ reply("CSMSG_TOPIC_SET", cData->topic);
return 1;
- }
+ }
reply("CSMSG_NO_TOPIC", channel->name);
return 0;
/* If they say "!topic *", use an empty topic. */
if((topic[0] == '*') && (topic[1] == 0))
topic[0] = 0;
+
if(bad_topic(channel, user, topic))
{
- char *topic_mask = cData->topic_mask;
- if(topic_mask)
+ reply("CSMSG_TOPIC_LOCKED", channel->name);
+ return 0;
+ }
+ else
+ {
+ /* If there is a topicmask set, and the new topic doesnt match, make it */
+ if(cData->topic_mask && !match_ircglob(topic, cData->topic_mask))
{
- char new_topic[TOPICLEN+1], tchar;
- int pos=0, starpos=-1, dpos=0, len;
+ char *topic_mask = cData->topic_mask;
+ char new_topic[TOPICLEN+1];
- while((tchar = topic_mask[pos++]) && (dpos <= TOPICLEN))
- {
- switch(tchar)
- {
- case '*':
- if(starpos != -1)
- goto bad_mask;
- len = strlen(topic);
- if((dpos + len) > TOPICLEN)
- len = TOPICLEN + 1 - dpos;
- memcpy(new_topic+dpos, topic, len);
- dpos += len;
- starpos = pos;
- break;
- case '\\': tchar = topic_mask[pos++]; /* and fall through */
- default: new_topic[dpos++] = tchar; break;
- }
- }
- if((dpos > TOPICLEN) || tchar)
+ /* make a new topic fitting mask */
+ conform_topic(topic_mask, topic, new_topic);
+ if(!*new_topic)
{
- bad_mask:
+ /* Topic couldnt fit into mask, was too long */
reply("CSMSG_TOPICMASK_CONFLICT1", channel->name, topic_mask);
reply("CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
return 0;
}
- new_topic[dpos] = 0;
SetChannelTopic(channel, chanserv, new_topic, 1);
- } else {
- reply("CSMSG_TOPIC_LOCKED", channel->name);
- return 0;
}
+ else /* No mask set, just set the topic */
+ SetChannelTopic(channel, chanserv, topic, 1);
}
- else
- SetChannelTopic(channel, chanserv, topic, 1);
if(check_user_level(channel, user, lvlTopicSnarf, 1, 0))
{
reply("CSMSG_BAR");
uData = GetChannelUser(cData, user->handle_info);
- if(uData && (uData->access >= cData->lvlOpts[lvlGiveOps]))
+ if(uData && (uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/))
{
mod_chanmode_format(&cData->modes, modes);
reply("CSMSG_CHANNEL_TOPIC", cData->topic);
if(owner->access == UL_OWNER)
reply("CSMSG_CHANNEL_OWNER", owner->handle->handle);
reply("CSMSG_CHANNEL_USERS", cData->userCount);
- reply("CSMSG_CHANNEL_BANS", cData->banCount);
+ 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));
reply("CSMSG_NETWORK_USERS", dict_size(clients));
reply("CSMSG_NETWORK_OPERS", curr_opers.used);
reply("CSMSG_NETWORK_CHANNELS", registered_channels);
- reply("CSMSG_NETWORK_BANS", banCount);
+ reply("CSMSG_NETWORK_LAMERS", banCount);
reply("CSMSG_NETWORK_CHANUSERS", userCount);
reply("CSMSG_SERVICES_UPTIME", intervalString(interval, time(NULL) - boot_time, user->handle_info));
reply("CSMSG_BURST_LENGTH", intervalString(interval, burst_length, user->handle_info));
continue;
uData = GetChannelAccess(cData, mn->user->handle_info);
- if(!cData->lvlOpts[lvlGiveOps]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveOps]))
+ if(uData && uData->access >= UL_OP /* cData->lvlOpts[lvlGiveOps]*/)
{
if(!(mn->modes & MODE_CHANOP))
{
changes->args[used++].u.member = mn;
}
}
- else if(!cData->lvlOpts[lvlGiveHalfOps]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveHalfOps]))
+ else if(uData && uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
{
- if(!(mn->modes & MODE_HALFOP))
+ if(mn->modes & MODE_CHANOP)
{
- changes->args[used].mode = MODE_HALFOP;
+ changes->args[used].mode = MODE_REMOVE | MODE_CHANOP;
changes->args[used++].u.member = mn;
}
- if(mn->modes & MODE_CHANOP)
+ if(!(mn->modes & MODE_HALFOP))
{
- changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_CHANOP);
+ changes->args[used].mode = MODE_HALFOP;
changes->args[used++].u.member = mn;
}
+ /* why cant halfops keep voice
if(mn->modes & MODE_VOICE)
{
changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
changes->args[used++].u.member = mn;
}
+ */
}
- else if(!cData->lvlOpts[lvlGiveVoice]
- || (uData && uData->access >= cData->lvlOpts[lvlGiveVoice]))
+ else if(uData && uData->access >= UL_PEON /* cData->lvlOpts[lvlGiveVoice]*/)
{
if(mn->modes & MODE_CHANOP)
{
- changes->args[used].mode = MODE_REMOVE | (mn->modes & ~MODE_VOICE);
+ 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 | (mn->modes & ~MODE_VOICE);
+ changes->args[used].mode = MODE_REMOVE | MODE_HALFOP;
changes->args[used++].u.member = mn;
}
if(!(mn->modes & MODE_VOICE))
return 1;
}
+static CHANSERV_FUNC(cmd_last)
+{
+ int numoflines;
+
+ REQUIRE_PARAMS(1);
+
+ numoflines = (argc > 1) ? atoi(argv[1]) : 10;
+
+ if(numoflines < 1 || numoflines > 200)
+ {
+ reply("CSMSG_LAST_INVALID");
+ return 0;
+ }
+ ShowLog(user, channel, "*", "*", "*", "*", numoflines);
+ return 1;
+}
+
static CHANSERV_FUNC(cmd_events)
{
struct logSearch discrim;
}
switch(option)
{
+ /* removing these level sets..
case lvlGiveVoice:
if(value > cData->lvlOpts[lvlGiveOps])
{
return 0;
}
break;
+ */
case lvlSetters:
/* This test only applies to owners, since non-owners
* trying to set an option to above their level get caught
{
return channel_level_option(lvlEnfHalfOps, CSFUNC_ARGS);
}
-
+/*
static MODCMD_FUNC(chan_opt_giveops)
{
return channel_level_option(lvlGiveOps, CSFUNC_ARGS);
{
return channel_level_option(lvlGiveHalfOps, CSFUNC_ARGS);
}
-
+*/
static MODCMD_FUNC(chan_opt_enfmodes)
{
return channel_level_option(lvlEnfModes, CSFUNC_ARGS);
return channel_level_option(lvlSetters, CSFUNC_ARGS);
}
+/*
static MODCMD_FUNC(chan_opt_ctcpusers)
{
return channel_level_option(lvlCTCPUsers, CSFUNC_ARGS);
}
+*/
static MODCMD_FUNC(chan_opt_userinfo)
{
return channel_level_option(lvlUserInfo, CSFUNC_ARGS);
}
+/*
static MODCMD_FUNC(chan_opt_givevoice)
{
return channel_level_option(lvlGiveVoice, CSFUNC_ARGS);
}
+*/
static MODCMD_FUNC(chan_opt_topicsnarf)
{
return 1;
}
+static MODCMD_FUNC(chan_opt_voice)
+{
+ return channel_multiple_option(chVoice, CSFUNC_ARGS);
+}
+
static MODCMD_FUNC(chan_opt_protect)
{
return channel_multiple_option(chProtect, CSFUNC_ARGS);
return 1;
}
-static MODCMD_FUNC(user_opt_noautoop)
+static MODCMD_FUNC(user_opt_autoop)
{
struct userData *uData;
reply("CSMSG_NOT_USER", channel->name);
return 0;
}
- if(uData->access < channel->channel_info->lvlOpts[lvlGiveOps])
- return user_binary_option("CSMSG_USET_NOAUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
+ if(uData->access < UL_OP /*channel->channel_info->lvlOpts[lvlGiveOps]*/)
+ return user_binary_option("CSMSG_USET_AUTOVOICE", USER_AUTO_OP, CSFUNC_ARGS);
else
- return user_binary_option("CSMSG_USET_NOAUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
+ return user_binary_option("CSMSG_USET_AUTOOP", USER_AUTO_OP, CSFUNC_ARGS);
+ /* TODO: add halfops error message? or is the op one generic enough? */
}
static MODCMD_FUNC(user_opt_autoinvite)
{
char *options[] =
{
- "NoAutoOp", "AutoInvite", "Info"
+ "AutoOp", "AutoInvite", "Info"
};
if(!uset_shows_list.size)
if(channel->join_flooded)
{
- /* don't automatically give ops or voice during a join flood */
+ /* don't automatically give non users ops or voice during a join flood */
}
- else if(cData->lvlOpts[lvlGiveOps] == 0)
- modes |= MODE_CHANOP;
- else if(cData->lvlOpts[lvlGiveHalfOps] == 0)
- modes |= MODE_HALFOP;
- else if(cData->lvlOpts[lvlGiveVoice] == 0)
+ /* EVERYONE is to get voice */
+ else if(cData->chOpts[chVoice] == 'a')
modes |= MODE_VOICE;
greeting = cData->greeting;
uData = GetTrueChannelAccess(cData, handle);
if(uData && !IsUserSuspended(uData))
{
- /* Ops and above were handled by the above case. */
+ /* non users getting voice are handled above. */
if(IsUserAutoOp(uData))
{
- if(uData->access >= cData->lvlOpts[lvlGiveOps])
+ if(uData->access >= UL_OP /*cData->lvlOpts[lvlGiveOps]*/)
modes |= MODE_CHANOP;
- if(uData->access >= cData->lvlOpts[lvlGiveHalfOps])
+ if(uData->access >= UL_HALFOP /*cData->lvlOpts[lvlGiveHalfOps]*/)
modes |= MODE_HALFOP;
- else if(uData->access >= cData->lvlOpts[lvlGiveVoice])
+ else if(uData->access >= UL_PEON && cData->chOpts[chVoice] == 'p')
modes |= MODE_VOICE;
}
if(uData->access >= UL_PRESENT)
if(IsUserAutoOp(channel))
{
- if(channel->access >= cn->channel_info->lvlOpts[lvlGiveOps])
+ if(channel->access >= UL_OP /* cn->channel_info->lvlOpts[lvlGiveOps] */)
change.args[0].mode = MODE_CHANOP;
- else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveHalfOps])
+ else if(channel->access >= UL_HALFOP /* cn->channel_info->lvlOpts[lvlGiveHalfOps]*/)
change.args[0].mode = MODE_HALFOP;
- else if(channel->access >= cn->channel_info->lvlOpts[lvlGiveVoice])
+ else if(channel->access >= UL_PEON /* cn->channel_info->lvlOpts[lvlGiveVoice]*/)
change.args[0].mode = MODE_VOICE;
else
change.args[0].mode = 0;
cData = channel->channel_info;
if(bad_topic(channel, user, channel->topic))
- {
+ { /* User doesnt have privs to set topics. Undo it */
send_message(user, chanserv, "CSMSG_TOPIC_LOCKED", channel->name);
- if(cData->topic_mask && match_ircglob(old_topic, cData->topic_mask))
- SetChannelTopic(channel, chanserv, old_topic, 1);
- else if(cData->topic)
- SetChannelTopic(channel, chanserv, cData->topic, 1);
+ SetChannelTopic(channel, chanserv, old_topic, 1);
return 1;
}
+ /* If there is a topic mask set, and the new topic doesnt match,
+ * set the topic to mask + new_topic */
+ if(cData->topic_mask && !match_ircglob(channel->topic, cData->topic_mask))
+ {
+ char new_topic[TOPICLEN+1];
+ conform_topic(cData->topic_mask, channel->topic, new_topic);
+ if(*new_topic)
+ {
+ SetChannelTopic(channel, chanserv, new_topic, 1);
+ /* and fall through to topicsnarf code below.. */
+ }
+ else /* Topic couldnt fit into mask, was too long */
+ {
+ SetChannelTopic(channel, chanserv, old_topic, 1);
+ send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT1", channel->name, cData->topic_mask);
+ send_message(user, chanserv, "CSMSG_TOPICMASK_CONFLICT2", TOPICLEN);
+ return 1;
+ }
+ }
/* With topicsnarf, grab the topic and save it as the default topic. */
if(check_user_level(channel, user, lvlTopicSnarf, 0, 0))
{
/* free form text */
"DefaultTopic", "TopicMask", "Greeting", "UserGreeting", "Modes",
/* options based on user level */
- "PubCmd", "InviteMe", "UserInfo", "GiveVoice", "GiveHalfOps", "GiveOps", "EnfOps",
- "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", "CtcpUsers",
+ "PubCmd", "InviteMe", "UserInfo",/* "GiveVoice", "GiveHalfOps", "GiveOps", */ "EnfOps",
+ "EnfHalfOps", "EnfModes", "EnfTopic", "TopicSnarf", "Setters", /*"CtcpUsers", */
/* multiple choice options */
"CtcpReaction", "Protect", "Toys", "TopicRefresh",
/* binary options */
uData = add_channel_user(chan, handle, access, last_seen, inf);
uData->flags = flags ? strtoul(flags, NULL, 0) : 0;
+
+ /* Upgrade: set autoop to the inverse of noautoop */
+ if(chanserv_read_version < 2)
+ {
+ /* if noautoop is true, set autoop false, and vice versa */
+ if(uData->flags & USER_NOAUTO_OP)
+ uData->flags = uData->flags & ~USER_AUTO_OP;
+ else
+ uData->flags = uData->flags | USER_AUTO_OP;
+ log_module(CS_LOG, LOG_INFO, "UPGRADE: to db version 2 from %u. Changing flag to %d for %s in %s.", chanserv_read_version, uData->flags, key, chan->channel->name);
+ }
+
}
static void
dnr->set = 0;
}
+static void
+chanserv_version_read(struct dict *section)
+{
+ /* global var.. */
+ char *str;
+ str = database_get_data(section, KEY_VERSION_NUMBER, RECDB_QSTRING);
+ if(str)
+ chanserv_read_version = atoi(str);
+ log_module(CS_LOG, LOG_DEBUG, "Chanserv db version is %d.", chanserv_read_version);
+}
+
static int
chanserv_saxdb_read(struct dict *database)
{
struct dict *section;
dict_iterator_t it;
+ if((section = database_get_data(database, KEY_VERSION_CONTROL, RECDB_OBJECT)))
+ chanserv_version_read(section);
+
if((section = database_get_data(database, KEY_NOTE_TYPES, RECDB_OBJECT)))
for(it = dict_first(section); it; it = iter_next(it))
chanserv_note_type_read(iter_key(it), iter_data(it));
dict_iterator_t it;
struct chanData *channel;
+ /* Version Control*/
+ saxdb_start_record(ctx, KEY_VERSION_CONTROL, 1);
+ saxdb_write_int(ctx, KEY_VERSION_NUMBER, CHANSERV_DB_VERSION);
+ saxdb_end_record(ctx);
+
/* Notes */
saxdb_start_record(ctx, KEY_NOTE_TYPES, 1);
for(it = dict_first(note_types); it; it = iter_next(it))
DEFINE_COMMAND(createnote, 5, 0, "level", "800", NULL);
DEFINE_COMMAND(removenote, 2, 0, "level", "800", NULL);
+ DEFINE_COMMAND(pending, 1, MODCMD_REQUIRE_AUTHED, "flags", "+helping", NULL);
+
DEFINE_COMMAND(unregister, 1, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "flags", "+loghostmask", NULL);
DEFINE_COMMAND(merge, 2, MODCMD_REQUIRE_AUTHED|MODCMD_REQUIRE_REGCHAN, "access", "owner", NULL);
DEFINE_COMMAND(voice, 2, MODCMD_REQUIRE_CHANNEL, "template", "op", NULL);
DEFINE_COMMAND(devoice, 2, MODCMD_REQUIRE_CHANNEL, "template", "op", NULL);
- DEFINE_COMMAND(kickban, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
- DEFINE_COMMAND(kick, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
- DEFINE_COMMAND(ban, 2, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
- DEFINE_COMMAND(unban, 2, 0, "template", "op", NULL);
- DEFINE_COMMAND(unbanall, 1, 0, "template", "op", NULL);
- DEFINE_COMMAND(unbanme, 1, MODCMD_REQUIRE_CHANUSER, "template", "op", NULL);
+ DEFINE_COMMAND(kickban, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+ DEFINE_COMMAND(kick, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+ DEFINE_COMMAND(ban, 2, MODCMD_REQUIRE_REGCHAN, "template", "hop", NULL);
+ DEFINE_COMMAND(unban, 2, 0, "template", "hop", NULL);
+ DEFINE_COMMAND(unbanall, 1, 0, "template", "hop", NULL);
+ DEFINE_COMMAND(unbanme, 1, MODCMD_REQUIRE_CHANUSER, "template", "hop", NULL);
DEFINE_COMMAND(open, 1, MODCMD_REQUIRE_CHANUSER, "template", "op", NULL);
- DEFINE_COMMAND(topic, 1, MODCMD_REQUIRE_REGCHAN, "template", "op", "flags", "+never_csuspend", NULL);
+ DEFINE_COMMAND(topic, 1, MODCMD_REQUIRE_REGCHAN, "template", "hop", "flags", "+never_csuspend", NULL);
DEFINE_COMMAND(mode, 1, MODCMD_REQUIRE_REGCHAN, "template", "op", NULL);
DEFINE_COMMAND(inviteme, 1, MODCMD_REQUIRE_CHANNEL, "access", "1", NULL);
DEFINE_COMMAND(invite, 1, MODCMD_REQUIRE_CHANNEL, "access", "manager", NULL);
DEFINE_COMMAND(wipeinfo, 2, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
DEFINE_COMMAND(resync, 1, MODCMD_REQUIRE_CHANUSER, "access", "manager", NULL);
- DEFINE_COMMAND(events, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "350", NULL);
- DEFINE_COMMAND(addban, 2, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
- DEFINE_COMMAND(addtimedban, 3, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
- DEFINE_COMMAND(delban, 2, MODCMD_REQUIRE_REGCHAN, "access", "250", NULL);
+ DEFINE_COMMAND(events, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "manager", NULL);
+ DEFINE_COMMAND(last, 1, MODCMD_REQUIRE_REGCHAN, "flags", "+nolog", "access", "manager", NULL);
+ DEFINE_COMMAND(addlamer, 2, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
+ DEFINE_COMMAND(addtimedlamer, 3, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
+
+ /* if you change dellamer access, see also places
+ * like unbanme which have manager hardcoded. */
+ DEFINE_COMMAND(dellamer, 2, MODCMD_REQUIRE_REGCHAN, "access", "manager", NULL);
DEFINE_COMMAND(uset, 1, MODCMD_REQUIRE_CHANUSER, "access", "1", NULL);
- DEFINE_COMMAND(bans, 1, MODCMD_REQUIRE_REGCHAN, "access", "1", "flags", "+nolog", NULL);
+ DEFINE_COMMAND(lamers, 1, MODCMD_REQUIRE_REGCHAN, "access", "1", "flags", "+nolog", NULL);
+
DEFINE_COMMAND(peek, 1, MODCMD_REQUIRE_REGCHAN, "access", "op", "flags", "+nolog", NULL);
DEFINE_COMMAND(myaccess, 1, MODCMD_REQUIRE_AUTHED, NULL);
DEFINE_CHANNEL_OPTION(modes);
DEFINE_CHANNEL_OPTION(enfops);
DEFINE_CHANNEL_OPTION(enfhalfops);
- DEFINE_CHANNEL_OPTION(giveops);
+ /*DEFINE_CHANNEL_OPTION(giveops);
DEFINE_CHANNEL_OPTION(givehalfops);
+ */
+ DEFINE_CHANNEL_OPTION(voice);
DEFINE_CHANNEL_OPTION(protect);
DEFINE_CHANNEL_OPTION(enfmodes);
DEFINE_CHANNEL_OPTION(enftopic);
DEFINE_CHANNEL_OPTION(pubcmd);
- DEFINE_CHANNEL_OPTION(givevoice);
+ /*DEFINE_CHANNEL_OPTION(givevoice);
+ */
DEFINE_CHANNEL_OPTION(userinfo);
DEFINE_CHANNEL_OPTION(dynlimit);
DEFINE_CHANNEL_OPTION(topicsnarf);
DEFINE_CHANNEL_OPTION(toys);
DEFINE_CHANNEL_OPTION(setters);
DEFINE_CHANNEL_OPTION(topicrefresh);
- DEFINE_CHANNEL_OPTION(ctcpusers);
+// DEFINE_CHANNEL_OPTION(ctcpusers);
DEFINE_CHANNEL_OPTION(ctcpreaction);
DEFINE_CHANNEL_OPTION(inviteme);
if(off_channel > 1)
modcmd_register(chanserv_module, "set topic", chan_opt_defaulttopic, 1, 0, NULL);
/* User options */
- DEFINE_USER_OPTION(noautoop);
DEFINE_USER_OPTION(autoinvite);
DEFINE_USER_OPTION(info);
+ DEFINE_USER_OPTION(autoop);
/* Alias uset autovoice to uset autoop. */
- modcmd_register(chanserv_module, "uset noautovoice", user_opt_noautoop, 1, 0, NULL);
+ modcmd_register(chanserv_module, "uset autovoice", user_opt_autoop, 1, 0, NULL);
note_types = dict_new();
dict_set_free_data(note_types, chanserv_deref_note_type);
service_register(chanserv)->trigger = '!';
reg_chanmsg_func('\001', chanserv, chanserv_ctcp_check);
}
+
saxdb_register("ChanServ", chanserv_saxdb_read, chanserv_saxdb_write);
if(chanserv_conf.channel_expire_frequency)